我搜索并没有找到解决该问题的Go解决方案，无论是否使用 mgo.v2 ，都不在StackOverflow上，也不在任何其他站点上。此问答符合knowledge sharing / documenting的精神。

假设我们在Gogo users中建模了MongoDB中的struct集合:

type User struct {
    ID      bson.ObjectId `bson:"_id"`
    Name    string        `bson:"name"`
    Country string        `bson:"country"`
}

session, err := mgo.Dial(url) // Acquire Mongo session, handle error!

c := session.DB("").C("users")
q := c.Find(bson.M{"country" : "USA"}).Sort("name", "_id").Limit(10)

// To get the nth page:
q = q.Skip((n-1)*10)

var users []*User
err = q.All(&users)

db.users.createIndex(
    {
        country: 1,
        name: 1,
        _id: 1
    }
)

最佳答案

不幸的是 mgo.v2 驱动程序不提供API调用来指定 cursor.min() 。

但是有一个解决方案。 mgo.Database 类型提供 Database.Run() 方法来运行任何MongoDB命令。可在此处找到可用的命令及其文档:Database commands

从MongoDB 3.2开始，提供了一个新的 find 命令，该命令可用于执行查询，并且它支持指定min参数，该参数表示从其开始列出结果的第一个索引条目。

好的。我们需要做的是在每个批次(页面的文档)从查询结果的最后一个文档生成min文档之后，该文档必须包含用于执行查询的索引条目的值，然后是下一个批次(下一页的文档)可以通过在执行查询之前设置此min索引条目来获取。

索引条目(从现在开始将其称为光标)可以被编码为string并与结果一起发送给客户端，当客户端想要下一页时，他发送回光标，说他想要从该光标之后开始的结果。

手动执行(“硬”方式)

要执行的命令可以采用不同的形式，但是命令名称(find)必须在编码(marshal)结果中位于第一个位置，因此我们将使用 bson.D (与 bson.M 相比，保留顺序):

limit := 10
cmd := bson.D{
    {Name: "find", Value: "users"},
    {Name: "filter", Value: bson.M{"country": "USA"}},
    {Name: "sort", Value: []bson.D{
        {Name: "name", Value: 1},
        {Name: "_id", Value: 1},
    },
    {Name: "limit", Value: limit},
    {Name: "batchSize", Value: limit},
    {Name: "singleBatch", Value: true},
}
if min != nil {
    // min is inclusive, must skip first (which is the previous last)
    cmd = append(cmd,
        bson.DocElem{Name: "skip", Value: 1},
        bson.DocElem{Name: "min", Value: min},
    )
}

var res struct {
    OK       int `bson:"ok"`
    WaitedMS int `bson:"waitedMS"`
    Cursor   struct {
        ID         interface{} `bson:"id"`
        NS         string      `bson:"ns"`
        FirstBatch []bson.Raw  `bson:"firstBatch"`
    } `bson:"cursor"`
}

db := session.DB("")
if err := db.Run(cmd, &res); err != nil {
    // Handle error (abort)
}

firstBatch := res.Cursor.FirstBatch
var users []*User
err = db.C("users").NewIter(nil, firstBatch, 0, nil).All(&users)

if len(users) > 0 {
    lastUser := users[len(users)-1]
    cursorData := []bson.D{
        {Name: "country", Value: lastUser.Country},
        {Name: "name", Value: lastUser.Name},
        {Name: "_id", Value: lastUser.ID},
    }
} else {
    // No more users found, use the last cursor
}

// CreateCursor returns a web-safe cursor string from the specified fields.
// The returned cursor string is safe to include in URL queries without escaping.
func CreateCursor(cursorData bson.D) (string, error) {
    // bson.Marshal() never returns error, so I skip a check and early return
    // (but I do return the error if it would ever happen)
    data, err := bson.Marshal(cursorData)
    return base64.RawURLEncoding.EncodeToString(data), err
}

// ParseCursor parses the cursor string and returns the cursor data.
func ParseCursor(c string) (cursorData bson.D, err error) {
    var data []byte
    if data, err = base64.RawURLEncoding.DecodeString(c); err != nil {
        return
    }

    err = bson.Unmarshal(data, &cursorData)
    return
}

q := minquery.New(session.DB(""), "users", bson.M{"country" : "USA"}).
    Sort("name", "_id").Limit(10)
// If this is not the first page, set cursor:
// getLastCursor() represents your logic how you acquire the last cursor.
if cursor := getLastCursor(); cursor != "" {
    q = q.Cursor(cursor)
}

var users []*User
newCursor, err := q.All(&users, "country", "name", "_id")

关于mongodb - 使用mgo在MongoDB中进行有效的分页，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40634865/