Merge branch 'james/proc' of github.com:dolthub/go-mysql-server into james/proc

Author: James Cor

sql/procedures/interpreter_logic.go

@@ -147,6 +147,9 @@ func replaceVariablesInExpr(ctx *sql.Context, stack *InterpreterStack, expr ast.
 		if e.AsOf == nil && asOf != nil {
 			e.AsOf = asOf.Time
 		}
+		if len(e.ProcName.Qualifier.String()) == 0 {
+			e.ProcName.Qualifier = ast.NewTableIdent(stack.GetDatabase())
+		}
 	case *ast.Limit:
 		newOffset, err := replaceVariablesInExpr(ctx, stack, e.Offset, asOf)
 		if err != nil {
@@ -251,12 +254,18 @@ func replaceVariablesInExpr(ctx *sql.Context, stack *InterpreterStack, expr ast.
 			e.Values[i] = newExpr.(ast.ValTuple)
 		}
 	case *ast.Insert:
+		if asOf != nil {
+			return nil, sql.ErrProcedureCallAsOfReadOnly.New()
+		}
 		newExpr, err := replaceVariablesInExpr(ctx, stack, e.Rows, asOf)
 		if err != nil {
 			return nil, err
 		}
 		e.Rows = newExpr.(ast.InsertRows)
 	case *ast.Delete:
+		if asOf != nil {
+			return nil, sql.ErrProcedureCallAsOfReadOnly.New()
+		}
 		if e.Where != nil {
 			newExpr, err := replaceVariablesInExpr(ctx, stack, e.Where.Expr, asOf)
 			if err != nil {
@@ -265,6 +274,9 @@ func replaceVariablesInExpr(ctx *sql.Context, stack *InterpreterStack, expr ast.
 			e.Where.Expr = newExpr.(ast.Expr)
 		}
 	case *ast.Update:
+		if asOf != nil {
+			return nil, sql.ErrProcedureCallAsOfReadOnly.New()
+		}
 		if e.Where != nil {
 			newExpr, err := replaceVariablesInExpr(ctx, stack, e.Where.Expr, asOf)
 			if err != nil {
@@ -706,6 +718,42 @@ func execOp(ctx *sql.Context, runner sql.StatementRunner, stack *InterpreterStac
 			}
 		}
 
+	case OpCode_Call:
+		stmt, err := replaceVariablesInExpr(ctx, stack, operation.PrimaryData, asOf)
+		if err != nil {
+			return 0, nil, nil, nil, err
+		}
+		// put stack variables into session variables
+		callStmt := stmt.(*ast.Call)
+		stackToParam := make(map[*InterpreterVariable]*sql.StoredProcParam)
+		for _, param := range callStmt.Params {
+			colName, isColName := param.(*ast.ColName)
+			if !isColName {
+				continue
+			}
+			paramName := colName.Name.String()
+			iv := stack.GetVariable(paramName)
+			if iv == nil {
+				continue
+			}
+			spp := &sql.StoredProcParam{
+				Type:  iv.Type,
+				Value: iv.Value,
+			}
+			ctx.Session.NewStoredProcParam(paramName, spp)
+			stackToParam[iv] = spp
+		}
+		sch, rowIter, err := query(ctx, runner, callStmt)
+		if err != nil {
+			return 0, nil, nil, nil, err
+		}
+		// assign stored proc params to stack variables
+		for iv, spp := range stackToParam {
+			iv.Value = spp.Value
+		}
+
+		return counter, sch, nil, rowIter, err
+
 	case OpCode_If:
 		selectStmt := operation.PrimaryData.(*ast.Select)
 		if selectStmt.SelectExprs == nil {
@@ -828,6 +876,9 @@ func Call(ctx *sql.Context, iNode InterpreterNode) (sql.RowIter, *InterpreterSta
 	var retSch sql.Schema
 	runner := iNode.GetRunner()
 	statements := iNode.GetStatements()
+	if dbNode, isDbNode := iNode.(sql.Databaser); isDbNode {
+		stack.SetDatabase(dbNode.Database().Name())
+	}
 	for {
 		counter++
 		if counter < 0 {

sql/procedures/interpreter_operation.go

@@ -23,6 +23,7 @@ const (
 	OpCode_Fetch
 	OpCode_Close
 	OpCode_Set
+	OpCode_Call
 	OpCode_If
 	OpCode_Goto
 	OpCode_Execute

sql/procedures/interpreter_stack.go

@@ -152,6 +152,9 @@ type InterpreterScopeDetails struct {
 
 	// labels mark the counter of the start of a loop or block.
 	labels map[string]int
+
+	// database is the current database for this scope.
+	database string
 }
 
 // InterpreterStack represents the working information that an interpreter will use during execution. It is not exactly
@@ -304,6 +307,21 @@ func (is *InterpreterStack) NewLabel(name string, index int) {
 	is.stack.Peek().labels[name] = index
 }
 
+// GetDatabase returns the current database for this scope.
+func (is *InterpreterStack) GetDatabase() string {
+	for i := 0; i < is.stack.Len(); i++ {
+		if db := is.stack.PeekDepth(i).database; db != "" {
+			return db
+		}
+	}
+	return ""
+}
+
+// SetDatabase sets the current database for this scope.
+func (is *InterpreterStack) SetDatabase(db string) {
+	is.stack.Peek().database = db
+}
+
 // GetLabel traverses the stack (starting from the top) to find a label with a matching name. Returns -1 if no
 // variable was found.
 func (is *InterpreterStack) GetLabel(name string) int {

sql/procedures/parse.go

@@ -141,6 +141,13 @@ func ConvertStmt(ops *[]*InterpreterOperation, stack *InterpreterStack, stmt ast
 		}
 		*ops = append(*ops, setOp)
 
+	case *ast.Call:
+		callOp := &InterpreterOperation{
+			OpCode:      OpCode_Call,
+			PrimaryData: s,
+		}
+		*ops = append(*ops, callOp)
+
 	case *ast.IfStatement:
 		var ifElseGotoOps []*InterpreterOperation
 		for _, ifCond := range s.Conditions {