sql/*: implement drop index statement

erizocosmico · erizocosmico · commit a1ee88e74208 · 2018-06-06T17:22:12.000+02:00
Signed-off-by: Miguel Molina &lt;miguel@erizocosmi.co&gt;
diff --git a/sql/analyzer/rules.go b/sql/analyzer/rules.go
@@ -769,25 +769,29 @@ func dedupStrings(in []string) []string {
 	return result
 }
 
-// indexCatalog sets the catalog in the CreateIndex nodes.
+// indexCatalog sets the catalog in the CreateIndex and DropIndex nodes.
 func indexCatalog(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error) {
 	if !n.Resolved() {
 		return n, nil
 	}
 
-	ci, ok := n.(*plan.CreateIndex)
-	if !ok {
-		return n, nil
-	}
-
 	span, ctx := ctx.Span("index_catalog")
 	defer span.Finish()
 
-	nc := *ci
-	ci.Catalog = a.Catalog
-	ci.CurrentDatabase = a.CurrentDatabase
-
-	return &nc, nil
+	switch node := n.(type) {
+	case *plan.CreateIndex:
+		nc := *node
+		nc.Catalog = a.Catalog
+		nc.CurrentDatabase = a.CurrentDatabase
+		return &nc, nil
+	case *plan.DropIndex:
+		nc := *node
+		nc.Catalog = a.Catalog
+		nc.CurrentDatabase = a.CurrentDatabase
+		return &nc, nil
+	default:
+		return n, nil
+	}
 }
 
 func pushdown(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error) {
diff --git a/sql/analyzer/rules_test.go b/sql/analyzer/rules_test.go
@@ -569,6 +569,33 @@ func TestQualifyColumns(t *testing.T) {
 	require.Equal(expected, result)
 }
 
+func TestCatalogIndex(t *testing.T) {
+	require := require.New(t)
+	f := getRule("index_catalog")
+
+	c := sql.NewCatalog()
+	a := New(c)
+	a.CurrentDatabase = "foo"
+
+	tbl := mem.NewTable("foo", nil)
+
+	node, err := f.Apply(sql.NewEmptyContext(), a, plan.NewCreateIndex("", tbl, nil, "", make(map[string]string)))
+	require.NoError(err)
+
+	ci, ok := node.(*plan.CreateIndex)
+	require.True(ok)
+	require.Equal(c, ci.Catalog)
+	require.Equal("foo", ci.CurrentDatabase)
+
+	node, err = f.Apply(sql.NewEmptyContext(), a, plan.NewDropIndex("foo", tbl))
+	require.NoError(err)
+
+	di, ok := node.(*plan.DropIndex)
+	require.True(ok)
+	require.Equal(c, di.Catalog)
+	require.Equal("foo", di.CurrentDatabase)
+}
+
 func TestReorderProjection(t *testing.T) {
 	require := require.New(t)
 	f := getRule("reorder_projection")
diff --git a/sql/index.go b/sql/index.go
@@ -45,6 +45,8 @@ type Index interface {
 	// one expression, it means the index has multiple columns indexed. If it's
 	// just one, it means it may be an expression or a column.
 	ExpressionHashes() []ExpressionHash
+	// Driver ID of the index.
+	Driver() string
 }
 
 // AscendIndex is an index that is sorted in ascending order.
@@ -206,6 +208,7 @@ func (r *IndexRegistry) ReleaseIndex(idx Index) {
 func (r *IndexRegistry) Index(db, id string) Index {
 	r.mut.RLock()
 	defer r.mut.RUnlock()
+	r.retainIndex(db, id)
 	return r.indexes[indexKey{db, strings.ToLower(id)}]
 }
 
diff --git a/sql/index/pilosa/index.go b/sql/index/pilosa/index.go
@@ -144,6 +144,8 @@ func (idx *sqlIndex) ExpressionHashes() []sql.ExpressionHash {
 	return idx.expressions
 }
 
+func (sqlIndex) Driver() string { return "pilosa" }
+
 // lookup implements sql.IndexLookup and sql.IndexValueIter interface
 type sqlIndexLookupIter struct {
 	offset    uint64
diff --git a/sql/index_test.go b/sql/index_test.go
@@ -126,6 +126,7 @@ func (i dummyIdx) Get(...interface{}) (IndexLookup, error) { panic("not implemen
 func (i dummyIdx) Has(...interface{}) (bool, error)        { panic("not implemented") }
 func (i dummyIdx) Database() string                        { return i.database }
 func (i dummyIdx) Table() string                           { return i.table }
+func (i dummyIdx) Driver() string                          { return "dummy" }
 
 type dummyExpr struct {
 	foo int
diff --git a/sql/parse/indexes.go b/sql/parse/indexes.go
@@ -52,6 +52,7 @@ func parseCreateIndex(s string) (sql.Node, error) {
 			readKeyValue(config),
 			skipSpaces,
 		),
+		checkEOF,
 	}
 
 	for _, step := range steps {
@@ -195,6 +196,36 @@ func readValue(val *string) parseFunc {
 	}
 }
 
+func parseDropIndex(str string) (sql.Node, error) {
+	r := bufio.NewReader(strings.NewReader(str))
+
+	var name, table string
+	steps := []parseFunc{
+		expect("drop"),
+		skipSpaces,
+		expect("index"),
+		skipSpaces,
+		readIdent(&name),
+		skipSpaces,
+		expect("on"),
+		skipSpaces,
+		readIdent(&table),
+		skipSpaces,
+		checkEOF,
+	}
+
+	for _, step := range steps {
+		if err := step(r); err != nil {
+			return nil, err
+		}
+	}
+
+	return plan.NewDropIndex(
+		name,
+		plan.NewUnresolvedTable(table),
+	), nil
+}
+
 func parseIndexExpr(str string) (sql.Expression, error) {
 	stmt, err := sqlparser.Parse("SELECT " + str)
 	if err != nil {
@@ -368,3 +399,12 @@ func skipSpaces(r *bufio.Reader) error {
 		}
 	}
 }
+
+func checkEOF(rd *bufio.Reader) error {
+	r, _, err := rd.ReadRune()
+	if err == io.EOF {
+		return nil
+	}
+
+	return errUnexpectedSyntax.New("EOF", r)
+}
diff --git a/sql/parse/indexes_test.go b/sql/parse/indexes_test.go
diff --git a/sql/parse/parse.go b/sql/parse/parse.go
@@ -31,6 +31,7 @@ var (
 var (
 	describeTablesRegex = regexp.MustCompile(`^describe\s+table\s+(.*)`)
 	createIndexRegex    = regexp.MustCompile(`^create\s+index\s+`)
+	dropIndexRegex      = regexp.MustCompile(`^drop\s+index\s+`)
 )
 
 // Parse parses the given SQL sentence and returns the corresponding node.
@@ -48,6 +49,8 @@ func Parse(ctx *sql.Context, s string) (sql.Node, error) {
 		return parseDescribeTables(lowerQuery)
 	case createIndexRegex.MatchString(lowerQuery):
 		return parseCreateIndex(s)
+	case dropIndexRegex.MatchString(lowerQuery):
+		return parseDropIndex(s)
 	}
 
 	stmt, err := sqlparser.Parse(s)
@@ -78,7 +81,7 @@ func convert(ctx *sql.Context, stmt sqlparser.Statement, query string) (sql.Node
 	case *sqlparser.Insert:
 		return convertInsert(ctx, n)
 	case *sqlparser.DDL:
-		return convertDDL(n, query)
+		return convertDDL(n)
 	}
 }
 
@@ -141,7 +144,7 @@ func convertSelect(ctx *sql.Context, s *sqlparser.Select) (sql.Node, error) {
 	return node, nil
 }
 
-func convertDDL(c *sqlparser.DDL, query string) (sql.Node, error) {
+func convertDDL(c *sqlparser.DDL) (sql.Node, error) {
 	switch c.Action {
 	case sqlparser.CreateStr:
 		return convertCreateTable(c)
diff --git a/sql/parse/parse_test.go b/sql/parse/parse_test.go
@@ -3,10 +3,11 @@ package parse
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
-	"gopkg.in/src-d/go-mysql-server.v0/sql"
 	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
 	"gopkg.in/src-d/go-mysql-server.v0/sql/plan"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
 )
 
 var fixtures = map[string]sql.Node{
@@ -588,6 +589,10 @@ var fixtures = map[string]sql.Node{
 			plan.NewUnresolvedTable("baz"),
 		),
 	),
+	`DROP INDEX foo ON bar`: plan.NewDropIndex(
+		"foo",
+		plan.NewUnresolvedTable("bar"),
+	),
 }
 
 func TestParse(t *testing.T) {
diff --git a/sql/plan/create_index_test.go b/sql/plan/create_index_test.go
@@ -71,6 +71,7 @@ func (i *mockIndex) Get(key ...interface{}) (sql.IndexLookup, error) {
 func (i *mockIndex) Has(key ...interface{}) (bool, error) {
 	panic("unimplemented")
 }
+func (*mockIndex) Driver() string { return "mock" }
 
 type mockDriver struct {
 	deleted []string
diff --git a/sql/plan/drop_index.go b/sql/plan/drop_index.go
@@ -0,0 +1,98 @@
+package plan
+
+import (
+	errors "gopkg.in/src-d/go-errors.v1"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+)
+
+// ErrIndexNotFound is returned when the index cannot be found.
+var ErrIndexNotFound = errors.NewKind("unable to find index %q on table %q of database %q")
+
+// DropIndex is a node to drop an index.
+type DropIndex struct {
+	Name            string
+	Table           sql.Node
+	Catalog         *sql.Catalog
+	CurrentDatabase string
+}
+
+// NewDropIndex creates a new DropIndex node.
+func NewDropIndex(name string, table sql.Node) *DropIndex {
+	return &DropIndex{name, table, nil, ""}
+}
+
+// Resolved implements the Node interface.
+func (d *DropIndex) Resolved() bool { return d.Table.Resolved() }
+
+// Schema implements the Node interface.
+func (d *DropIndex) Schema() sql.Schema { return nil }
+
+// Children implements the Node interface.
+func (d *DropIndex) Children() []sql.Node { return []sql.Node{d.Table} }
+
+// RowIter implements the Node interface.
+func (d *DropIndex) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	db, err := d.Catalog.Database(d.CurrentDatabase)
+	if err != nil {
+		return nil, err
+	}
+
+	table, ok := d.Table.(sql.Nameable)
+	if !ok {
+		return nil, ErrTableNotNameable.New()
+	}
+
+	if _, ok = db.Tables()[table.Name()]; !ok {
+		return nil, sql.ErrTableNotFound.New(table.Name())
+	}
+
+	index := d.Catalog.Index(db.Name(), d.Name)
+	if index == nil {
+		return nil, ErrIndexNotFound.New(d.Name, table.Name(), db.Name())
+	}
+	d.Catalog.ReleaseIndex(index)
+
+	done, err := d.Catalog.DeleteIndex(db.Name(), d.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	driver := d.Catalog.IndexDriver(index.Driver())
+	if driver == nil {
+		return nil, ErrInvalidIndexDriver.New(index.Driver())
+	}
+
+	<-done
+	if err := driver.Delete(index); err != nil {
+		return nil, err
+	}
+
+	return sql.RowsToRowIter(), nil
+}
+
+func (d *DropIndex) String() string {
+	pr := sql.NewTreePrinter()
+	_ = pr.WriteNode("DropIndex(%s)", d.Name)
+	_ = pr.WriteChildren(d.Table.String())
+	return pr.String()
+}
+
+// TransformExpressionsUp implements the Node interface.
+func (d *DropIndex) TransformExpressionsUp(fn sql.TransformExprFunc) (sql.Node, error) {
+	t, err := d.Table.TransformExpressionsUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewDropIndex(d.Name, t), nil
+}
+
+// TransformUp implements the Node interface.
+func (d *DropIndex) TransformUp(fn sql.TransformNodeFunc) (sql.Node, error) {
+	t, err := d.Table.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return fn(NewDropIndex(d.Name, t))
+}
diff --git a/sql/plan/drop_index_test.go b/sql/plan/drop_index_test.go
@@ -0,0 +1,62 @@
+package plan
+
+import (
+	"crypto/sha1"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/src-d/go-mysql-server.v0/mem"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+func TestDeleteIndex(t *testing.T) {
+	require := require.New(t)
+
+	table := &indexableTable{mem.NewTable("foo", sql.Schema{
+		{Name: "a", Source: "foo"},
+		{Name: "b", Source: "foo"},
+		{Name: "c", Source: "foo"},
+	})}
+
+	driver := new(mockDriver)
+	catalog := sql.NewCatalog()
+	catalog.RegisterIndexDriver(driver)
+	db := mem.NewDatabase("foo")
+	db.AddTable("foo", table)
+	catalog.Databases = append(catalog.Databases, db)
+
+	var expressions = []sql.Expression{
+		expression.NewGetFieldWithTable(0, sql.Int64, "foo", "c", true),
+		expression.NewGetFieldWithTable(1, sql.Int64, "foo", "a", true),
+	}
+	var hashes []sql.ExpressionHash
+
+	for _, e := range expressions {
+		h := sha1.Sum([]byte(e.String()))
+		exh := sql.ExpressionHash(h[:])
+		hashes = append(hashes, exh)
+	}
+
+	done, err := catalog.AddIndex(&mockIndex{id: "idx", db: "foo", table: "foo", exprs: hashes})
+	require.NoError(err)
+	close(done)
+
+	time.Sleep(50 * time.Millisecond)
+	idx := catalog.Index("foo", "idx")
+	require.NotNil(idx)
+	catalog.ReleaseIndex(idx)
+
+	di := NewDropIndex("idx", table)
+	di.Catalog = catalog
+	di.CurrentDatabase = "foo"
+
+	_, err = di.RowIter(sql.NewEmptyContext())
+	require.NoError(err)
+
+	time.Sleep(50 * time.Millisecond)
+
+	require.Equal([]string{"idx"}, driver.deleted)
+	require.Nil(catalog.Index("foo", "idx"))
+}

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,8 @@ type Index interface {`
`45`	`45`	`// one expression, it means the index has multiple columns indexed. If it's`
`46`	`46`	`// just one, it means it may be an expression or a column.`
`47`	`47`	`ExpressionHashes() []ExpressionHash`
	`48`	`+ // Driver ID of the index.`
	`49`	`+ Driver() string`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`// AscendIndex is an index that is sorted in ascending order.`
`@@ -206,6 +208,7 @@ func (r *IndexRegistry) ReleaseIndex(idx Index) {`
`206`	`208`	`func (r *IndexRegistry) Index(db, id string) Index {`
`207`	`209`	`r.mut.RLock()`
`208`	`210`	`defer r.mut.RUnlock()`
	`211`	`+ r.retainIndex(db, id)`
`209`	`212`	`return r.indexes[indexKey{db, strings.ToLower(id)}]`
`210`	`213`	`}`
`211`	`214`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,8 @@ func (idx *sqlIndex) ExpressionHashes() []sql.ExpressionHash {`
`144`	`144`	`return idx.expressions`
`145`	`145`	`}`
`146`	`146`
	`147`	`+func (sqlIndex) Driver() string { return "pilosa" }`
	`148`	`+`
`147`	`149`	`// lookup implements sql.IndexLookup and sql.IndexValueIter interface`
`148`	`150`	`type sqlIndexLookupIter struct {`
`149`	`151`	`offset uint64`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ var (`
`31`	`31`	`var (`
`32`	`32`	describeTablesRegex = regexp.MustCompile(`^describe\s+table\s+(.*)`)
`33`	`33`	createIndexRegex = regexp.MustCompile(`^create\s+index\s+`)
	`34`	+ dropIndexRegex = regexp.MustCompile(`^drop\s+index\s+`)
`34`	`35`	`)`
`35`	`36`
`36`	`37`	`// Parse parses the given SQL sentence and returns the corresponding node.`
`@@ -48,6 +49,8 @@ func Parse(ctx *sql.Context, s string) (sql.Node, error) {`
`48`	`49`	`return parseDescribeTables(lowerQuery)`
`49`	`50`	`case createIndexRegex.MatchString(lowerQuery):`
`50`	`51`	`return parseCreateIndex(s)`
	`52`	`+ case dropIndexRegex.MatchString(lowerQuery):`
	`53`	`+ return parseDropIndex(s)`
`51`	`54`	`}`
`52`	`55`
`53`	`56`	`stmt, err := sqlparser.Parse(s)`
`@@ -78,7 +81,7 @@ func convert(ctx *sql.Context, stmt sqlparser.Statement, query string) (sql.Node`
`78`	`81`	`case *sqlparser.Insert:`
`79`	`82`	`return convertInsert(ctx, n)`
`80`	`83`	`case *sqlparser.DDL:`
`81`		`- return convertDDL(n, query)`
	`84`	`+ return convertDDL(n)`
`82`	`85`	`}`
`83`	`86`	`}`
`84`	`87`
`@@ -141,7 +144,7 @@ func convertSelect(ctx sql.Context, s sqlparser.Select) (sql.Node, error) {`
`141`	`144`	`return node, nil`
`142`	`145`	`}`
`143`	`146`
`144`		`-func convertDDL(c *sqlparser.DDL, query string) (sql.Node, error) {`
	`147`	`+func convertDDL(c *sqlparser.DDL) (sql.Node, error) {`
`145`	`148`	`switch c.Action {`
`146`	`149`	`case sqlparser.CreateStr:`
`147`	`150`	`return convertCreateTable(c)`
Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,7 @@ func (i *mockIndex) Get(key ...interface{}) (sql.IndexLookup, error) {`
`71`	`71`	`func (i *mockIndex) Has(key ...interface{}) (bool, error) {`
`72`	`72`	`panic("unimplemented")`
`73`	`73`	`}`
	`74`	`+func (*mockIndex) Driver() string { return "mock" }`
`74`	`75`
`75`	`76`	`type mockDriver struct {`
`76`	`77`	`deleted []string`