implement case errors

Author: James Cor

sql/planbuilder/scalar.go

@@ -106,8 +106,8 @@ func (b *Builder) buildScalar(inScope *scope, e ast.Expr) (ex sql.Expression) {
 	case *ast.NullVal:
 		return expression.NewLiteral(nil, types.Null)
 	case *ast.ColName:
-		if v.Metadata != nil {
-			return b.ConvertVal(v.Metadata)
+		if v.StoredProcVal != nil {
+			return b.ConvertVal(v.StoredProcVal)
 		}
 		dbName := strings.ToLower(v.Qualifier.DbQualifier.String())
 		tblName := strings.ToLower(v.Qualifier.Name.String())

sql/planbuilder/show.go

@@ -604,8 +604,8 @@ func (b *Builder) buildAsOfExpr(inScope *scope, time ast.Expr) sql.Expression {
 		}
 		return expression.NewLiteral(ret.(string), types.LongText)
 	case *ast.ColName:
-		if v.Metadata != nil {
-			return b.buildAsOfExpr(inScope, v.Metadata)
+		if v.StoredProcVal != nil {
+			return b.buildAsOfExpr(inScope, v.StoredProcVal)
 		}
 		sysVar, _, ok := b.buildSysVar(v, ast.SetScope_None)
 		if ok {

sql/procedures/interpreter_logic.go

@@ -39,42 +39,6 @@ type Parameter struct {
 	Value any
 }
 
-func unreplaceVariablesInExpr(stack *InterpreterStack, expr ast.SQLNode) ast.SQLNode {
-	switch e := expr.(type) {
-	case *ast.AliasedExpr:
-		newExpr := unreplaceVariablesInExpr(stack, e.Expr)
-		e.Expr = newExpr.(ast.Expr)
-	case *ast.BinaryExpr:
-		newLeftExpr := unreplaceVariablesInExpr(stack, e.Left)
-		newRightExpr := unreplaceVariablesInExpr(stack, e.Right)
-		e.Left = newLeftExpr.(ast.Expr)
-		e.Right = newRightExpr.(ast.Expr)
-	case *ast.ComparisonExpr:
-		newLeftExpr := unreplaceVariablesInExpr(stack, e.Left)
-		newRightExpr := unreplaceVariablesInExpr(stack, e.Right)
-		e.Left = newLeftExpr.(ast.Expr)
-		e.Right = newRightExpr.(ast.Expr)
-	case *ast.FuncExpr:
-		for i := range e.Exprs {
-			newExpr := unreplaceVariablesInExpr(stack, e.Exprs[i])
-			e.Exprs[i] = newExpr.(ast.SelectExpr)
-		}
-	case *ast.NotExpr:
-		newExpr := unreplaceVariablesInExpr(stack, e.Expr)
-		e.Expr = newExpr.(ast.Expr)
-	case *ast.Set:
-		for _, setExpr := range e.Exprs {
-			newExpr := unreplaceVariablesInExpr(stack, setExpr.Expr)
-			setExpr.Expr = newExpr.(ast.Expr)
-		}
-	case *ast.SQLVal:
-		if oldVal, ok := stack.replaceMap[expr]; ok {
-			return oldVal
-		}
-	}
-	return expr
-}
-
 func replaceVariablesInExpr(stack *InterpreterStack, expr ast.SQLNode) (ast.SQLNode, error) {
 	switch e := expr.(type) {
 	case *ast.AliasedExpr:
@@ -136,8 +100,11 @@ func replaceVariablesInExpr(stack *InterpreterStack, expr ast.SQLNode) (ast.SQLN
 			return expr, nil
 		}
 		newExpr := iv.ToAST()
-		stack.replaceMap[newExpr] = e
-		return newExpr, nil
+		return &ast.ColName{
+			Name:          e.Name,
+			Qualifier:     e.Qualifier,
+			StoredProcVal: newExpr,
+		}, nil
 	}
 	return expr, nil
 }
@@ -207,12 +174,6 @@ func Call(ctx *sql.Context, iNode InterpreterNode, params []*Parameter) (any, er
 			}
 			rowIters = append(rowIters, rowIter)
 
-			for i := range selectStmt.SelectExprs {
-				newNode := unreplaceVariablesInExpr(&stack, selectStmt.SelectExprs[i])
-				selectStmt.SelectExprs[i] = newNode.(ast.SelectExpr)
-			}
-			stack.replaceMap = map[ast.SQLNode]ast.SQLNode{}
-
 		case OpCode_Declare:
 			declareStmt := operation.PrimaryData.(*ast.Declare)
 			for _, decl := range declareStmt.Variables.Names {
@@ -259,14 +220,9 @@ func Call(ctx *sql.Context, iNode InterpreterNode, params []*Parameter) (any, er
 				return nil, err
 			}
 
-			for i := range selectStmt.SelectExprs {
-				newNode := unreplaceVariablesInExpr(&stack, selectStmt.SelectExprs[i])
-				selectStmt.SelectExprs[i] = newNode.(ast.SelectExpr)
-			}
-			stack.replaceMap = map[ast.SQLNode]ast.SQLNode{}
-
 		case OpCode_Exception:
-			// TODO: implement
+			return nil, operation.Error
+
 		case OpCode_Execute:
 			// TODO: replace variables
 			stmt, err := replaceVariablesInExpr(&stack, operation.PrimaryData)
@@ -279,9 +235,6 @@ func Call(ctx *sql.Context, iNode InterpreterNode, params []*Parameter) (any, er
 			}
 			rowIters = append(rowIters, rowIter)
 
-			stmt = unreplaceVariablesInExpr(&stack, stmt)
-			stack.replaceMap = map[ast.SQLNode]ast.SQLNode{}
-
 		case OpCode_Goto:
 			// We must compare to the index - 1, so that the increment hits our target
 			if counter <= operation.Index {
@@ -341,12 +294,6 @@ func Call(ctx *sql.Context, iNode InterpreterNode, params []*Parameter) (any, er
 				counter = operation.Index - 1 // index of the else block, offset by 1
 			}
 
-			for i := range selectStmt.SelectExprs {
-				newNode := unreplaceVariablesInExpr(&stack, selectStmt.SelectExprs[i])
-				selectStmt.SelectExprs[i] = newNode.(ast.SelectExpr)
-			}
-			stack.replaceMap = map[ast.SQLNode]ast.SQLNode{}
-
 		case OpCode_ScopeBegin:
 			stack.PushScope()
 		case OpCode_ScopeEnd:

sql/procedures/interpreter_operation.go

@@ -36,4 +36,5 @@ type InterpreterOperation struct {
 	SecondaryData []string      // This represents auxiliary data, such as bindings, strictness, etc.
 	Target        string        // This is the variable that will store the results (if applicable)
 	Index         int           // This is the index that should be set for operations that move the function counter
+	Error         error         // This is the error that should be returned for OpCode_Exception
 }

sql/procedures/interpreter_stack.go

@@ -123,7 +123,6 @@ type InterpreterScopeDetails struct {
 // general purpose.
 type InterpreterStack struct {
 	stack      *Stack[*InterpreterScopeDetails]
-	replaceMap map[ast.SQLNode]ast.SQLNode
 }
 
 // NewInterpreterStack creates a new InterpreterStack.
@@ -135,7 +134,6 @@ func NewInterpreterStack() InterpreterStack {
 	})
 	return InterpreterStack{
 		stack:      stack,
-		replaceMap: map[ast.SQLNode]ast.SQLNode{},
 	}
 }
 

sql/procedures/parse.go

@@ -15,6 +15,8 @@
 package procedures
 
 import (
+	"github.com/dolthub/vitess/go/mysql"
+
 	ast "github.com/dolthub/vitess/go/vt/sqlparser"
 )
 
@@ -153,7 +155,16 @@ func ConvertStmt(ops *[]*InterpreterOperation, stack *InterpreterStack, stmt ast
 
 			caseOp.Index = len(*ops) // start of next case
 		}
-		if s.Else != nil {
+		if s.Else == nil {
+			// throw an error if when there is no else block
+			// this is just an empty case statement that will always hit the else
+			// todo: alternatively, use an error opcode
+			errOp := &InterpreterOperation{
+				OpCode: OpCode_Exception,
+				Error:  mysql.NewSQLError(1339, "20000", "Case not found for CASE statement"),
+			}
+			*ops = append(*ops, errOp)
+		} else {
 			for _, elseStmt := range s.Else {
 				if err := ConvertStmt(ops, stack, elseStmt); err != nil {
 					return err