From 3152823484c9622dbcdc7b57510337620e08f380 Mon Sep 17 00:00:00 2001
From: chenlinzhneg <chenlinzheng@qianxin.com>
Date: Sun, 27 Oct 2019 10:25:34 +0800
Subject: [PATCH 1/2] fix(index): index parser

---
 minquery.go | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/minquery.go b/minquery.go
index 651932f..0f90262 100644
--- a/minquery.go
+++ b/minquery.go
@@ -4,6 +4,7 @@ package minquery
 
 import (
 	"errors"
+	"strings"
 
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
@@ -203,7 +204,24 @@ func (mq *minQuery) All(result interface{}, cursorFields ...string) (cursor stri
 			}
 			cursorData := make(bson.D, len(cursorFields))
 			for i, cf := range cursorFields {
-				cursorData[i] = bson.DocElem{Name: cf, Value: doc[cf]}
+				cfs := strings.Split(cf, ".")
+				if len(cfs) <= 1 {
+					cursorData[i] = bson.DocElem{Name: cf, Value: doc[cf]}
+					continue
+				}
+				leafM := doc
+				var ok bool
+				for j:=0; j<len(cfs); j++ {
+					if j == len(cfs) - 1 {
+						cursorData[i] = bson.DocElem{Name: cf, Value: leafM[cfs[j]]}
+						break
+					}
+					leafM, ok = leafM[cfs[j]].(bson.M)
+					if !ok || len(leafM) <= 0 {
+						cursorData[i] = bson.DocElem{Name: cf, Value: nil}
+						break
+					}
+				}
 			}
 			cursor, err = mq.cursorCodec.CreateCursor(cursorData)
 			if err != nil {

From 9a32aaf57efca0adb837fdbe5ee0302a855fa9ac Mon Sep 17 00:00:00 2001
From: chenlinzhneg <chenlinzheng@qianxin.com>
Date: Wed, 6 Nov 2019 21:56:24 +0800
Subject: [PATCH 2/2] fix(index): array index

---
 .gitignore       |   1 +
 minquery.go      |  50 +++++++++------
 minquery_test.go | 158 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 190 insertions(+), 19 deletions(-)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..723ef36
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.idea
\ No newline at end of file
diff --git a/minquery.go b/minquery.go
index 0f90262..9af955b 100644
--- a/minquery.go
+++ b/minquery.go
@@ -4,6 +4,7 @@ package minquery
 
 import (
 	"errors"
+	"strconv"
 	"strings"
 
 	"github.com/globalsign/mgo"
@@ -203,25 +204,9 @@ func (mq *minQuery) All(result interface{}, cursorFields ...string) (cursor stri
 				return
 			}
 			cursorData := make(bson.D, len(cursorFields))
-			for i, cf := range cursorFields {
-				cfs := strings.Split(cf, ".")
-				if len(cfs) <= 1 {
-					cursorData[i] = bson.DocElem{Name: cf, Value: doc[cf]}
-					continue
-				}
-				leafM := doc
-				var ok bool
-				for j:=0; j<len(cfs); j++ {
-					if j == len(cfs) - 1 {
-						cursorData[i] = bson.DocElem{Name: cf, Value: leafM[cfs[j]]}
-						break
-					}
-					leafM, ok = leafM[cfs[j]].(bson.M)
-					if !ok || len(leafM) <= 0 {
-						cursorData[i] = bson.DocElem{Name: cf, Value: nil}
-						break
-					}
-				}
+			err = mq.getCursorData(cursorFields, cursorData, doc)
+			if err != nil {
+				return
 			}
 			cursor, err = mq.cursorCodec.CreateCursor(cursorData)
 			if err != nil {
@@ -239,3 +224,30 @@ func (mq *minQuery) All(result interface{}, cursorFields ...string) (cursor stri
 	err = mq.db.C(mq.coll).NewIter(nil, firstBatch, 0, nil).All(result)
 	return
 }
+
+func (mq *minQuery) getCursorData(cursorFields []string, cursorData bson.D, doc bson.M) error {
+	for i, cf := range cursorFields {
+		cfs := strings.Split(cf, ".")
+		if len(cfs) <= 1 {
+			cursorData[i] = bson.DocElem{Name: cf, Value: doc[cf]}
+			continue
+		}
+		leafM := doc[cfs[0]]
+		for j:=1; j<len(cfs); j++ {
+			switch expr := leafM.(type) {
+			case bson.M:
+				leafM = expr[cfs[j]]
+			case []interface{}:
+				index, err :=strconv.Atoi(cfs[j])
+				if err != nil {
+					return err
+				}
+				leafM = expr[index]
+			default:
+				leafM = expr
+			}
+		}
+		cursorData[i] = bson.DocElem{Name: cf, Value: leafM}
+	}
+	return nil
+}
\ No newline at end of file
diff --git a/minquery_test.go b/minquery_test.go
index cb1e503..6b1c26a 100644
--- a/minquery_test.go
+++ b/minquery_test.go
@@ -38,6 +38,33 @@ func init() {
 	if _, err := c.RemoveAll(nil); err != nil {
 		panic(err)
 	}
+
+	mgoCompany := sess.DB("").C("company")
+	if err := mgoCompany.EnsureIndex(mgo.Index{Key: []string{"name", "boos"}}); err != nil {
+		panic(err)
+	}
+	if err := mgoCompany.EnsureIndex(mgo.Index{Key: []string{"name", "boos.name"}}); err != nil {
+		panic(err)
+	}
+	if err := mgoCompany.EnsureIndex(mgo.Index{Key: []string{"subsidiary"}}); err != nil {
+		panic(err)
+	}
+	if err := mgoCompany.EnsureIndex(mgo.Index{Key: []string{"subsidiary.0"}}); err != nil {
+		panic(err)
+	}
+	if _, err := mgoCompany.RemoveAll(nil); err != nil {
+		panic(err)
+	}
+}
+
+func clearDB() {
+	c := sess.DB("")
+	if _, err := c.C("users").RemoveAll(nil); err != nil {
+		panic(err)
+	}
+	if _, err := c.C("company").RemoveAll(nil); err != nil {
+		panic(err)
+	}
 }
 
 type User struct {
@@ -46,7 +73,15 @@ type User struct {
 	Country string        `bson:"country"`
 }
 
+type Company struct {
+	ID      	bson.ObjectId	`bson:"_id"`
+	Name		string			`bson:"name"`
+	Boos		User			`bson:"boos"`
+	Subsidiary	[]string		`bson:"subsidiary"`
+}
+
 func TestMinQuery(t *testing.T) {
+	clearDB()
 	eq, neq, deq := mighty.Eq(t), mighty.Neq(t), mighty.Deq(t)
 	_, _ = eq, neq
 
@@ -132,6 +167,129 @@ func TestMinQuery(t *testing.T) {
 	mq.(*minQuery).testError = false
 }
 
+func TestMinQueryMultiIndex(t *testing.T) {
+	clearDB()
+	eq, neq, deq := mighty.Eq(t), mighty.Neq(t), mighty.Deq(t)
+	_, _ = eq, neq
+
+	c := sess.DB("").C("company")
+
+	// Insert test documents:
+	companies := []*Company{
+		{Name: "amazon", Boos: User{ID: bson.NewObjectId(), Name: "Dakota", Country: "US"}, Subsidiary: []string{}},
+		{Name: "apple", Boos: User{ID: bson.NewObjectId(), Name: "Fae", Country: "US"}, Subsidiary: []string{}},
+		{Name: "facebook", Boos: User{ID: bson.NewObjectId(), Name: "Chloe", Country: "UK"}, Subsidiary: []string{}},
+		{Name: "google", Boos: User{ID: bson.NewObjectId(), Name: "Aaron", Country: "UK"}, Subsidiary: []string{}},
+		{Name: "honer", Boos: User{ID: bson.NewObjectId(), Name: "Ed", Country: "US"}, Subsidiary: []string{}},
+		{Name: "videos", Boos: User{ID: bson.NewObjectId(), Name: "Glan", Country: "US"}, Subsidiary: []string{}},
+		{Name: "zMind", Boos: User{ID: bson.NewObjectId(), Name: "len", Country: "US"}, Subsidiary: []string{}},
+	}
+
+	cursorFields := []string{"name", "boos"}
+
+	for _, u := range companies {
+		u.ID = bson.NewObjectId()
+		eq(nil, c.Insert(u))
+	}
+
+	mq := New(sess.DB(""), "company", bson.M{}).
+		Sort("name", "boos").Limit(3)
+	var result []*Company
+
+	cursor, err := mq.All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[0:3], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[3:6], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[6:], result)
+}
+
+func TestMinQuerySubDocIndex(t *testing.T) {
+	clearDB()
+	eq, neq, deq := mighty.Eq(t), mighty.Neq(t), mighty.Deq(t)
+	_, _ = eq, neq
+
+	c := sess.DB("").C("company")
+
+	// Insert test documents:
+	companies := []*Company{
+		{Name: "amazon", Boos: User{ID: bson.NewObjectId(), Name: "Dakota", Country: "US"}, Subsidiary: []string{}},
+		{Name: "apple", Boos: User{ID: bson.NewObjectId(), Name: "Fae", Country: "US"}, Subsidiary: []string{}},
+		{Name: "facebook", Boos: User{ID: bson.NewObjectId(), Name: "Chloe", Country: "UK"}, Subsidiary: []string{}},
+		{Name: "google", Boos: User{ID: bson.NewObjectId(), Name: "Aaron", Country: "UK"}, Subsidiary: []string{}},
+		{Name: "honer", Boos: User{ID: bson.NewObjectId(), Name: "Ed", Country: "US"}, Subsidiary: []string{}},
+		{Name: "videos", Boos: User{ID: bson.NewObjectId(), Name: "Glan", Country: "US"}, Subsidiary: []string{}},
+		{Name: "zMind", Boos: User{ID: bson.NewObjectId(), Name: "len", Country: "US"}, Subsidiary: []string{}},
+	}
+
+	cursorFields := []string{"name", "boos.name"}
+
+	for _, u := range companies {
+		u.ID = bson.NewObjectId()
+		eq(nil, c.Insert(u))
+	}
+
+	mq := New(sess.DB(""), "company", bson.M{}).
+		Sort("name", "boos.name").Limit(3)
+	var result []*Company
+
+	cursor, err := mq.All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[0:3], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[3:6], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[6:], result)
+}
+
+func TestMinQueryArrayMemberIndex(t *testing.T) {
+	clearDB()
+	eq, neq, deq := mighty.Eq(t), mighty.Neq(t), mighty.Deq(t)
+	_, _ = eq, neq
+
+	c := sess.DB("").C("company")
+
+	companies := []*Company{
+		{Name: "amazon", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"ama", "zon"}},
+		{Name: "apple", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"app", "le"}},
+		{Name: "facebook", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"face", "book"}},
+		{Name: "google", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"goo", "gle"}},
+		{Name: "honer", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"hon", "er"}},
+		{Name: "videos", Boos: User{ID: bson.NewObjectId()}, Subsidiary: []string{"video", "s"}},
+	}
+
+	cursorFields := []string{"subsidiary.0"}
+
+	for _, u := range companies {
+		u.ID = bson.NewObjectId()
+		eq(nil, c.Insert(u))
+	}
+	mq := New(sess.DB(""), "company", bson.M{}).
+		Sort("subsidiary.0").Limit(3)
+	var result []*Company
+
+	cursor, err := mq.All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[0:3], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[3:6], result)
+
+	cursor, err = mq.Cursor(cursor).All(&result, cursorFields...)
+	eq(nil, err)
+	deq(companies[6:], result)
+}
+
 type testCodec struct {
 	testError bool
 }