Parse CREATE VIEW statements

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

Author: agarciamontoro

sql/parse/parse.go

@@ -36,6 +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+`)
 	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*`)
@@ -47,7 +48,6 @@ var (
 	unlockTablesRegex    = regexp.MustCompile(`^unlock\s+tables$`)
 	lockTablesRegex      = regexp.MustCompile(`^lock\s+tables\s`)
 	setRegex             = regexp.MustCompile(`^set\s+`)
-	createViewRegex      = regexp.MustCompile(`^create\s+view\s+`)
 )
 
 // These constants aren't exported from vitess for some reason. This could be removed if we changed this.
@@ -82,6 +82,8 @@ func Parse(ctx *sql.Context, query string) (sql.Node, error) {
 		return parseDescribeTables(lowerQuery)
 	case createIndexRegex.MatchString(lowerQuery):
 		return parseCreateIndex(ctx, s)
+	case createViewRegex.MatchString(lowerQuery):
+		return parseCreateView(ctx, s)
 	case dropIndexRegex.MatchString(lowerQuery):
 		return parseDropIndex(s)
 	case showIndexRegex.MatchString(lowerQuery):
@@ -104,9 +106,6 @@ func Parse(ctx *sql.Context, query string) (sql.Node, error) {
 		return parseLockTables(ctx, s)
 	case setRegex.MatchString(lowerQuery):
 		s = fixSetQuery(s)
-	case createViewRegex.MatchString(lowerQuery):
-		// CREATE VIEW parses as a CREATE DDL statement with an empty table spec
-		return nil, ErrUnsupportedFeature.New("CREATE VIEW")
 	}
 
 	stmt, err := sqlparser.Parse(s)

sql/parse/parse_test.go

@@ -1296,7 +1296,6 @@ var fixturesErrors = map[string]*errors.Kind{
 	`SELECT INTERVAL 1 DAY + INTERVAL 1 DAY`:                  ErrUnsupportedSyntax,
 	`SELECT '2018-05-01' + (INTERVAL 1 DAY + INTERVAL 1 DAY)`: ErrUnsupportedSyntax,
 	`SELECT AVG(DISTINCT foo) FROM b`:                         ErrUnsupportedSyntax,
-	`CREATE VIEW view1 AS SELECT x FROM t1 WHERE x>0`:         ErrUnsupportedFeature,
 }
 
 func TestParseErrors(t *testing.T) {

sql/parse/util.go

@@ -308,3 +308,113 @@ func expectQuote(r *bufio.Reader) error {
 
 	return nil
 }
+
+func maybe(matched *bool, str string) parseFunc {
+	return func (rd *bufio.Reader) error {
+		*matched = false
+		strLength := len(str)
+
+		data, err := rd.Peek(strLength)
+		if err != nil {
+			// If there are not enough runes, what we expected was not there, which
+			// is not an error per se.
+			if len(data) < strLength {
+				return nil
+			}
+
+			return err
+		}
+
+		if strings.ToLower(string(data)) == str {
+			_, err := rd.Discard(strLength)
+			if err != nil {
+				return err
+			}
+
+			*matched = true
+			return nil
+		}
+
+		return nil
+	}
+}
+
+func multiMaybe(matched *bool, strings ...string) parseFunc {
+	return func (rd *bufio.Reader) error {
+		*matched = false
+		first := true
+		for _, str := range strings {
+			if err := maybe(matched, str)(rd); err != nil {
+				return err
+			}
+
+			if !*matched {
+				if first {
+					return nil
+				}
+
+				// TODO: add actual string parsed
+				return errUnexpectedSyntax.New(str, "smth else")
+			}
+
+			first = false
+
+			if err := skipSpaces(rd); err != nil {
+				return err
+			}
+		}
+		*matched = true
+		return nil
+	}
+}
+
+// Read a list of strings separated by the specified separator, with a rune
+// indicating the opening of the list and another one specifying its closing.
+// For example, readList('(', ',', ')', list) parses "(uno,  dos,tres)" and
+// populates list with the array of strings ["uno", "dos", "tres"]
+// If the opening is not found, do not advance the reader
+func maybeList(opening, separator, closing rune, list []string) parseFunc {
+	return func(rd *bufio.Reader) error {
+		r, _, err := rd.ReadRune()
+		if err != nil {
+			return err
+		}
+
+		if r != opening {
+			rd.UnreadRune()
+			return nil
+		}
+
+		for {
+			var newItem string
+			err := parseFuncs{
+				skipSpaces,
+				readIdent(&newItem),
+				skipSpaces,
+			}.exec(rd)
+
+			if err != nil {
+				return err
+			}
+
+			r, _, err := rd.ReadRune()
+			if err != nil {
+				return err
+			}
+
+			switch r {
+			case closing:
+				list = append(list, newItem)
+				return nil
+			case separator:
+				list = append(list, newItem)
+				continue
+			default:
+				return errUnexpectedSyntax.New(
+					fmt.Sprintf("%v or %v", separator, closing),
+					string(r),
+				)
+			}
+		}
+	}
+}

sql/parse/views.go

@@ -0,0 +1,71 @@
+package parse
+
+import (
+	"bufio"
+	"strings"
+	// "io"
+
+	"github.com/src-d/go-mysql-server/sql"
+	"github.com/src-d/go-mysql-server/sql/plan"
+
+	"gopkg.in/src-d/go-errors.v1"
+	"vitess.io/vitess/go/vt/sqlparser"
+)
+
+var ErrMalformedCreateView = errors.NewKind("view definition %#v is not a SELECT query")
+
+// Parses
+// CREATE [OR REPLACE] VIEW view_name [(col1, col2, ...)] AS select_statement
+// and returns a NewCreateView node in case of success
+func parseCreateView(ctx *sql.Context, s string) (sql.Node, error) {
+	r := bufio.NewReader(strings.NewReader(s))
+
+
+	var (
+		viewName, subquery string
+		columns []string
+		isReplace bool
+	)
+
+	err := parseFuncs{
+		expect("create"),
+		skipSpaces,
+		multiMaybe(&isReplace, "or", "replace"),
+		skipSpaces,
+		expect("view"),
+		skipSpaces,
+		readIdent(&viewName),
+		skipSpaces,
+		maybeList('(', ',', ')', columns),
+		skipSpaces,
+		expect("as"),
+		skipSpaces,
+		readRemaining(&subquery),
+		checkEOF,
+	}.exec(r)
+
+	if err != nil {
+		return nil, err
+	}
+
+	subqueryStatement, err := sqlparser.Parse(subquery)
+	if err != nil {
+		return nil, err
+	}
+
+	selectStatement, ok := subqueryStatement.(*sqlparser.Select)
+	if !ok {
+		return nil, ErrMalformedCreateView.New(subqueryStatement)
+	}
+
+	subqueryNode, err := convertSelect(ctx, selectStatement)
+	if err != nil {
+		return nil, err
+	}
+
+	subqueryAlias := plan.NewSubqueryAlias(viewName, subqueryNode)
+
+	return plan.NewCreateView(
+		sql.UnresolvedDatabase(""), viewName, columns, subqueryAlias,
+	), nil
+}