add analyzer package. (#26)

* Add analyzer.Analyzer.
* Add rule to resolve table.

Author: smola

git/commits.go

@@ -38,7 +38,7 @@ func (commitsRelation) Schema() sql.Schema {
 }
 
 func (r *commitsRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node {
-	return f(newCommitsRelation(r.r))
+	return f(r)
 }
 
 func (r *commitsRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {

mem/table.go

@@ -42,7 +42,7 @@ func (t *Table) RowIter() (sql.RowIter, error) {
 }
 
 func (t *Table) TransformUp(f func(sql.Node) sql.Node) sql.Node {
-	return f(NewTable(t.name, t.schema))
+	return f(t)
 }
 
 func (t *Table) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {

sql/analyzer/analyzer.go

@@ -0,0 +1,66 @@
+package analyzer
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/mvader/gitql/sql"
+)
+
+const maxAnalysisIterations = 1000
+
+type Analyzer struct {
+	Rules           []Rule
+	Catalog         sql.Catalog
+	CurrentDatabase string
+}
+
+type Rule struct {
+	Name  string
+	Apply func(*Analyzer, sql.Node) sql.Node
+}
+
+func New(catalog sql.Catalog) *Analyzer {
+	return &Analyzer{
+		Rules:   DefaultRules,
+		Catalog: catalog,
+	}
+}
+
+func (a *Analyzer) Analyze(n sql.Node) (sql.Node, error) {
+	prev := n
+	cur := a.analyzeOnce(n)
+	i := 0
+	for !reflect.DeepEqual(prev, cur) {
+		prev = cur
+		cur = a.analyzeOnce(n)
+		i += 1
+		if i >= maxAnalysisIterations {
+			return cur, fmt.Errorf("exceeded max analysis iterations (%d)", maxAnalysisIterations)
+		}
+	}
+
+	err := a.validate(cur)
+	if err != nil {
+		return cur, err
+	}
+
+	return cur, nil
+}
+
+func (a *Analyzer) analyzeOnce(n sql.Node) sql.Node {
+	result := n
+	for _, rule := range a.Rules {
+		result = rule.Apply(a, result)
+	}
+	return result
+}
+
+func (a *Analyzer) validate(n sql.Node) error {
+	if !n.Resolved() {
+		return errors.New("plan is not resolved")
+	}
+
+	return nil
+}

sql/analyzer/analyzer_test.go

@@ -0,0 +1,73 @@
+package analyzer_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/mvader/gitql/mem"
+	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/sql/analyzer"
+	"github.com/mvader/gitql/sql/expression"
+	"github.com/mvader/gitql/sql/plan"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAnalyzer_Analyze(t *testing.T) {
+	assert := require.New(t)
+
+	table := mem.NewTable("mytable", sql.Schema{{"i", sql.Integer}})
+	db := mem.NewDatabase("mydb")
+	db.AddTable("mytable", table)
+
+	catalog := sql.Catalog{db}
+	a := analyzer.New(catalog)
+	a.CurrentDatabase = "mydb"
+
+	var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable")
+	analyzed, err := a.Analyze(notAnalyzed)
+	assert.Nil(err)
+	assert.Equal(table, analyzed)
+
+	notAnalyzed = plan.NewUnresolvedRelation("nonexistant")
+	analyzed, err = a.Analyze(notAnalyzed)
+	assert.NotNil(err)
+	assert.Equal(notAnalyzed, analyzed)
+
+	analyzed, err = a.Analyze(table)
+	assert.Nil(err)
+	assert.Equal(table, analyzed)
+
+	notAnalyzed = plan.NewProject(
+		[]sql.Expression{expression.NewUnresolvedColumn("i")},
+		plan.NewUnresolvedRelation("mytable"),
+	)
+	analyzed, err = a.Analyze(notAnalyzed)
+	expected := plan.NewProject(
+		[]sql.Expression{expression.NewGetField(0, sql.Integer, "i")},
+		table,
+	)
+	assert.Nil(err)
+	assert.Equal(expected, analyzed)
+}
+
+func TestAnalyzer_Analyze_MaxIterations(t *testing.T) {
+	assert := require.New(t)
+
+	catalog := sql.Catalog{}
+	a := analyzer.New(catalog)
+	a.CurrentDatabase = "mydb"
+
+	i := 0
+	a.Rules = []analyzer.Rule{{
+		"infinite",
+		func(a *analyzer.Analyzer, n sql.Node) sql.Node {
+			i += 1
+			return plan.NewUnresolvedRelation(fmt.Sprintf("rel%d", i))
+		},
+	}}
+
+	notAnalyzed := plan.NewUnresolvedRelation("mytable")
+	analyzed, err := a.Analyze(notAnalyzed)
+	assert.NotNil(err)
+	assert.Equal(plan.NewUnresolvedRelation("rel1001"), analyzed)
+}

sql/analyzer/rules.go

@@ -0,0 +1,63 @@
+package analyzer
+
+import (
+	"fmt"
+	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/sql/expression"
+	"github.com/mvader/gitql/sql/plan"
+)
+
+var DefaultRules = []Rule{
+	{"resolve_tables", resolveTables},
+	{"resolve_columns", resolveColumns},
+}
+
+func resolveTables(a *Analyzer, n sql.Node) sql.Node {
+	return n.TransformUp(func(n sql.Node) sql.Node {
+		t, ok := n.(*plan.UnresolvedRelation)
+		if !ok {
+			return n
+		}
+
+		rt, err := a.Catalog.Table(a.CurrentDatabase, t.Name)
+		if err != nil {
+			return n
+		}
+
+		return rt
+	})
+}
+
+func resolveColumns(a *Analyzer, n sql.Node) sql.Node {
+	if n.Resolved() {
+		return n
+	}
+
+	if len(n.Children()) != 1 {
+		return n
+	}
+
+	child := n.Children()[0]
+	if !child.Resolved() {
+		return n
+	}
+
+	colMap := map[string]*expression.GetField{}
+	for idx, child := range child.Schema() {
+		colMap[child.Name] = expression.NewGetField(idx, child.Type, child.Name)
+	}
+
+	return n.TransformExpressionsUp(func(e sql.Expression) sql.Expression {
+		uc, ok := e.(*expression.UnresolvedColumn)
+		if !ok {
+			return e
+		}
+
+		gf, ok := colMap[uc.Name()]
+		if !ok {
+			return e
+		}
+
+		return gf
+	})
+}

sql/analyzer/rules_test.go

@@ -0,0 +1,76 @@
+package analyzer_test
+
+import (
+	"testing"
+
+	"github.com/mvader/gitql/mem"
+	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/sql/analyzer"
+	"github.com/mvader/gitql/sql/expression"
+	"github.com/mvader/gitql/sql/plan"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_resolveTables(t *testing.T) {
+	assert := assert.New(t)
+
+	f := getRule("resolve_tables")
+
+	table := mem.NewTable("mytable", sql.Schema{{"i", sql.Integer}})
+	db := mem.NewDatabase("mydb")
+	db.AddTable("mytable", table)
+
+	catalog := sql.Catalog{db}
+
+	a := analyzer.New(catalog)
+	a.Rules = []analyzer.Rule{f}
+
+	a.CurrentDatabase = "mydb"
+	var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable")
+	analyzed := f.Apply(a, notAnalyzed)
+	assert.Equal(table, analyzed)
+
+	notAnalyzed = plan.NewUnresolvedRelation("nonexistant")
+	analyzed = f.Apply(a, notAnalyzed)
+	assert.Equal(notAnalyzed, analyzed)
+
+	analyzed = f.Apply(a, table)
+	assert.Equal(table, analyzed)
+
+}
+
+func Test_resolveTables_Nested(t *testing.T) {
+	assert := assert.New(t)
+
+	f := getRule("resolve_tables")
+
+	table := mem.NewTable("mytable", sql.Schema{{"i", sql.Integer}})
+	db := mem.NewDatabase("mydb")
+	db.AddTable("mytable", table)
+
+	catalog := sql.Catalog{db}
+
+	a := analyzer.New(catalog)
+	a.Rules = []analyzer.Rule{f}
+	a.CurrentDatabase = "mydb"
+
+	notAnalyzed := plan.NewProject(
+		[]sql.Expression{expression.NewGetField(0, sql.Integer, "i")},
+		plan.NewUnresolvedRelation("mytable"),
+	)
+	analyzed := f.Apply(a, notAnalyzed)
+	expected := plan.NewProject(
+		[]sql.Expression{expression.NewGetField(0, sql.Integer, "i")},
+		table,
+	)
+	assert.Equal(expected, analyzed)
+}
+
+func getRule(name string) analyzer.Rule {
+	for _, rule := range analyzer.DefaultRules {
+		if rule.Name == name {
+			return rule
+		}
+	}
+	panic("missing rule")
+}

sql/catalog.go

@@ -0,0 +1,32 @@
+package sql
+
+import (
+	"fmt"
+)
+
+type Catalog []Database
+
+func (c Catalog) Database(name string) (Database, error) {
+	for _, db := range []Database(c) {
+		if db.Name() == name {
+			return db, nil
+		}
+	}
+
+	return nil, fmt.Errorf("database not found: %s", name)
+}
+
+func (c Catalog) Table(dbName string, tableName string) (PhysicalRelation, error) {
+	db, err := c.Database(dbName)
+	if err != nil {
+		return nil, err
+	}
+
+	tables := db.Relations()
+	table, found := tables[tableName]
+	if !found {
+		return nil, fmt.Errorf("table not found: %s", tableName)
+	}
+
+	return table, nil
+}

sql/plan/project.go

@@ -64,7 +64,8 @@ func (p *Project) TransformExpressionsUp(f func(sql.Expression) sql.Expression)
 	c := p.UnaryNode.Child.TransformExpressionsUp(f)
 	es := []sql.Expression{}
 	for _, e := range p.expressions {
-		es = append(es, e.TransformUp(f))
+		te := e.TransformUp(f)
+		es = append(es, te)
 	}
 	n := NewProject(es, c)
 

sql/plan/unresolved.go

@@ -10,6 +10,10 @@ type UnresolvedRelation struct {
 	Name string
 }
 
+func NewUnresolvedRelation(name string) *UnresolvedRelation {
+	return &UnresolvedRelation{name}
+}
+
 func (*UnresolvedRelation) Resolved() bool {
 	return false
 }

sql/plan/unresolved_test.go

@@ -9,6 +9,6 @@ import (
 
 func TestUnresolvedRelation(t *testing.T) {
 	assert := assert.New(t)
-	var r sql.Node = &UnresolvedRelation{"test_table"}
+	var r sql.Node = NewUnresolvedRelation("test_table")
 	assert.NotNil(r)
 }