Test new changes from VIEW implementation

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

Author: agarciamontoro

sql/analyzer/assign_catalog_test.go

@@ -73,4 +73,12 @@ func TestAssignCatalog(t *testing.T) {
 	ut, ok := node.(*plan.UnlockTables)
 	require.True(ok)
 	require.Equal(c, ut.Catalog)
+
+	mockSubquery := plan.NewSubqueryAlias("mock", plan.NewResolvedTable(tbl))
+	mockView := plan.NewCreateView(db, "", nil, mockSubquery, false)
+	node, err = f.Apply(sql.NewEmptyContext(), a, mockView)
+	require.NoError(err)
+	cv, ok := node.(*plan.CreateView)
+	require.True(ok)
+	require.Equal(c, cv.Catalog)
 }

sql/analyzer/resolve_tables_test.go

@@ -91,3 +91,44 @@ func TestResolveTablesNested(t *testing.T) {
 	)
 	require.Equal(expected, analyzed)
 }
+
+func TestResolveViews(t *testing.T) {
+	require := require.New(t)
+
+	f := getRule("resolve_tables")
+
+	table := memory.NewTable("mytable", sql.Schema{{Name: "i", Type: sql.Int32}})
+	db := memory.NewDatabase("mydb")
+	db.AddTable("mytable", table)
+
+	// Resolved plan that corresponds to query "SELECT i FROM mytable"
+	subquery := plan.NewProject(
+		[]sql.Expression{
+			expression.NewGetFieldWithTable(
+				1, sql.Int32, table.Name(), "i", true),
+		},
+		plan.NewResolvedTable(table),
+	)
+	subqueryAlias := plan.NewSubqueryAlias("myview", subquery)
+	view := sql.View{"myview", subqueryAlias}
+
+	catalog := sql.NewCatalog()
+	catalog.AddDatabase(db)
+	catalog.ViewRegistry.Register(db.Name(), view)
+
+	a := NewBuilder(catalog).AddPostAnalyzeRule(f.Name, f.Apply).Build()
+
+	var notAnalyzed sql.Node = plan.NewUnresolvedTable("myview", "")
+	analyzed, err := f.Apply(sql.NewEmptyContext(), a, notAnalyzed)
+	require.NoError(err)
+	require.Equal(subqueryAlias, analyzed)
+
+	notAnalyzed = plan.NewUnresolvedTable("MyVieW", "")
+	analyzed, err = f.Apply(sql.NewEmptyContext(), a, notAnalyzed)
+	require.NoError(err)
+	require.Equal(subqueryAlias, analyzed)
+
+	analyzed, err = f.Apply(sql.NewEmptyContext(), a, subqueryAlias)
+	require.NoError(err)
+	require.Equal(subqueryAlias, analyzed)
+}

sql/parse/parse_test.go

@@ -1,8 +1,8 @@
 package parse
 
 import (
-	"math"
 	"testing"
+	"math"
 
 	"github.com/src-d/go-mysql-server/sql/expression"
 	"github.com/src-d/go-mysql-server/sql/expression/function/aggregation"
@@ -1263,6 +1263,42 @@ var fixtures = map[string]sql.Node{
 		},
 		plan.NewUnresolvedTable("dual", ""),
 	),
+	`CREATE VIEW myview AS SELECT 1`: plan.NewCreateView(
+		sql.UnresolvedDatabase(""),
+		"myview",
+		nil,
+		plan.NewSubqueryAlias("myview",
+			plan.NewProject(
+				[]sql.Expression{expression.NewLiteral(int8(1), sql.Int8)},
+				plan.NewUnresolvedTable("dual", ""),
+			),
+		),
+		false,
+	),
+	`CREATE VIEW mydb.myview AS SELECT 1`: plan.NewCreateView(
+		sql.UnresolvedDatabase("mydb"),
+		"myview",
+		nil,
+		plan.NewSubqueryAlias("myview",
+			plan.NewProject(
+				[]sql.Expression{expression.NewLiteral(int8(1), sql.Int8)},
+				plan.NewUnresolvedTable("dual", ""),
+			),
+		),
+		false,
+	),
+	`CREATE OR REPLACE VIEW mydb.myview AS SELECT 1`: plan.NewCreateView(
+		sql.UnresolvedDatabase("mydb"),
+		"myview",
+		nil,
+		plan.NewSubqueryAlias(	"myview",
+			plan.NewProject(
+				[]sql.Expression{expression.NewLiteral(int8(1), sql.Int8)},
+				plan.NewUnresolvedTable("dual", ""),
+			),
+		),
+		true,
+	),
 }
 
 func TestParse(t *testing.T) {
@@ -1296,6 +1332,7 @@ 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 myview (col1) AS SELECT 1`:                         ErrUnsupportedSyntax,
 }
 
 func TestParseErrors(t *testing.T) {

sql/parse/util_test.go

@@ -0,0 +1,72 @@
+package parse
+
+import (
+	"bufio"
+	"strings"
+	"testing"
+	"bytes"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestReadLetterOrPoint(t *testing.T) {
+	testFixtures := []struct {
+		string  string
+		expectedBuffer string
+		expectedRemaining string
+	}{
+		{ "asd.ASD.ñu",
+			"asd.ASD.ñu",
+			"",
+		},
+		{ "5anytext",
+			"",
+			"5anytext",
+		},
+		{ "",
+			"",
+			"",
+		},
+		{ "as df",
+			"as",
+			" df",
+		},
+		{ "a.s df",
+			"a.s",
+			" df",
+		},
+		{ "a.s-",
+			"a.s",
+			"-",
+		},
+	}
+
+	for _, fixture := range testFixtures {
+		reader := bufio.NewReader(strings.NewReader(fixture.string))
+		var buffer bytes.Buffer
+
+		for i := 0; i < len(fixture.string); i++ {
+			readLetterOrPoint(reader, &buffer)
+		}
+
+		remaining, _ := reader.ReadString('\n')
+		require.Equal(t, remaining, fixture.expectedRemaining)
+
+		require.Equal(t, buffer.String(), fixture.expectedBuffer)
+	}
+}
+
+func TestReadValidScopedIdentRune(t *testing.T) {
+}
+
+func TestReadScopedIdent(t *testing.T) {
+}
+
+func TestMaybe(t *testing.T) {
+}
+
+func TestMultiMaybe(t *testing.T) {
+}
+
+func TestMaybeList(t *testing.T) {
+}