Change default query order to descending. Make datastore respect query order

src/datastore/datastore_test.go

@@ -356,3 +356,38 @@ func (self *DatastoreSuite) TestLimitsPointsReturnedBasedOnQuery(c *C) {
 	c.Assert(*results.Points[0].SequenceNumber, Equals, uint32(2))
 	c.Assert(*results.Points[0].Values[0].StringValue, Equals, "paul")
 }
+
+func (self *DatastoreSuite) TestReturnsResultsInAscendingOrder(c *C) {
+	cleanup(nil)
+	db := newDatastore(c)
+	defer cleanup(db)
+
+	minuteAgo := time.Now().Add(-time.Minute).Unix()
+	mock := `{
+    "points":[
+      {"values":[{"string_value":"paul"}],"sequence_number":1},
+      {"values":[{"string_value":"todd"}],"sequence_number":2}],
+      "name":"user_things",
+      "fields":[{"type":"STRING","name":"name"}]
+    }`
+	series := stringToSeries(mock, minuteAgo, c)
+	err := db.WriteSeriesData("foobar", series)
+	c.Assert(err, IsNil)
+	results := executeQuery("foobar", "select name from user_things order asc;", db, c)
+	c.Assert(results, DeepEquals, series)
+
+	mock = `{
+    "points":[
+      {"values":[{"string_value":"john"}],"sequence_number":1}],
+      "name":"user_things",
+      "fields":[{"type":"STRING","name":"name"}]
+    }`
+	newSeries := stringToSeries(mock, time.Now().Unix(), c)
+	err = db.WriteSeriesData("foobar", newSeries)
+	c.Assert(err, IsNil)
+	results = executeQuery("foobar", "select name from user_things order asc;", db, c)
+	c.Assert(len(results.Points), Equals, 3)
+	c.Assert(*results.Points[0].Values[0].StringValue, Equals, "paul")
+	c.Assert(*results.Points[1].Values[0].StringValue, Equals, "todd")
+	c.Assert(*results.Points[2].Values[0].StringValue, Equals, "john")
+}

src/datastore/leveldb_datastore.go

@@ -153,8 +153,14 @@ func (self *LevelDbDatastore) executeQueryForSeries(database, series string, col
 		ro := levigo.NewReadOptions()
 		defer ro.Close()
 		iterators[i] = self.db.NewIterator(ro)
-		iterators[i].Seek(append(append(field.Id, endTimeBytes...), MAX_SEQUENCE...))
-		iterators[i].Prev()
+		if query.Ascending {
+			iterators[i].Seek(append(field.Id, startTimeBytes...))
+		} else {
+			iterators[i].Seek(append(append(field.Id, endTimeBytes...), MAX_SEQUENCE...))
+			if iterators[i].Valid() {
+				iterators[i].Prev()
+			}
+		}
 	}
 
 	result := &protocol.Series{Name: &series, Fields: fieldDefinitions, Points: make([]*protocol.Point, 0)}
@@ -199,7 +205,11 @@ func (self *LevelDbDatastore) executeQueryForSeries(database, series string, col
 		for i, iterator := range iterators {
 			if rawColumnValues[i] != nil && bytes.Equal(rawColumnValues[i].time, latestTimeRaw) && bytes.Equal(rawColumnValues[i].sequence, latestSequenceRaw) {
 				isValid = true
-				iterator.Prev()
+				if query.Ascending {
+					iterator.Next()
+				} else {
+					iterator.Prev()
+				}
 				fv := &protocol.FieldValue{}
 				err := proto.Unmarshal(rawColumnValues[i].value, fv)
 				if err != nil {

src/parser/parser_test.go

@@ -268,8 +268,8 @@ func (self *QueryParserSuite) TestParseSelectWithOrderByAndLimit(c *C) {
 	defer q.Close()
 	c.Assert(err, IsNil)
 	c.Assert(q.Limit, Equals, 20)
-	// ascending is the default
-	c.Assert(q.Ascending, Equals, true)
+	// descending is the default
+	c.Assert(q.Ascending, Equals, false)
 }
 
 func (self *QueryParserSuite) TestParseFromWithNestedFunctions2(c *C) {

src/parser/query.yacc

@@ -138,7 +138,7 @@ ORDER_CLAUSE:
         }
         |
         {
-          $$ = TRUE;
+          $$ = FALSE;
         }
 
 LIMIT_CLAUSE: