Resolve Catalog in CreateView node

Signed-off-by: Alejandro García Montoro <alejandro.garciamontoro@gmail.com>

Author: agarciamontoro

sql/analyzer/assign_catalog.go

@@ -60,6 +60,10 @@ func assignCatalog(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 			nc := *node
 			nc.Catalog = a.Catalog
 			return &nc, nil
+		case *plan.CreateView:
+			nc := *node
+			nc.Catalog = a.Catalog
+			return &nc, nil
 		default:
 			return n, nil
 		}

sql/index.go

@@ -512,7 +512,7 @@ func exprListsEqual(a, b []string) bool {
 // marked as creating, so nobody can't register two indexes with the same
 // expression or id while the other is still being created.
 // When something is sent through the returned channel, it means the index has
-// finished it's creation and will be marked as ready.
+// finished its creation and will be marked as ready.
 // Another channel is returned to notify the user when the index is ready.
 func (r *IndexRegistry) AddIndex(
 	idx Index,

sql/parse/parse.go

@@ -36,7 +36,7 @@ var (
 var (
 	describeTablesRegex  = regexp.MustCompile(`^(describe|desc)\s+table\s+(.*)`)
 	createIndexRegex     = regexp.MustCompile(`^create\s+index\s+`)
-	createViewRegex     = regexp.MustCompile(`^create\s+(or\s+replace\s+)?view\s+`)
+	createViewRegex      = regexp.MustCompile(`^create\s+(or\s+replace\s+)?view\s+`)
 	dropIndexRegex       = regexp.MustCompile(`^drop\s+index\s+`)
 	showIndexRegex       = regexp.MustCompile(`^show\s+(index|indexes|keys)\s+(from|in)\s+\S+\s*`)
 	showCreateRegex      = regexp.MustCompile(`^show create\s+\S+\s*`)

sql/parse/util.go

@@ -310,7 +310,7 @@ func expectQuote(r *bufio.Reader) error {
 }
 
 func maybe(matched *bool, str string) parseFunc {
-	return func (rd *bufio.Reader) error {
+	return func(rd *bufio.Reader) error {
 		*matched = false
 		strLength := len(str)
 
@@ -340,7 +340,7 @@ func maybe(matched *bool, str string) parseFunc {
 }
 
 func multiMaybe(matched *bool, strings ...string) parseFunc {
-	return func (rd *bufio.Reader) error {
+	return func(rd *bufio.Reader) error {
 		*matched = false
 		first := true
 		for _, str := range strings {

sql/parse/views.go

@@ -20,11 +20,10 @@ var ErrMalformedCreateView = errors.NewKind("view definition %#v is not a SELECT
 func parseCreateView(ctx *sql.Context, s string) (sql.Node, error) {
 	r := bufio.NewReader(strings.NewReader(s))
 
-
 	var (
 		viewName, subquery string
-		columns []string
-		isReplace bool
+		columns            []string
+		isReplace          bool
 	)
 
 	err := parseFuncs{

sql/plan/create_view.go

@@ -3,178 +3,72 @@ package plan
 import (
 	"fmt"
 	"strings"
-	// "time"
 
-	// opentracing "github.com/opentracing/opentracing-go"
-	// otlog "github.com/opentracing/opentracing-go/log"
-	// "github.com/sirupsen/logrus"
 	"github.com/src-d/go-mysql-server/sql"
-	// "github.com/src-d/go-mysql-server/sql/expression"
-	// errors "gopkg.in/src-d/go-errors.v1"
 )
 
 type CreateView struct {
-    Database     sql.Database
-    Name   string
-    Columns []string
-    Definition *SubqueryAlias
+	UnaryNode
+	Database sql.Database
+	Name     string
+	Columns  []string
+	Catalog *sql.Catalog
 }
 
 func NewCreateView(
-	database     sql.Database,
-	name   string,
+	database sql.Database,
+	name string,
 	columns []string,
 	definition *SubqueryAlias,
 ) *CreateView {
 	return &CreateView{
-		Database: database,
-		Name: name,
-		Columns: columns,
-		Definition: definition,
+		UnaryNode{Child: definition},
+		database,
+		name,
+		columns,
+		nil,
 	}
 }
 
 // Children implements the Node interface.
-func (c *CreateView) Children() []sql.Node { return nil }
+func (create *CreateView) Children() []sql.Node {
+	return []sql.Node{create.Child}
+}
 
 // Resolved implements the Node interface.
-func (c *CreateView) Resolved() bool {
-	_, ok := c.Database.(sql.UnresolvedDatabase)
-	return !ok && c.Definition.Resolved()
+func (create *CreateView) Resolved() bool {
+	// TOOD: Check whether the database has been resolved
+	// _, ok := create.Database.(sql.UnresolvedDatabase)
+	return create.Child.Resolved()
 }
-//
-// func getIndexableTable(t sql.Table) (sql.IndexableTable, error) {
-// 	switch t := t.(type) {
-// 	case sql.IndexableTable:
-// 		return t, nil
-// 	case sql.TableWrapper:
-// 		return getIndexableTable(t.Underlying())
-// 	default:
-// 		return nil, ErrNotIndexable.New()
-// 	}
-// }
-//
-// func getChecksumable(t sql.Table) sql.Checksumable {
-// 	switch t := t.(type) {
-// 	case sql.Checksumable:
-// 		return t
-// 	case sql.TableWrapper:
-// 		return getChecksumable(t.Underlying())
-// 	default:
-// 		return nil
-// 	}
-// }
-//
+
 // RowIter implements the Node interface.
-func (c *CreateView) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+func (create *CreateView) RowIter(ctx *sql.Context) (sql.RowIter, error) {
 	// TODO: add it to the register
 
-	// table, ok := c.Table.(*ResolvedTable)
-	// if !ok {
-	// 	return nil, ErrNotIndexable.New()
-	// }
-	//
-	// indexable, err := getIndexableTable(table.Table)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// var driver sql.IndexDriver
-	// if c.Driver == "" {
-	// 	driver = c.Catalog.DefaultIndexDriver()
-	// } else {
-	// 	driver = c.Catalog.IndexDriver(c.Driver)
-	// }
-	//
-	// if driver == nil {
-	// 	return nil, ErrInvalidIndexDriver.New(c.Driver)
-	// }
-	//
-	// columns, exprs, err := getColumnsAndPrepareExpressions(c.Exprs)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// for _, e := range exprs {
-	// 	if e.Type() == sql.Blob || e.Type() == sql.JSON {
-	// 		return nil, ErrExprTypeNotIndexable.New(e, e.Type())
-	// 	}
-	// }
-	//
-	// if ch := getChecksumable(table.Table); ch != nil {
-	// 	c.Config[sql.ChecksumKey], err = ch.Checksum()
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// }
-	//
-	// index, err := driver.Create(
-	// 	c.CurrentDatabase,
-	// 	table.Name(),
-	// 	c.Name,
-	// 	exprs,
-	// 	c.Config,
-	// )
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// iter, err := indexable.IndexKeyValues(ctx, columns)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// iter = &evalPartitionKeyValueIter{
-	// 	ctx:     ctx,
-	// 	columns: columns,
-	// 	exprs:   exprs,
-	// 	iter:    iter,
-	// }
-	//
-	// created, ready, err := c.Catalog.AddIndex(index)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// log := logrus.WithFields(logrus.Fields{
-	// 	"id":     index.ID(),
-	// 	"driver": index.Driver(),
-	// })
-	//
-	// createIndex := func() {
-	// 	c.createIndex(ctx, log, driver, index, iter, created, ready)
-	// 	c.Catalog.ProcessList.Done(ctx.Pid())
-	// }
-	//
-	// log.WithField("async", c.Async).Info("starting to save the index")
-	//
-	// if c.Async {
-	// 	go createIndex()
-	// } else {
-	// 	createIndex()
-	// }
-
 	return sql.RowsToRowIter(), nil
 }
 
 // Schema implements the Node interface.
-func (c *CreateView) Schema() sql.Schema { return nil }
+func (create *CreateView) Schema() sql.Schema { return nil }
 
 func (create *CreateView) String() string {
 	pr := sql.NewTreePrinter()
 	_ = pr.WriteNode("CreateView(%s)", create.Name)
 	_ = pr.WriteChildren(
 		fmt.Sprintf("Columns (%s)", strings.Join(create.Columns, ", ")),
-		fmt.Sprintf("As (%s)", create.Definition.String()),
+		fmt.Sprintf("As (%s)", create.Child.String()),
 	)
 	return pr.String()
 }
 
 // WithChildren implements the Node interface.
-func (c *CreateView) WithChildren(children ...sql.Node) (sql.Node, error) {
-	if len(children) != 0 {
-		return nil, sql.ErrInvalidChildrenNumber.New(c, len(children), 0)
+func (create *CreateView) WithChildren(children ...sql.Node) (sql.Node, error) {
+	if len(children) != 1 {
+		return nil, sql.ErrInvalidChildrenNumber.New(create, len(children), 1)
 	}
 
-	return c, nil
+	newCreate := create
+	newCreate.Child = children[0]
+	return newCreate, nil
 }