Go语言mgo库MongoDB范围查询指南：解决$gte/$lte语法错误

// 错误的示例：直接在复合字面量中使用 $
// searchResults, searchErr = SearchReading(bson.M{"k": key, "t": { $gte: start, $lte: end } }, limit)

// 正确的示例：使用嵌套的 bson.M 封装操作符
searchResults, searchErr = SearchReading(bson.M{"k": key, "t": bson.M{"$gte": start, "$lte": end}}, limit)

package main

import (
    "fmt"
    "log"
    "time"

    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

// Reading 结构体定义，对应MongoDB中的文档
type Reading struct {
    K string  `bson:"k"` // 键
    T int64   `bson:"t"` // 时间戳
    V float64 `bson:"v"` // 值
}

// 假设的数据库连接和集合操作函数
// 实际应用中，withCollection 会管理mgo会话的获取和关闭
func withCollection(collectionName string, s func(*mgo.Collection) error) error {
    // 实际应用中，这里会建立与MongoDB的连接，并获取一个会话
    // 为了示例简洁，我们模拟一个会话和集合
    // 请替换为您的实际mgo连接逻辑
    session, err := mgo.Dial("mongodb://localhost:27017") // 替换为您的MongoDB连接字符串
    if err != nil {
        return fmt.Errorf("failed to connect to MongoDB: %v", err)
    }
    defer session.Close() // 确保会话关闭

    session.SetMode(mgo.Monotonic, true)
    c := session.DB("testdb").C(collectionName) // 替换为您的数据库名和集合名
    return s(c)
}

// SearchReading 是一个通用的查询函数，接受一个查询条件q和限制limit
func SearchReading(q interface{}, limit int) (searchResults []Reading, searchErr string) {
    searchErr = ""
    searchResults = []Reading{}
    queryFunc := func(c *mgo.Collection) error {
        var err error
        if limit < 0 { // limit < 0 表示不限制
            err = c.Find(q).All(&searchResults)
        } else {
            err = c.Find(q).Limit(limit).All(&searchResults)
        }
        return err
    }

    err := withCollection("reading", queryFunc)
    if err != nil {
        searchErr = fmt.Sprintf("Database Error: %v", err)
    }
    return
}

// GetReadingsForKey 根据键、起始时间、结束时间进行范围查询
func GetReadingsForKey(key string, start int64, end int64, limit int) (searchResults []Reading, searchErr string) {
    // 正确的范围查询条件构建方式
    queryCondition := bson.M{
        "k": key,
        "t": bson.M{
            "$gte": start, // 大于等于起始时间
            "$lte": end,   // 小于等于结束时间
        },
    }
    searchResults, searchErr = SearchReading(queryCondition, limit)
    return
}

func main() {
    // 假设我们有一些数据需要插入
    // 实际应用中，这部分数据可能已经存在
    err := withCollection("reading", func(c *mgo.Collection) error {
        // 清空集合以便重复运行示例
        _ = c.DropCollection()

        // 插入一些示例数据
        data := []Reading{
            {K: "sensor1", T: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC).Unix(), V: 10.5},
            {K: "sensor1", T: time.Date(2023, 1, 1, 10, 15, 0, 0, time.UTC).Unix(), V: 11.2},
            {K: "sensor2", T: time.Date(2023, 1, 1, 10, 30, 0, 0, time.UTC).Unix(), V: 20.1},
            {K: "sensor1", T: time.Date(2023, 1, 1, 10, 45, 0, 0, time.UTC).Unix(), V: 12.8},
            {K: "sensor2", T: time.Date(2023, 1, 1, 11, 0, 0, 0, time.UTC).Unix(), V: 22.5},
        }
        for _, r := range data {
            if err := c.Insert(r); err != nil {
                return fmt.Errorf("failed to insert data: %v", err)
            }
        }
        fmt.Println("示例数据插入成功。")
        return nil
    })

    if err != nil {
        log.Fatalf("初始化数据失败: %v", err)
    }

    // 定义查询范围
    startTime := time.Date(2023, 1, 1, 10, 10, 0, 0, time.UTC).Unix() // 2023-01-01 10:10:00 UTC
    endTime := time.Date(2023, 1, 1, 10, 50, 0, 0, time.UTC).Unix()   // 2023-01-01 10:50:00 UTC

    fmt.Printf("\n查询 'sensor1' 在 %s 和 %s 之间的数据:\n",
        time.Unix(startTime, 0).Format(time.RFC3339),
        time.Unix(endTime, 0).Format(time.RFC3339))

    // 执行范围查询
    results, queryErr := GetReadingsForKey("sensor1", startTime, endTime, -1) // -1表示不限制返回数量

    if queryErr != "" {
        log.Fatalf("查询失败: %s", queryErr)
    }

    if len(results) == 0 {
        fmt.Println("未找到匹配的数据。")
    } else {
        for _, r := range results {
            fmt.Printf("  K: %s, T: %s, V: %.2f\n", r.K, time.Unix(r.T, 0).Format(time.RFC3339), r.V)
        }
    }

    fmt.Printf("\n查询 'sensor2' 在 %s 和 %s 之间的数据:\n",
        time.Unix(startTime, 0).Format(time.RFC3339),
        time.Unix(endTime, 0).Format(time.RFC3339))

    results2, queryErr2 := GetReadingsForKey("sensor2", startTime, endTime, -1)
    if queryErr2 != "" {
        log.Fatalf("查询失败: %s", queryErr2)
    }
    if len(results2) == 0 {
        fmt.Println("未找到匹配的数据。")
    } else {
        for _, r := range results2 {
            fmt.Printf("  K: %s, T: %s, V: %.2f\n", r.K, time.Unix(r.T, 0).Format(time.RFC3339), r.V)
        }
    }
}