Go语言mgo持久化高精度小数：big.Rat的存储方案

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 创建一个大有理数 5/10
    rat1 := big.NewRat(5, 10)
    fmt.Printf("Initial Rat: %s (Float: %s)\n", rat1.String(), rat1.FloatString(10)) // Output: 1/2 (Float: 0.5000000000)

    // 创建一个小的有理数 1/100000
    rat2 := big.NewRat(1, 100000)
    fmt.Printf("Subtracting Rat: %s (Float: %s)\n", rat2.String(), rat2.FloatString(10)) // Output: 1/100000 (Float: 0.0000100000)

    // 进行减法运算
    rat1.Sub(rat1, rat2)
    fmt.Printf("After Subtraction: %s (Float: %s)\n", rat1.String(), rat1.FloatString(10)) // Output: 49999/100000 (Float: 0.4999900000)
}

// CurrencyValue 用于在MongoDB中存储高精度货币值
type CurrencyValue struct {
    Num   int64 `bson:"num"`   // 分子
    Denom int64 `bson:"denom"` // 分母
}

// RatToCurrencyValue 将 big.Rat 转换为 CurrencyValue
func RatToCurrencyValue(r *big.Rat) CurrencyValue {
    // 注意：big.Rat 的 Num() 和 Denom() 返回的是 *big.Int
    // 这里我们假设其值在 int64 范围内，并进行转换
    return CurrencyValue{
        Num:   r.Num().Int64(),
        Denom: r.Denom().Int64(),
    }
}

// CurrencyValueToRat 将 CurrencyValue 转换为 *big.Rat
func CurrencyValueToRat(cv CurrencyValue) *big.Rat {
    return big.NewRat(cv.Num, cv.Denom)
}

package main

import (
    "fmt"
    "log"
    "math/big"
    "time"

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

// CurrencyValue 用于在MongoDB中存储高精度货币值
type CurrencyValue struct {
    Num   int64 `bson:"num"`   // 分子
    Denom int64 `bson:"denom"` // 分母
}

// Product 代表一个包含精确价格的产品
type Product struct {
    ID    bson.ObjectId `bson:"_id,omitempty"`
    Name  string        `bson:"name"`
    Price CurrencyValue `bson:"price"`
    Qty   int           `bson:"qty"`
}

// RatToCurrencyValue 将 big.Rat 转换为 CurrencyValue
func RatToCurrencyValue(r *big.Rat) CurrencyValue {
    // 检查分母是否为零，避免潜在的运行时错误
    if r.Denom().Cmp(big.NewInt(0)) == 0 {
        log.Fatalf("Error: big.Rat has zero denominator. Cannot convert to CurrencyValue.")
    }
    return CurrencyValue{
        Num:   r.Num().Int64(),
        Denom: r.Denom().Int64(),
    }
}

// CurrencyValueToRat 将 CurrencyValue 转换为 *big.Rat
func CurrencyValueToRat(cv CurrencyValue) *big.Rat {
    // 检查分母是否为零，避免潜在的运行时错误
    if cv.Denom == 0 {
        log.Fatalf("Error: CurrencyValue has zero denominator. Cannot convert to big.Rat.")
    }
    return big.NewRat(cv.Num, cv.Denom)
}

func main() {
    // 1. 连接MongoDB
    session, err := mgo.Dial("mongodb://localhost:27017")
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer session.Close()

    // 可选：设置会话模式
    session.SetMode(mgo.Monotonic, true)

    db := session.DB("test_db")
    collection := db.C("products")

    // 清理旧数据 (仅为示例方便)
    if _, err := collection.RemoveAll(nil); err != nil {
        log.Printf("Failed to clear collection: %v", err)
    }

    // 2. 创建一个包含 big.Rat 价格的产品
    productPriceRat := big.NewRat(19999, 100) // 199.99
    product := Product{
        ID:    bson.NewObjectId(),
        Name:  "Example Product A",
        Price: RatToCurrencyValue(productPriceRat), // 转换为 CurrencyValue
        Qty:   10,
    }

    // 3. 插入产品到MongoDB
    err = collection.Insert(&product)
    if err != nil {
        log.Fatalf("Failed to insert product: %v", err)
    }
    fmt.Printf("Inserted product: %s with price %s (stored as %v)\n",
        product.Name, productPriceRat.FloatString(2), product.Price)

    // 4. 从MongoDB检索产品
    var retrievedProduct Product
    err = collection.Find(bson.M{"_id": product.ID}).One(&retrievedProduct)
    if err != nil {
        log.Fatalf("Failed to retrieve product: %v", err)
    }

    // 5. 将检索到的 CurrencyValue 价格重构回 big.Rat
    retrievedPriceRat := CurrencyValueToRat(retrievedProduct.Price)

    fmt.Printf("Retrieved product: %s with price %s (reconstructed from %v)\n",
        retrievedProduct.Name, retrievedPriceRat.FloatString(2), retrievedProduct.Price)

    // 6. 进行计算验证
    anotherProductPriceRat := big.NewRat(99, 100) // 0.99
    sumPrice := new(big.Rat).Add(retrievedPriceRat, anotherProductPriceRat)
    fmt.Printf("Calculated total price: %s\n", sumPrice.FloatString(2))

    // 7. 存储一个更新后的产品
    retrievedProduct.Qty = 5
    updatedPriceRat := big.NewRat(150, 3) // 50.00
    retrievedProduct.Price = RatToCurrencyValue(updatedPriceRat)

    err = collection.UpdateId(retrievedProduct.ID, retrievedProduct)
    if err != nil {
        log.Fatalf("Failed to update product: %v", err)
    }
    fmt.Printf("Updated product: %s with new price %s\n",
        retrievedProduct.Name, updatedPriceRat.FloatString(2))

    // 再次检索验证更新
    var updatedRetrievedProduct Product
    err = collection.Find(bson.M{"_id": retrievedProduct.ID}).One(&updatedRetrievedProduct)
    if err != nil {
        log.Fatalf("Failed to retrieve updated product: %v", err)
    }
    updatedRetrievedPriceRat := CurrencyValueToRat(updatedRetrievedProduct.Price)
    fmt.Printf("Verified updated product price: %s\n", updatedRetrievedPriceRat.FloatString(2))
}