feat(firestore): implement limitToLast

firestore/integration_test.go

@@ -632,7 +632,7 @@ func TestIntegration_WriteBatch(t *testing.T) {
 	// TODO(jba): test verify when it is supported.
 }
 
-func TestIntegration_Query(t *testing.T) {
+func TestIntegration_QueryDocuments(t *testing.T) {
 	ctx := context.Background()
 	coll := integrationColl(t)
 	h := testHelper{t}
@@ -681,7 +681,91 @@ func TestIntegration_Query(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	seen := map[int64]bool{} // "q" values we see
+	seen := map[int64]bool{} // "q" values we see.
+	for _, d := range allDocs {
+		data := d.Data()
+		q, ok := data["q"]
+		if !ok {
+			// A document from another test.
+			continue
+		}
+		if seen[q.(int64)] {
+			t.Errorf("%v: duplicate doc", data)
+		}
+		seen[q.(int64)] = true
+		if data["x"] != int64(1) {
+			t.Errorf("%v: wrong or missing 'x'", data)
+		}
+		if len(data) != 2 {
+			t.Errorf("%v: want two keys", data)
+		}
+	}
+	if got, want := len(seen), len(wants); got != want {
+		t.Errorf("got %d docs with 'q', want %d", len(seen), len(wants))
+	}
+}
+
+func TestIntegration_QueryDocuments_LimitToLast_Fail(t *testing.T) {
+	ctx := context.Background()
+	coll := integrationColl(t)
+	q := coll.Select("q").OrderBy("q", Asc).LimitToLast(1)
+	gotDocs, err := q.Documents(ctx).GetAll()
+	if err == nil {
+		t.Errorf("got %v docs, want error", len(gotDocs))
+	}
+}
+
+func TestIntegration_QueryGet(t *testing.T) {
+	ctx := context.Background()
+	coll := integrationColl(t)
+	h := testHelper{t}
+	var wants []map[string]interface{}
+	for i := 0; i < 3; i++ {
+		doc := coll.NewDoc()
+		// To support running this test in parallel with the others, use a field name
+		// that we don't use anywhere else.
+		h.mustCreate(doc, map[string]interface{}{"q": i, "x": 1})
+		wants = append(wants, map[string]interface{}{"q": int64(i)})
+	}
+	q := coll.Select("q").OrderBy("q", Asc)
+	for i, test := range []struct {
+		q    Query
+		want []map[string]interface{}
+	}{
+		{q, wants},
+		{q.Where("q", ">", 1), wants[2:]},
+		{q.WherePath([]string{"q"}, ">", 1), wants[2:]},
+		{q.Offset(1).Limit(1), wants[1:2]},
+		{q.StartAt(1), wants[1:]},
+		{q.StartAfter(1), wants[2:]},
+		{q.EndAt(1), wants[:2]},
+		{q.EndBefore(1), wants[:1]},
+		{q.LimitToLast(2), wants[1:]},
+	} {
+		gotDocs, err := test.q.Get(ctx)
+		if err != nil {
+			t.Errorf("#%d: %+v: %v", i, test.q, err)
+			continue
+		}
+		if len(gotDocs) != len(test.want) {
+			t.Errorf("#%d: %+v: got %d docs, want %d", i, test.q, len(gotDocs), len(test.want))
+			continue
+		}
+		for j, g := range gotDocs {
+			if got, want := g.Data(), test.want[j]; !testEqual(got, want) {
+				t.Errorf("#%d: %+v, #%d: got\n%+v\nwant\n%+v", i, test.q, j, got, want)
+			}
+		}
+	}
+	_, err := coll.Select("q").Where("x", "==", 1).OrderBy("q", Asc).Get(ctx)
+	codeEq(t, "Where and OrderBy on different fields without an index", codes.FailedPrecondition, err)
+
+	// Using the collection itself as the query should return the full documents.
+	allDocs, err := coll.Get(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[int64]bool{} // "q" values we see.
 	for _, d := range allDocs {
 		data := d.Data()
 		q, ok := data["q"]

firestore/query.go

@@ -43,6 +43,7 @@ type Query struct {
 	orders                 []order
 	offset                 int32
 	limit                  *wrappers.Int32Value
+	limitToLast            bool
 	startVals, endVals     []interface{}
 	startDoc, endDoc       *DocumentSnapshot
 	startBefore, endBefore bool
@@ -162,10 +163,19 @@ func (q Query) Offset(n int) Query {
 	return q
 }
 
-// Limit returns a new Query that specifies the maximum number of results to return.
-// It must not be negative.
+// Limit returns a new Query that specifies the maximum number of first results
+// to return. It must not be negative.
 func (q Query) Limit(n int) Query {
 	q.limit = &wrappers.Int32Value{Value: trunc32(n)}
+	q.limitToLast = false
+	return q
+}
+
+// LimitToLast returns a new Query that specifies the maximum number of last
+// results to return. It must not be negative.
+func (q Query) LimitToLast(n int) Query {
+	q.limit = &wrappers.Int32Value{Value: trunc32(n)}
+	q.limitToLast = true
 	return q
 }
 
@@ -569,8 +579,48 @@ func trunc32(i int) int32 {
 	return int32(i)
 }
 
+// Get returns an array of query's resulting documents.
+func (q Query) Get(ctx context.Context) ([]*DocumentSnapshot, error) {
+	limitedToLast := q.limitToLast
+
+	if q.limitToLast {
+		// Flip order statements before posting a request.
+		for i := range q.orders {
+			if q.orders[i].dir == Asc {
+				q.orders[i].dir = Desc
+			} else {
+				q.orders[i].dir = Asc
+			}
+		}
+		// Swap cursors.
+		q.startVals, q.endVals = q.endVals, q.startVals
+		q.startDoc, q.endDoc = q.endDoc, q.startDoc
+		q.startBefore, q.endBefore = q.endBefore, q.startBefore
+
+		q.limitToLast = false
+	}
+	docs, err := q.Documents(ctx).GetAll()
+	if err != nil {
+		return nil, err
+	}
+	if limitedToLast {
+		// Flip docs order before return.
+		for i, j := 0, len(docs)-1; i < j; {
+			docs[i], docs[j] = docs[j], docs[i]
+			i++
+			j--
+		}
+	}
+	return docs, nil
+}
+
 // Documents returns an iterator over the query's resulting documents.
 func (q Query) Documents(ctx context.Context) *DocumentIterator {
+	if q.limitToLast {
+		return &DocumentIterator{
+			err: errors.New("firestore: queries that include limitToLast constraints cannot be streamed. Use Query.Get() instead"),
+		}
+	}
 	return &DocumentIterator{
 		iter: newQueryDocumentIterator(withResourceHeader(ctx, q.c.path()), &q, nil),
 	}