plan: Added SHOW TABLES query (#64)

Author: ajnavarro

README.md

@@ -57,6 +57,7 @@ gitql supports a subset of the SQL standard, currently including:
 * `WHERE` (`=` only)
 * `ORDER BY` (with `ASC` and `DESC`)
 * `LIMIT`
+* `SHOW TABLES`
 
 ## License
 

sql/analyzer/rules.go

@@ -9,9 +9,24 @@ import (
 var DefaultRules = []Rule{
 	{"resolve_tables", resolveTables},
 	{"resolve_columns", resolveColumns},
+	{"resolve_database", resolveDatabase},
 	{"resolve_star", resolveStar},
 }
 
+func resolveDatabase(a *Analyzer, n sql.Node) sql.Node {
+	_, ok := n.(*plan.ShowTables)
+	if !ok {
+		return n
+	}
+
+	db, err := a.Catalog.Database(a.CurrentDatabase)
+	if err != nil {
+		return n
+	}
+
+	return plan.NewShowTables(db)
+}
+
 func resolveTables(a *Analyzer, n sql.Node) sql.Node {
 	return n.TransformUp(func(n sql.Node) sql.Node {
 		t, ok := n.(*plan.UnresolvedTable)

sql/core.go

@@ -28,4 +28,9 @@ type Table interface {
 	Node
 }
 
+type Database interface {
+	Nameable
+	Tables() map[string]Table
+}
+
 var ErrInvalidType = errors.New("invalid type")

sql/database.go

@@ -12,6 +12,10 @@ import (
 	"github.com/youtube/vitess/go/vt/sqlparser"
 )
 
+const (
+	showTables = "SHOW TABLES"
+)
+
 func errUnsupported(n sqlparser.SQLNode) error {
 	return fmt.Errorf("unsupported syntax: %#v", n)
 }
@@ -25,6 +29,11 @@ func Parse(s string) (sql.Node, error) {
 		s = s[:len(s)-1]
 	}
 
+	// TODO implement it into the parser
+	if strings.ToUpper(s) == showTables {
+		return plan.NewShowTables(&sql.UnresolvedDatabase{}), nil
+	}
+
 	stmt, err := sqlparser.Parse(s)
 	if err != nil {
 		return nil, err

sql/parse/parse.go

@@ -0,0 +1,67 @@
+package plan
+
+import (
+	"io"
+	"sort"
+
+	"github.com/gitql/gitql/sql"
+)
+
+type ShowTables struct {
+	database sql.Database
+}
+
+func NewShowTables(database sql.Database) *ShowTables {
+	return &ShowTables{
+		database: database,
+	}
+}
+
+func (p *ShowTables) Resolved() bool {
+	_, ok := p.database.(*sql.UnresolvedDatabase)
+	return !ok
+}
+
+func (*ShowTables) Children() []sql.Node {
+	return nil
+}
+
+func (*ShowTables) Schema() sql.Schema {
+	return sql.Schema{{
+		"table", sql.String,
+	}}
+}
+
+func (p *ShowTables) RowIter() (sql.RowIter, error) {
+	tableNames := []string{}
+	for key := range p.database.Tables() {
+		tableNames = append(tableNames, key)
+	}
+
+	sort.Strings(tableNames)
+
+	return &showTablesIter{tableNames: tableNames}, nil
+}
+
+func (p *ShowTables) TransformUp(f func(sql.Node) sql.Node) sql.Node {
+	return f(NewShowTables(p.database))
+}
+
+func (p *ShowTables) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	return p
+}
+
+type showTablesIter struct {
+	tableNames []string
+	idx        int
+}
+
+func (i *showTablesIter) Next() (sql.Row, error) {
+	if i.idx >= len(i.tableNames) {
+		return nil, io.EOF
+	}
+	row := sql.NewMemoryRow(i.tableNames[i.idx])
+	i.idx++
+
+	return row, nil
+}

sql/plan/show_tables.go

@@ -0,0 +1,46 @@
+package plan
+
+import (
+	"io"
+	"testing"
+
+	"github.com/gitql/gitql/mem"
+	"github.com/gitql/gitql/sql"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestShowTables(t *testing.T) {
+	assert := assert.New(t)
+
+	unresolvedShowTables := NewShowTables(&sql.UnresolvedDatabase{})
+
+	assert.False(unresolvedShowTables.Resolved())
+	assert.Nil(unresolvedShowTables.Children())
+
+	db := mem.NewDatabase("test")
+	db.AddTable("test1", mem.NewTable("test1", nil))
+	db.AddTable("test2", mem.NewTable("test2", nil))
+	db.AddTable("test3", mem.NewTable("test3", nil))
+
+	resolvedShowTables := NewShowTables(db)
+	assert.True(resolvedShowTables.Resolved())
+	assert.Nil(resolvedShowTables.Children())
+
+	iter, err := resolvedShowTables.RowIter()
+	assert.Nil(err)
+
+	res, err := iter.Next()
+	assert.Nil(err)
+	assert.Equal("test1", res.Fields()[0])
+
+	res, err = iter.Next()
+	assert.Nil(err)
+	assert.Equal("test2", res.Fields()[0])
+
+	res, err = iter.Next()
+	assert.Nil(err)
+	assert.Equal("test3", res.Fields()[0])
+
+	_, err = iter.Next()
+	assert.Equal(io.EOF, err)
+}

sql/plan/show_tables_test.go

@@ -0,0 +1,11 @@
+package sql
+
+type UnresolvedDatabase struct{}
+
+func (d *UnresolvedDatabase) Name() string {
+	return "unresolved_database"
+}
+
+func (d *UnresolvedDatabase) Tables() map[string]Table {
+	return make(map[string]Table)
+}