return error for ddl in create proc statements

Author: James Cor

enginetest/queries/procedure_queries.go

@@ -2823,6 +2823,64 @@ var ProcedureCreateInSubroutineTests = []ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "procedure must not contain CREATE TABLE",
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "create procedure p() create table t (pk int);",
+				ExpectedErrStr: "creating tables in stored procedures is currently unsupported and will be added in a future release",
+			},
+			{
+				Query: "create procedure p() begin create table t (pk int); end;",
+				ExpectedErrStr: "creating tables in stored procedures is currently unsupported and will be added in a future release",
+			},
+		},
+	},
+	{
+		Name: "procedure must not contain CREATE TRIGGER",
+		SetUpScript: []string{
+			"create table t (i int);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "create procedure p() create trigger trig before insert on t for each row begin select 1; end;",
+				ExpectedErrStr: "creating triggers in stored procedures is currently unsupported and will be added in a future release",
+			},
+			{
+				Query: "create procedure p() begin create trigger trig before insert on t for each row begin select 1; end; end;",
+				ExpectedErrStr: "creating triggers in stored procedures is currently unsupported and will be added in a future release",
+			},
+		},
+	},
+	{
+		Name: "procedure must not contain CREATE DB",
+		SetUpScript: []string{},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "create procedure p() create database procdb;",
+				ExpectedErrStr: "creating databases in stored procedures is currently unsupported and will be added in a future release",
+			},
+			{
+				Query: "create procedure p() begin create database procdb; end;",
+				ExpectedErrStr: "creating databases in stored procedures is currently unsupported and will be added in a future release",
+			},
+		},
+	},
+	{
+		Name: "procedure must not contain CREATE VIEW",
+		SetUpScript: []string{},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "create procedure p() create view v as select 1;",
+				ExpectedErrStr: "creating views in stored procedures is currently unsupported and will be added in a future release",
+			},
+			{
+				Query: "create procedure p() begin create view v as select 1; end;",
+				ExpectedErrStr: "creating views in stored procedures is currently unsupported and will be added in a future release",
+			},
+		},
+	},
+
 }
 
 var NoDbProcedureTests = []ScriptTestAssertion{

sql/analyzer/stored_procedures.go

@@ -15,17 +15,14 @@
 package analyzer
 
 import (
-	"fmt"
-	"slices"
-	"strings"
 
-	"gopkg.in/src-d/go-errors.v1"
-
-	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/expression"
-	"github.com/dolthub/go-mysql-server/sql/plan"
-	"github.com/dolthub/go-mysql-server/sql/planbuilder"
-	"github.com/dolthub/go-mysql-server/sql/transform"
+"fmt"
+"github.com/dolthub/go-mysql-server/sql"
+"github.com/dolthub/go-mysql-server/sql/expression"
+"github.com/dolthub/go-mysql-server/sql/plan"
+"github.com/dolthub/go-mysql-server/sql/planbuilder"
+"github.com/dolthub/go-mysql-server/sql/transform"
+"slices"
 )
 
 // loadStoredProcedures loads non-built-in stored procedures for all databases on relevant calls.
@@ -184,56 +181,6 @@ func validateCreateProcedure(ctx *sql.Context, a *Analyzer, node sql.Node, scope
 func validateStoredProcedure(_ *sql.Context, proc *plan.Procedure) error {
 	// For now, we don't support creating any of the following within stored procedures.
 	// These will be removed in the future, but cause issues with the current execution plan.
-	var err error
-	spUnsupportedErr := errors.NewKind("creating %s in stored procedures is currently unsupported " +
-		"and will be added in a future release")
-	transform.Inspect(proc, func(n sql.Node) bool {
-		switch n.(type) {
-		case *plan.CreateTable:
-			err = spUnsupportedErr.New("tables")
-		case *plan.CreateTrigger:
-			err = spUnsupportedErr.New("triggers")
-		case *plan.CreateProcedure:
-			err = spUnsupportedErr.New("procedures")
-		case *plan.CreateDB:
-			err = spUnsupportedErr.New("databases")
-		case *plan.CreateForeignKey:
-			err = spUnsupportedErr.New("foreign keys")
-		case *plan.CreateIndex:
-			err = spUnsupportedErr.New("indexes")
-		case *plan.CreateView:
-			err = spUnsupportedErr.New("views")
-		default:
-			return true
-		}
-		return false
-	})
-	if err != nil {
-		return err
-	}
-
-	transform.Inspect(proc, func(n sql.Node) bool {
-		switch n := n.(type) {
-		case *plan.Call:
-			if proc.Name == strings.ToLower(n.Name) {
-				err = sql.ErrProcedureRecursiveCall.New(proc.Name)
-			}
-		case *plan.LockTables: // Blocked in vitess, but this is for safety
-			err = sql.ErrProcedureInvalidBodyStatement.New("LOCK TABLES")
-		case *plan.UnlockTables: // Blocked in vitess, but this is for safety
-			err = sql.ErrProcedureInvalidBodyStatement.New("UNLOCK TABLES")
-		case *plan.Use: // Blocked in vitess, but this is for safety
-			err = sql.ErrProcedureInvalidBodyStatement.New("USE")
-		case *plan.LoadData:
-			err = sql.ErrProcedureInvalidBodyStatement.New("LOAD DATA")
-		default:
-			return true
-		}
-		return false
-	})
-	if err != nil {
-		return err
-	}
 
 	return nil
 }

sql/planbuilder/create_ddl.go

@@ -16,7 +16,8 @@ package planbuilder
 
 import (
 	"fmt"
-	"strings"
+	"github.com/dolthub/go-mysql-server/sql/transform"
+"strings"
 	"time"
 	"unicode"
 
@@ -132,6 +133,9 @@ func getCurrentUserForDefiner(ctx *sql.Context, definer string) string {
 }
 
 func (b *Builder) buildCreateProcedure(inScope *scope, subQuery string, fullQuery string, c *ast.DDL) (outScope *scope) {
+	b.qFlags.Set(sql.QFlagCreateProcedure)
+	defer func() {b.qFlags.Unset(sql.QFlagCreateProcedure)}()
+
 	var params []plan.ProcedureParam
 	for _, param := range c.ProcedureSpec.Params {
 		var direction plan.ProcedureParamDirection
@@ -200,6 +204,20 @@ func (b *Builder) buildCreateProcedure(inScope *scope, subQuery string, fullQuer
 	bodyStr := strings.TrimSpace(fullQuery[c.SubStatementPositionStart:c.SubStatementPositionEnd])
 
 	bodyScope := b.buildSubquery(inScope, c.ProcedureSpec.Body, bodyStr, fullQuery)
+	b.validateStoredProcedure(bodyScope.node)
+
+	// Check for recursive calls to same procedure
+	transform.Inspect(bodyScope.node, func(node sql.Node) (bool) {
+		switch n := node.(type) {
+		case *plan.Call:
+			if strings.EqualFold(procName, n.Name) {
+				b.handleErr(sql.ErrProcedureRecursiveCall.New(procName))
+			}
+			return false
+		default:
+			return true
+		}
+	})
 
 	var db sql.Database = nil
 	dbName := c.ProcedureSpec.ProcName.Qualifier.String()

sql/planbuilder/proc.go

@@ -16,6 +16,7 @@ package planbuilder
 
 import (
 	"fmt"
+	"gopkg.in/src-d/go-errors.v1"
 	"strconv"
 	"strings"
 
@@ -24,6 +25,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/transform"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
@@ -404,11 +406,55 @@ func (b *Builder) buildBlock(inScope *scope, parserStatements ast.Statements, fu
 			}
 		}
 		stmtScope := b.buildSubquery(inScope, s, ast.String(s), fullQuery)
+		if b.qFlags.IsSet(sql.QFlagCreateProcedure) {
+			b.validateStoredProcedure(stmtScope.node)
+		}
 		statements = append(statements, stmtScope.node)
 	}
+
 	return plan.NewBlock(statements)
 }
 
+func (b *Builder) validateStoredProcedure(node sql.Node) {
+	// For now, we don't support creating any of the following within stored procedures.
+	// These will be removed in the future, but cause issues with the current execution plan.
+	var err error
+	spUnsupportedErr := errors.NewKind("creating %s in stored procedures is currently unsupported " +
+		"and will be added in a future release")
+	transform.Inspect(node, func(n sql.Node) bool {
+		switch n.(type) {
+		case *plan.CreateTable:
+			err = spUnsupportedErr.New("tables")
+		case *plan.CreateTrigger:
+			err = spUnsupportedErr.New("triggers")
+		case *plan.CreateProcedure:
+			err = spUnsupportedErr.New("procedures")
+		case *plan.CreateDB:
+			err = spUnsupportedErr.New("databases")
+		case *plan.CreateForeignKey:
+			err = spUnsupportedErr.New("foreign keys")
+		case *plan.CreateIndex:
+			err = spUnsupportedErr.New("indexes")
+		case *plan.CreateView:
+			err = spUnsupportedErr.New("views")
+		case *plan.LockTables: // Blocked in vitess, but this is for safety
+			err = sql.ErrProcedureInvalidBodyStatement.New("LOCK TABLES")
+		case *plan.UnlockTables: // Blocked in vitess, but this is for safety
+			err = sql.ErrProcedureInvalidBodyStatement.New("UNLOCK TABLES")
+		case *plan.Use: // Blocked in vitess, but this is for safety
+			err = sql.ErrProcedureInvalidBodyStatement.New("USE")
+		case *plan.LoadData:
+			err = sql.ErrProcedureInvalidBodyStatement.New("LOAD DATA")
+		default:
+			return true
+		}
+		return false
+	})
+	if err != nil {
+		b.handleErr(err)
+	}
+}
+
 func (b *Builder) buildFetchCursor(inScope *scope, fetchCursor *ast.FetchCursor) (outScope *scope) {
 	if !inScope.proc.HasCursor(fetchCursor.Name) {
 		err := sql.ErrCursorNotFound.New(fetchCursor.Name)

sql/query_flags.go

@@ -51,6 +51,7 @@ const (
 	// QFlagUndeferrableExprs indicates that the query has expressions that cannot be deferred
 	QFlagUndeferrableExprs
 	QFlagTrigger
+	QFlagCreateProcedure
 )
 
 type QueryFlags struct {