Add engine and integrate CLI (#31)

smola · web-flow · commit 1d8c7ed8ecd4 · 2016-10-21T17:27:50.000+02:00
* Add Engine.

* This is the main entry point.

* integrate command

* remove debug left overs
diff --git a/cmd/gitql/query.go b/cmd/gitql/query.go
@@ -6,10 +6,13 @@ import (
 	"os"
 	"path/filepath"
 
-	gitql "github.com/mvader/gitql/git"
+	gitqlgit "github.com/mvader/gitql/git"
 	"github.com/mvader/gitql/sql"
 
 	"gopkg.in/src-d/go-git.v4"
+	"github.com/mvader/gitql"
+	"io"
+	"github.com/olekukonko/tablewriter"
 )
 
 type CmdQuery struct {
@@ -75,17 +78,51 @@ func (c *CmdQuery) buildDatabase() error {
 	c.print("current HEAD %q\n", head.Hash())
 
 	name := filepath.Base(filepath.Join(c.Path, ".."))
-	c.db = gitql.NewDatabase(name, c.r)
+	c.db = gitqlgit.NewDatabase(name, c.r)
 	return nil
 }
 
 func (c *CmdQuery) executeQuery() error {
 	c.print("executing %q at %q\n", c.Args.SQL, c.db.Name())
 
 	fmt.Println(c.Args.SQL)
+	e := gitql.New()
+	e.AddDatabase(c.db)
+	schema, iter, err := e.Query(c.Args.SQL)
+	if err != nil {
+		return err
+	}
+
+	c.printQuery(schema, iter)
+
 	return nil
 }
 
+func (c *CmdQuery) printQuery(schema sql.Schema, iter sql.RowIter) {
+	w := tablewriter.NewWriter(os.Stdout)
+	headers := []string{}
+	for _, f := range schema {
+		headers = append(headers, f.Name)
+	}
+	w.SetHeader(headers)
+	for {
+		row, err := iter.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			fmt.Printf("Error: %v\n", err)
+			return
+		}
+		rowStrings := []string{}
+		for _, v := range row.Fields() {
+			rowStrings = append(rowStrings, fmt.Sprintf("%v", v))
+		}
+		w.Append(rowStrings)
+	}
+	w.Render()
+}
+
 func findDotGitFolder(path string) (string, error) {
 	if path == "" {
 		var err error
diff --git a/engine.go b/engine.go
@@ -0,0 +1,44 @@
+package gitql
+
+import (
+	"strings"
+
+	"github.com/mvader/gitql/sql/analyzer"
+	"github.com/mvader/gitql/sql/parse"
+	"github.com/mvader/gitql/sql"
+)
+
+type Engine struct {
+	Catalog  *sql.Catalog
+	Analyzer *analyzer.Analyzer
+}
+
+func New() *Engine {
+	c := &sql.Catalog{}
+	a := analyzer.New(c)
+	return &Engine{c, a}
+}
+
+func (e *Engine) AddDatabase(db sql.Database) {
+	e.Catalog.Databases = append(e.Catalog.Databases, db)
+	e.Analyzer.CurrentDatabase = db.Name()
+}
+
+func (e *Engine) Query(query string) (sql.Schema, sql.RowIter, error) {
+	parsed, err := parse.Parse(strings.NewReader(query))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	analyzed, err := e.Analyzer.Analyze(parsed)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	iter, err := analyzed.RowIter()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return analyzed.Schema(), iter, nil
+}
diff --git a/engine_test.go b/engine_test.go
@@ -0,0 +1,49 @@
+package gitql_test
+
+import (
+	"testing"
+	"io"
+
+	"github.com/stretchr/testify/require"
+	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/mem"
+	"github.com/mvader/gitql"
+)
+
+func TestEngine_Query(t *testing.T) {
+	assert := require.New(t)
+
+	table := mem.NewTable("mytable", sql.Schema{{"i", sql.Integer}})
+	assert.Nil(table.Insert(int32(1)))
+	assert.Nil(table.Insert(int32(2)))
+	assert.Nil(table.Insert(int32(3)))
+
+	db := mem.NewDatabase("mydb")
+	db.AddTable("mytable", table)
+
+	e := gitql.New()
+	e.AddDatabase(db)
+
+	q := "SELECT i FROM mytable;"
+	schema, iter, err := e.Query(q)
+	assert.Nil(err)
+	assert.NotNil(iter)
+	assert.NotNil(schema)
+
+	results := []sql.Row{}
+	for {
+		el, err := iter.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			assert.Fail("returned err distinct of io.EOF: %q", err)
+		}
+		results = append(results, el)
+	}
+	assert.Len(results, 3)
+	assert.Equal(sql.NewMemoryRow(int32(1)), results[0])
+	assert.Equal(sql.NewMemoryRow(int32(2)), results[1])
+	assert.Equal(sql.NewMemoryRow(int32(3)), results[2])
+}
+
diff --git a/mem/database.go b/mem/database.go
@@ -7,9 +7,9 @@ type Database struct {
 	tables map[string]sql.PhysicalRelation
 }
 
-func NewDatabase(name string) Database {
-	return Database{
-		name:   name,
+func NewDatabase(name string) *Database {
+	return &Database{
+		name: name,
 		tables: map[string]sql.PhysicalRelation{},
 	}
 }
diff --git a/sql/analyzer/analyzer.go b/sql/analyzer/analyzer.go
@@ -12,7 +12,7 @@ const maxAnalysisIterations = 1000
 
 type Analyzer struct {
 	Rules           []Rule
-	Catalog         sql.Catalog
+	Catalog         *sql.Catalog
 	CurrentDatabase string
 }
 
@@ -21,7 +21,7 @@ type Rule struct {
 	Apply func(*Analyzer, sql.Node) sql.Node
 }
 
-func New(catalog sql.Catalog) *Analyzer {
+func New(catalog *sql.Catalog) *Analyzer {
 	return &Analyzer{
 		Rules:   DefaultRules,
 		Catalog: catalog,
diff --git a/sql/analyzer/analyzer_test.go b/sql/analyzer/analyzer_test.go
@@ -19,7 +19,7 @@ func TestAnalyzer_Analyze(t *testing.T) {
 	db := mem.NewDatabase("mydb")
 	db.AddTable("mytable", table)
 
-	catalog := sql.Catalog{db}
+	catalog := &sql.Catalog{Databases:[]sql.Database{db}}
 	a := analyzer.New(catalog)
 	a.CurrentDatabase = "mydb"
 
@@ -53,7 +53,7 @@ func TestAnalyzer_Analyze(t *testing.T) {
 func TestAnalyzer_Analyze_MaxIterations(t *testing.T) {
 	assert := require.New(t)
 
-	catalog := sql.Catalog{}
+	catalog := &sql.Catalog{}
 	a := analyzer.New(catalog)
 	a.CurrentDatabase = "mydb"
 
diff --git a/sql/analyzer/rules.go b/sql/analyzer/rules.go
@@ -1,7 +1,6 @@
 package analyzer
 
 import (
-	"fmt"
 	"github.com/mvader/gitql/sql"
 	"github.com/mvader/gitql/sql/expression"
 	"github.com/mvader/gitql/sql/plan"
@@ -20,6 +19,7 @@ func resolveTables(a *Analyzer, n sql.Node) sql.Node {
 		}
 
 		rt, err := a.Catalog.Table(a.CurrentDatabase, t.Name)
+
 		if err != nil {
 			return n
 		}
diff --git a/sql/analyzer/rules_test.go b/sql/analyzer/rules_test.go
@@ -20,7 +20,7 @@ func Test_resolveTables(t *testing.T) {
 	db := mem.NewDatabase("mydb")
 	db.AddTable("mytable", table)
 
-	catalog := sql.Catalog{db}
+	catalog := &sql.Catalog{Databases:[]sql.Database{db}}
 
 	a := analyzer.New(catalog)
 	a.Rules = []analyzer.Rule{f}
@@ -48,7 +48,7 @@ func Test_resolveTables_Nested(t *testing.T) {
 	db := mem.NewDatabase("mydb")
 	db.AddTable("mytable", table)
 
-	catalog := sql.Catalog{db}
+	catalog := &sql.Catalog{Databases:[]sql.Database{db}}
 
 	a := analyzer.New(catalog)
 	a.Rules = []analyzer.Rule{f}
diff --git a/sql/catalog.go b/sql/catalog.go
@@ -4,10 +4,12 @@ import (
 	"fmt"
 )
 
-type Catalog []Database
+type Catalog struct {
+	Databases []Database
+}
 
 func (c Catalog) Database(name string) (Database, error) {
-	for _, db := range []Database(c) {
+	for _, db := range c.Databases {
 		if db.Name() == name {
 			return db, nil
 		}
diff --git a/sql/parse/parse.go b/sql/parse/parse.go
@@ -232,18 +232,12 @@ func (p *parser) parse() error {
 	return nil
 }
 
-func (p *parser) buildPlan(relations []sql.PhysicalRelation) (sql.Node, error) {
-	var node sql.Node
-	for _, r := range relations {
-		if r.Name() == p.relation {
-			node = r
-			break
-		}
+func (p *parser) buildPlan() (sql.Node, error) {
+	if p.relation == "" {
+		return nil, errors.New("missing relation name")
 	}
 
-	if node == nil {
-		return nil, fmt.Errorf("unknown table name %q", p.relation)
-	}
+	var node sql.Node = plan.NewUnresolvedRelation(p.relation)
 
 	if len(p.filterClauses) > 0 {
 		node = plan.NewFilter(p.filterClauses[0], node)
@@ -257,13 +251,13 @@ func (p *parser) buildPlan(relations []sql.PhysicalRelation) (sql.Node, error) {
 	return node, nil
 }
 
-func Parse(input io.Reader, relations []sql.PhysicalRelation) (sql.Node, error) {
+func Parse(input io.Reader) (sql.Node, error) {
 	p := newParser(input)
 	if err := p.parse(); err != nil {
 		return nil, err
 	}
 
-	return p.buildPlan(relations)
+	return p.buildPlan()
 }
 
 func LastStates(input io.Reader) (ParseState, ParseState, error) {
diff --git a/sql/parse/parse_test.go b/sql/parse/parse_test.go
@@ -9,10 +9,11 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const testSelect = `SELECT foo, bar FROM foo WHERE foo = bar;`
+const testSelectFromWhere = `SELECT foo, bar FROM foo WHERE foo = bar;`
+const testSelectFrom = `SELECT foo, bar FROM foo;`
 
 func TestParseSelectFromWhere(t *testing.T) {
-	p := newParser(strings.NewReader(testSelect))
+	p := newParser(strings.NewReader(testSelectFromWhere))
 	require.Nil(t, p.parse())
 
 	require.Equal(t, p.projection, []sql.Expression{
@@ -33,3 +34,19 @@ func TestParseSelectFromWhere(t *testing.T) {
 	require.Nil(t, p.err)
 	require.Equal(t, DoneState, p.stateStack.pop())
 }
+
+func TestParseSelectFrom(t *testing.T) {
+	p := newParser(strings.NewReader(testSelectFrom))
+	require.Nil(t, p.parse())
+
+	require.Equal(t, p.projection, []sql.Expression{
+		expression.NewUnresolvedColumn("foo"),
+		expression.NewUnresolvedColumn("bar"),
+	})
+
+	require.Equal(t, p.relation, "foo")
+
+	require.Nil(t, p.sortFields)
+	require.Nil(t, p.err)
+	require.Equal(t, DoneState, p.stateStack.pop())
+}
diff --git a/sql/plan/transform_test.go b/sql/plan/transform_test.go
@@ -1,7 +1,6 @@
 package plan
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/mvader/gitql/mem"
@@ -25,11 +24,10 @@ func TestTransformUp(t *testing.T) {
 	table := mem.NewTable("resolved", schema)
 
 	pt := p.TransformUp(func(n sql.Node) sql.Node {
-		switch t := n.(type) {
+		switch n.(type) {
 		case *UnresolvedRelation:
 			return table
 		default:
-			fmt.Printf("unexpected type %T\n", t)
 			return n
 		}
 	})
diff --git a/sql/plan/unresolved.go b/sql/plan/unresolved.go
@@ -31,7 +31,7 @@ func (*UnresolvedRelation) RowIter() (sql.RowIter, error) {
 }
 
 func (p *UnresolvedRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node {
-	return f(&UnresolvedRelation{p.Name})
+	return f(NewUnresolvedRelation(p.Name))
 }
 
 func (p *UnresolvedRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@ type Database struct {`
`7`	`7`	`tables map[string]sql.PhysicalRelation`
`8`	`8`	`}`
`9`	`9`
`10`		`-func NewDatabase(name string) Database {`
`11`		`- return Database{`
`12`		`- name: name,`
	`10`	`+func NewDatabase(name string) *Database {`
	`11`	`+ return &Database{`
	`12`	`+ name: name,`
`13`	`13`	`tables: map[string]sql.PhysicalRelation{},`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ const maxAnalysisIterations = 1000`
`12`	`12`
`13`	`13`	`type Analyzer struct {`
`14`	`14`	`Rules []Rule`
`15`		`- Catalog sql.Catalog`
	`15`	`+ Catalog *sql.Catalog`
`16`	`16`	`CurrentDatabase string`
`17`	`17`	`}`
`18`	`18`
`@@ -21,7 +21,7 @@ type Rule struct {`
`21`	`21`	`Apply func(*Analyzer, sql.Node) sql.Node`
`22`	`22`	`}`
`23`	`23`
`24`		`-func New(catalog sql.Catalog) *Analyzer {`
	`24`	`+func New(catalog sql.Catalog) Analyzer {`
`25`	`25`	`return &Analyzer{`
`26`	`26`	`Rules: DefaultRules,`
`27`	`27`	`Catalog: catalog,`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`package analyzer`
`2`	`2`
`3`	`3`	`import (`
`4`		`- "fmt"`
`5`	`4`	`"github.com/mvader/gitql/sql"`
`6`	`5`	`"github.com/mvader/gitql/sql/expression"`
`7`	`6`	`"github.com/mvader/gitql/sql/plan"`
`@@ -20,6 +19,7 @@ func resolveTables(a *Analyzer, n sql.Node) sql.Node {`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`rt, err := a.Catalog.Table(a.CurrentDatabase, t.Name)`
	`22`	`+`
`23`	`23`	`if err != nil {`
`24`	`24`	`return n`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,12 @@ import (`
`4`	`4`	`"fmt"`
`5`	`5`	`)`
`6`	`6`
`7`		`-type Catalog []Database`
	`7`	`+type Catalog struct {`
	`8`	`+ Databases []Database`
	`9`	`+}`
`8`	`10`
`9`	`11`	`func (c Catalog) Database(name string) (Database, error) {`
`10`		`- for _, db := range []Database(c) {`
	`12`	`+ for _, db := range c.Databases {`
`11`	`13`	`if db.Name() == name {`
`12`	`14`	`return db, nil`
`13`	`15`	`}`