progress

Author: James Cor

sql/plan/call.go

@@ -17,15 +17,14 @@ package plan
 import (
 	"fmt"
 
-	"github.com/dolthub/go-mysql-server/sql/types"
-
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
+	"github.com/dolthub/go-mysql-server/sql/procedures"
+	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 
-// TODO: we need different types of calls: one for extrenal procedures one for stored procedures
-
+// TODO: we need different types of calls: one for external procedures one for stored procedures
 
 type Call struct {
 	db        sql.Database
@@ -38,24 +37,26 @@ type Call struct {
 	Analyzed  bool
 
 	// this will have list of parsed operations to run
-	runner sql.StatementRunner
+	Runner sql.StatementRunner
+	Ops    []procedures.InterpreterOperation
 }
 
 var _ sql.Node = (*Call)(nil)
 var _ sql.CollationCoercible = (*Call)(nil)
 var _ sql.Expressioner = (*Call)(nil)
-var _ sql.InterpreterNode = (*Call)(nil)
+var _ procedures.InterpreterNode = (*Call)(nil)
 var _ Versionable = (*Call)(nil)
 
 // NewCall returns a *Call node.
-func NewCall(db sql.Database, name string, params []sql.Expression, proc *Procedure, asOf sql.Expression, catalog sql.Catalog) *Call {
+func NewCall(db sql.Database, name string, params []sql.Expression, proc *Procedure, asOf sql.Expression, catalog sql.Catalog, ops []procedures.InterpreterOperation) *Call {
 	return &Call{
 		db:        db,
 		Name:      name,
 		Params:    params,
 		Procedure: proc,
 		asOf:      asOf,
 		cat:       catalog,
+		Ops:       ops,
 	}
 }
 
@@ -178,9 +179,6 @@ func (c *Call) DebugString() string {
 	} else {
 		tp.WriteNode("CALL %s.%s(%s)", c.db.Name(), c.Name, paramStr)
 	}
-	if c.Procedure != nil {
-		tp.WriteChildren(sql.DebugString(c.Procedure.Body))
-	}
 
 	return tp.String()
 }
@@ -209,6 +207,35 @@ func (c *Call) Dispose() {
 // SetStatementRunner implements the sql.InterpreterNode interface.
 func (c *Call) SetStatementRunner(ctx *sql.Context, runner sql.StatementRunner) sql.Node {
 	nc := *c
-	nc.runner = runner
+	nc.Runner = runner
 	return &nc
 }
+
+// GetRunner implements the sql.InterpreterNode interface.
+func (c *Call) GetRunner() sql.StatementRunner {
+	return c.Runner
+}
+
+// GetParameters implements the sql.InterpreterNode interface.
+func (c *Call) GetParameters() []sql.Type {
+	return nil
+}
+
+// GetParameterNames implements the sql.InterpreterNode interface.
+func (c *Call) GetParameterNames() []string {
+	return nil
+}
+
+// GetStatements implements the sql.InterpreterNode interface.
+func (c *Call) GetStatements() []procedures.InterpreterOperation {
+	return c.Ops
+}
+
+// GetReturn implements the sql.InterpreterNode interface.
+func (c *Call) GetReturn() sql.Type {
+	return nil
+}
+
+
+
+

sql/plan/procedure.go

@@ -20,9 +20,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/dolthub/go-mysql-server/sql/expression"
-
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/expression"
+	"github.com/dolthub/go-mysql-server/sql/procedures"
+	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 // ProcedureSecurityContext determines whether the stored procedure is executed using the privileges of the definer or
@@ -80,7 +81,8 @@ type Procedure struct {
 	Comment               string
 	Characteristics       []Characteristic
 	CreateProcedureString string
-	Body                  sql.Node
+	Ops                   []procedures.InterpreterOperation
+	ExternalProc          sql.Node
 	CreatedAt             time.Time
 	ModifiedAt            time.Time
 	ValidationError       error
@@ -100,7 +102,7 @@ func NewProcedure(
 	comment string,
 	characteristics []Characteristic,
 	createProcedureString string,
-	body sql.Node,
+	ops []procedures.InterpreterOperation,
 	createdAt time.Time,
 	modifiedAt time.Time,
 ) *Procedure {
@@ -121,55 +123,49 @@ func NewProcedure(
 		Comment:               comment,
 		Characteristics:       characteristics,
 		CreateProcedureString: createProcedureString,
-		Body:                  body,
+		Ops:                   ops,
 		CreatedAt:             createdAt,
 		ModifiedAt:            modifiedAt,
 	}
 }
 
 // Resolved implements the sql.Node interface.
 func (p *Procedure) Resolved() bool {
-	return p.Body.Resolved()
+	return true
 }
 
 func (p *Procedure) IsReadOnly() bool {
-	return p.Body.IsReadOnly()
+	return false
 }
 
 // String implements the sql.Node interface.
 func (p *Procedure) String() string {
-	return p.Body.String()
+	return ""
 }
 
 // DebugString implements the sql.DebugStringer interface.
 func (p *Procedure) DebugString() string {
-	return sql.DebugString(p.Body)
+	return sql.DebugString(p.Ops)
 }
 
 // Schema implements the sql.Node interface.
 func (p *Procedure) Schema() sql.Schema {
-	return p.Body.Schema()
+	return types.OkResultSchema
 }
 
 // Children implements the sql.Node interface.
 func (p *Procedure) Children() []sql.Node {
-	return []sql.Node{p.Body}
+	return nil
 }
 
 // WithChildren implements the sql.Node interface.
 func (p *Procedure) WithChildren(children ...sql.Node) (sql.Node, error) {
-	if len(children) != 1 {
-		return nil, sql.ErrInvalidChildrenNumber.New(p, len(children), 1)
-	}
-
-	np := *p
-	np.Body = children[0]
-	return &np, nil
+	return p, nil
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.
 func (p *Procedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
-	return sql.GetCoercibility(ctx, p.Body)
+	return sql.GetCoercibility(ctx, p.Ops)
 }
 
 // implementsRepresentsBlock implements the RepresentsBlock interface.
@@ -181,9 +177,9 @@ func (p *Procedure) ExtendVariadic(ctx *sql.Context, length int) *Procedure {
 		return p
 	}
 	np := *p
-	body := p.Body.(*ExternalProcedure)
+	body := p.ExternalProc.(*ExternalProcedure)
 	newBody := *body
-	np.Body = &newBody
+	np.ExternalProc = &newBody
 
 	newParamDefinitions := make([]ProcedureParam, length)
 	newParams := make([]*expression.ProcedureParam, length)
@@ -226,7 +222,7 @@ func (p *Procedure) HasVariadicParameter() bool {
 
 // IsExternal returns whether the stored procedure is external.
 func (p *Procedure) IsExternal() bool {
-	if _, ok := p.Body.(*ExternalProcedure); ok {
+	if _, ok := p.ExternalProc.(*ExternalProcedure); ok {
 		return true
 	}
 	return false

sql/planbuilder/proc.go

@@ -257,24 +257,14 @@ func BuildProcedureHelper(ctx *sql.Context, cat sql.Catalog, isCreateProc bool,
 
 	// TODO: convert ast to operations
 
-	procedures.Parse(procStmt.ProcedureSpec.Body)
+	ops, err := procedures.Parse(procStmt.ProcedureSpec.Body)
+	if err != nil {
+		b.handleErr(err)
+	}
 
 	procParams := b.buildProcedureParams(procStmt.ProcedureSpec.Params)
 	characteristics, securityType, comment := b.buildProcedureCharacteristics(procStmt.ProcedureSpec.Characteristics)
 
-	// populate inScope with the procedure parameters. this will be
-	// subject maybe a bug where an inner procedure has access to
-	// outer procedure parameters.
-	if inScope == nil {
-		inScope = b.newScope()
-	}
-	inScope.initProc()
-	for _, p := range procParams {
-		inScope.proc.AddVar(expression.NewProcedureParam(strings.ToLower(p.Name), p.Type))
-	}
-
-	bodyStr := strings.TrimSpace(procDetails.CreateStatement[procStmt.SubStatementPositionStart:procStmt.SubStatementPositionEnd])
-	bodyScope := b.buildSubquery(inScope, procStmt.ProcedureSpec.Body, bodyStr, procDetails.CreateStatement)
 
 	proc = plan.NewProcedure(
 		procDetails.Name,
@@ -284,12 +274,12 @@ func BuildProcedureHelper(ctx *sql.Context, cat sql.Catalog, isCreateProc bool,
 		comment,
 		characteristics,
 		procDetails.CreateStatement,
-		bodyScope.node,
+		ops,
 		procDetails.CreatedAt,
 		procDetails.ModifiedAt,
 	)
-	qFlags = b.qFlags
-	return
+
+	return proc, qFlags, nil
 }
 
 func (b *Builder) buildCall(inScope *scope, c *ast.Call) (outScope *scope) {
@@ -332,7 +322,7 @@ func (b *Builder) buildCall(inScope *scope, c *ast.Call) (outScope *scope) {
 		procDetails, ok, err = spdb.GetStoredProcedure(b.ctx, procName)
 		if err == nil {
 			if ok {
-				proc, innerQFlags, err = BuildProcedureHelper(b.ctx, b.cat, false, inScope, db, asOf, procDetails)
+				ops, innerQFlags, err = BuildProcedureHelper(b.ctx, b.cat, false, inScope, db, asOf, procDetails)
 				// TODO: somewhat hacky way of preserving this flag
 				// This is necessary so that the resolveSubqueries analyzer rule
 				// will apply NodeExecBuilder to Subqueries in procedure body

sql/procedures.go

@@ -18,6 +18,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/dolthub/go-mysql-server/sql/procedures"
+
 	"github.com/dolthub/vitess/go/vt/sqlparser"
 )
 
@@ -34,6 +36,10 @@ type Interpreter interface {
 // implemented as a set of operations that are interpreted during runtime).
 type InterpreterNode interface {
 	SetStatementRunner(ctx *Context, runner StatementRunner) Node
+	GetParameters() []Type
+	GetParameterNames() []string
+	GetReturn() Type
+	GetStatements() []procedures.InterpreterOperation
 }
 
 // StatementRunner is essentially an interface that the engine will implement. We cannot directly reference the engine