add TransformExpressionsUp. (#29)

* Fix Sort to use Expressions.

Author: smola

git/commits.go

@@ -41,6 +41,10 @@ func (r *commitsRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(newCommitsRelation(r.r))
 }
 
+func (r *commitsRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	return r
+}
+
 func (r commitsRelation) RowIter() (sql.RowIter, error) {
 	cIter, err := r.r.Commits()
 	if err != nil {

mem/table.go

@@ -45,6 +45,10 @@ func (t *Table) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(NewTable(t.name, t.schema))
 }
 
+func (t *Table) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	return t
+}
+
 func (t *Table) Insert(values ...interface{}) error {
 	if len(values) != len(t.schema) {
 		return fmt.Errorf("insert expected %d values, got %d", len(t.schema), len(values))

sql/core.go

@@ -12,6 +12,7 @@ type Resolvable interface {
 
 type Transformable interface {
 	TransformUp(func(Node) Node) Node
+	TransformExpressionsUp(func(Expression) Expression) Node
 }
 
 type Node interface {

sql/expression/star.go

@@ -24,3 +24,7 @@ func (Star) Name() string {
 func (Star) Eval(r sql.Row) interface{} {
 	return "FAIL" //FIXME
 }
+
+func (s *Star) TransformUp(f func(sql.Expression) sql.Expression) sql.Expression {
+	return f(s)
+}

sql/parse/parse.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/sql/expression"
 	"github.com/mvader/gitql/sql/plan"
 )
 
@@ -296,7 +297,7 @@ func parseOrderClause(q tokenQueue) ([]plan.SortField, error) {
 				return nil, fmt.Errorf(`expecting "DESC", "ASC" or ",", received %q`, tk.Value)
 			}
 
-			field = &plan.SortField{Column: tk.Value}
+			field = &plan.SortField{Column: expression.NewUnresolvedColumn(tk.Value)}
 		case KeywordToken:
 			if field == nil {
 				return nil, fmt.Errorf(`unexpected keyword %q, expecting identifier`, tk.Value)

sql/plan/filter.go

@@ -37,6 +37,14 @@ func (p *Filter) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(n)
 }
 
+func (p *Filter) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	c := p.UnaryNode.Child.TransformExpressionsUp(f)
+	e := p.expression.TransformUp(f)
+	n := NewFilter(e, c)
+
+	return n
+}
+
 type filterIter struct {
 	f         *Filter
 	childIter sql.RowIter

sql/plan/limit.go

@@ -41,6 +41,13 @@ func (l *Limit) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(n)
 }
 
+func (l *Limit) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	c := l.UnaryNode.Child.TransformExpressionsUp(f)
+	n := NewLimit(l.size, c)
+
+	return n
+}
+
 type limitIter struct {
 	l          *Limit
 	currentPos int64

sql/plan/project.go

@@ -51,6 +51,17 @@ func (p *Project) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(n)
 }
 
+func (p *Project) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	c := p.UnaryNode.Child.TransformExpressionsUp(f)
+	es := []sql.Expression{}
+	for _, e := range p.expressions {
+		es = append(es, e.TransformUp(f))
+	}
+	n := NewProject(es, c)
+
+	return n
+}
+
 type iter struct {
 	p         *Project
 	childIter sql.RowIter

sql/plan/sort.go

@@ -1,7 +1,6 @@
 package plan
 
 import (
-	"fmt"
 	"io"
 	"sort"
 
@@ -10,9 +9,7 @@ import (
 
 type Sort struct {
 	UnaryNode
-	fieldIndexes []int
-	fieldTypes   []sql.Type
-	sortFields   []SortField
+	sortFields []SortField
 }
 
 type SortOrder byte
@@ -23,33 +20,14 @@ const (
 )
 
 type SortField struct {
-	Column string
+	Column sql.Expression
 	Order  SortOrder
 }
 
 func NewSort(sortFields []SortField, child sql.Node) *Sort {
-	indexes := []int{}
-	types := []sql.Type{}
-	childSchema := child.Schema()
-	for _, sortField := range sortFields {
-		found := false
-		for idx, field := range childSchema {
-			if field.Name == sortField.Column {
-				indexes = append(indexes, idx)
-				types = append(types, field.Type)
-				found = true
-				break
-			}
-		}
-		if found == false {
-			panic(fmt.Errorf("Field %s not found in child", sortField.Column))
-		}
-	}
 	return &Sort{
-		fieldIndexes: indexes,
-		fieldTypes:   types,
-		UnaryNode:    UnaryNode{child},
-		sortFields:   sortFields,
+		UnaryNode:  UnaryNode{child},
+		sortFields: sortFields,
 	}
 }
 
@@ -62,6 +40,7 @@ func (s *Sort) Schema() sql.Schema {
 }
 
 func (s *Sort) RowIter() (sql.RowIter, error) {
+
 	i, err := s.UnaryNode.Child.RowIter()
 	if err != nil {
 		return nil, err
@@ -76,6 +55,17 @@ func (s *Sort) TransformUp(f func(sql.Node) sql.Node) sql.Node {
 	return f(n)
 }
 
+func (s *Sort) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	c := s.UnaryNode.Child.TransformExpressionsUp(f)
+	sfs := []SortField{}
+	for _, sf := range s.sortFields {
+		sfs = append(sfs, SortField{sf.Column.TransformUp(f), sf.Order})
+	}
+	n := NewSort(sfs, c)
+
+	return n
+}
+
 type sortIter struct {
 	s          *Sort
 	childIter  sql.RowIter
@@ -123,18 +113,16 @@ func (i *sortIter) computeSortedRows() error {
 		rows = append(rows, childRow)
 	}
 	sort.Sort(&sorter{
-		indexes: i.s.fieldIndexes,
-		types:   i.s.fieldTypes,
-		rows:    rows,
+		sortFields: i.s.sortFields,
+		rows:       rows,
 	})
 	i.sortedRows = rows
 	return nil
 }
 
 type sorter struct {
-	indexes []int
-	types   []sql.Type
-	rows    []sql.Row
+	sortFields []SortField
+	rows       []sql.Row
 }
 
 func (s *sorter) Len() int {
@@ -146,12 +134,12 @@ func (s *sorter) Swap(i, j int) {
 }
 
 func (s *sorter) Less(i, j int) bool {
-	a := s.rows[i].Fields()
-	b := s.rows[j].Fields()
-	for i, idx := range s.indexes {
-		typ := s.types[i]
-		av := a[idx]
-		bv := b[idx]
+	a := s.rows[i]
+	b := s.rows[j]
+	for _, sf := range s.sortFields {
+		typ := sf.Column.Type()
+		av := sf.Column.Eval(a)
+		bv := sf.Column.Eval(b)
 		if typ.Compare(av, bv) == -1 {
 			return true
 		}

sql/plan/sort_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/mvader/gitql/mem"
 	"github.com/mvader/gitql/sql"
+	"github.com/mvader/gitql/sql/expression"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -20,8 +21,8 @@ func TestSort(t *testing.T) {
 	child.Insert("b", int32(3))
 	child.Insert("c", int32(1))
 	sf := []SortField{
-		{Column: "col2", Order: Ascending},
-		{Column: "col1", Order: Descending},
+		{Column: expression.NewGetField(1, sql.Integer, "col2"), Order: Ascending},
+		{Column: expression.NewGetField(0, sql.String, "col1"), Order: Descending},
 	}
 	s := NewSort(sf, child)
 	assert.Equal(childSchema, s.Schema())