sql: fix sort. (#38)

Author: smola

engine_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-
 func TestEngine_Query(t *testing.T) {
 	e := newEngine(t)
 	testQuery(t, e,
@@ -29,8 +28,16 @@ func TestEngine_Query(t *testing.T) {
 			sql.NewMemoryRow(int64(2)),
 		},
 	)
-}
 
+	testQuery(t, e,
+		"SELECT i FROM mytable ORDER BY i DESC;",
+		[]sql.Row{
+			sql.NewMemoryRow(int64(3)),
+			sql.NewMemoryRow(int64(2)),
+			sql.NewMemoryRow(int64(1)),
+		},
+	)
+}
 
 func testQuery(t *testing.T, e *gitql.Engine, q string, r []sql.Row) {
 	assert := require.New(t)

sql/plan/sort.go

@@ -93,14 +93,12 @@ func newSortIter(s *Sort, child sql.RowIter) *sortIter {
 
 func (i *sortIter) Next() (sql.Row, error) {
 	if i.idx == -1 {
-		println("computing sorted rows")
 		err := i.computeSortedRows()
 		if err != nil {
 			return nil, err
 		}
 		i.idx = 0
 	}
-	println("sorted rows: ", i.sortedRows)
 	if i.idx >= len(i.sortedRows) {
 		return nil, io.EOF
 	}
@@ -149,9 +147,18 @@ func (s *sorter) Less(i, j int) bool {
 		typ := sf.Column.Type()
 		av := sf.Column.Eval(a)
 		bv := sf.Column.Eval(b)
-		if typ.Compare(av, bv) == -1 {
+
+		if sf.Order == Descending {
+			av, bv = bv, av
+		}
+
+		switch typ.Compare(av, bv) {
+		case -1:
 			return true
+		case 1:
+			return false
 		}
 	}
+
 	return false
 }

sql/plan/sort_test.go

@@ -17,10 +17,12 @@ func TestSort(t *testing.T) {
 		sql.Field{"col1", sql.String},
 		sql.Field{"col2", sql.Integer},
 	}
+
 	child := mem.NewTable("test", childSchema)
 	child.Insert("a", int32(3))
 	child.Insert("b", int32(3))
 	child.Insert("c", int32(1))
+
 	sf := []SortField{
 		{Column: expression.NewGetField(1, sql.Integer, "col2"), Order: Ascending},
 		{Column: expression.NewGetField(0, sql.String, "col1"), Order: Descending},
@@ -30,19 +32,94 @@ func TestSort(t *testing.T) {
 	iter, err := s.RowIter()
 	assert.Nil(err)
 	assert.NotNil(iter)
+
 	row, err := iter.Next()
 	assert.Nil(err)
 	assert.NotNil(row)
 	assert.Equal("c", row.Fields()[0])
 	row, err = iter.Next()
 	assert.Nil(err)
 	assert.NotNil(row)
+	assert.Equal("b", row.Fields()[0])
+	row, err = iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+	assert.Equal("a", row.Fields()[0])
+	row, err = iter.Next()
+	assert.Equal(io.EOF, err)
+	assert.Nil(row)
+}
+
+func TestSort_Ascending(t *testing.T) {
+	assert := assert.New(t)
+	childSchema := sql.Schema{
+		sql.Field{"col1", sql.String},
+	}
+
+	child := mem.NewTable("test", childSchema)
+	child.Insert("b")
+	child.Insert("c")
+	child.Insert("a")
+
+	sf := []SortField{
+		{Column: expression.NewGetField(0, sql.String, "col1"), Order: Ascending},
+	}
+	s := NewSort(sf, child)
+	assert.Equal(childSchema, s.Schema())
+	iter, err := s.RowIter()
+	assert.Nil(err)
+	assert.NotNil(iter)
+
+	row, err := iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
 	assert.Equal("a", row.Fields()[0])
 	row, err = iter.Next()
 	assert.Nil(err)
 	assert.NotNil(row)
 	assert.Equal("b", row.Fields()[0])
 	row, err = iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+	assert.Equal("c", row.Fields()[0])
+	row, err = iter.Next()
+	assert.Equal(io.EOF, err)
+	assert.Nil(row)
+}
+
+func TestSort_Descending(t *testing.T) {
+	assert := assert.New(t)
+	childSchema := sql.Schema{
+		sql.Field{"col1", sql.String},
+	}
+
+	child := mem.NewTable("test", childSchema)
+	child.Insert("a")
+	child.Insert("c")
+	child.Insert("b")
+
+	sf := []SortField{
+		{Column: expression.NewGetField(0, sql.String, "col1"), Order: Descending},
+	}
+	s := NewSort(sf, child)
+	assert.Equal(childSchema, s.Schema())
+	iter, err := s.RowIter()
+	assert.Nil(err)
+	assert.NotNil(iter)
+
+	row, err := iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+	assert.Equal("c", row.Fields()[0])
+	row, err = iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+	assert.Equal("b", row.Fields()[0])
+	row, err = iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+	assert.Equal("a", row.Fields()[0])
+	row, err = iter.Next()
 	assert.Equal(io.EOF, err)
 	assert.Nil(row)
 }

sql/type_test.go

@@ -19,6 +19,9 @@ func TestType_String(t *testing.T) {
 	v, err = String.Convert(1)
 	assert.Equal(ErrInvalidType, err)
 	assert.Nil(v)
+	assert.Equal(-1, String.Compare("a", "b"))
+	assert.Equal(0, String.Compare("a", "a"))
+	assert.Equal(1, String.Compare("b", "a"))
 }
 
 func TestType_Integer(t *testing.T) {
@@ -50,6 +53,9 @@ func TestType_Integer(t *testing.T) {
 	v, err = Integer.Convert(uint64(18446744073709551615))
 	assert.NotNil(err)
 	assert.Nil(v)
+	assert.Equal(-1, Integer.Compare(int32(1), int32(2)))
+	assert.Equal(0, Integer.Compare(int32(1), int32(1)))
+	assert.Equal(1, Integer.Compare(int32(2), int32(1)))
 }
 
 func TestType_BigInteger(t *testing.T) {
@@ -81,4 +87,7 @@ func TestType_BigInteger(t *testing.T) {
 	v, err = BigInteger.Convert("")
 	assert.NotNil(err)
 	assert.Nil(v)
+	assert.Equal(-1, BigInteger.Compare(int64(1), int64(2)))
+	assert.Equal(0, BigInteger.Compare(int64(1), int64(1)))
+	assert.Equal(1, BigInteger.Compare(int64(2), int64(1)))
 }