接續上篇文章《ShardingSphere-Proxy分表場景測試案例》

go測試用例：

package mainimport ("fmt""math/rand""time""github.com/bwmarrin/snowflake""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)var globalDB *gorm.DBtype Order struct {ID        int64  `gorm:"primaryKey"`OrderId   string `gorm:"sharding:order_id"` // 指明 OrderId 是分片鍵UserID    int64  `gorm:"sharding:user_id"`ProductID int64OrderDate int64
}type Product struct {ID   int64  `gorm:"primaryKey"`Name string `gorm:"name"`
}// 定義結構體，用于接收查詢結果
type OrderGroup struct {ID         int64  `gorm:"primaryKey"`OrderId    string `gorm:"sharding:order_id"` // 指明 OrderId 是分片鍵UserID     int64  `gorm:"sharding:user_id"`ProductID  int64OrderDate  int64SumProduct int64MaxProduct int64
}type OrderProduct struct {OrderProduct
}type User struct {ID   int64  `gorm:"primaryKey"`Name string `gorm:"name"`
}type OrderUser struct {OrderUser
}func main() {InitDb()// 示例：插入訂單數據InsertRandomOrders()// 示例：插入product數據InsertRandomProducts()// 示例：插入user數據InsertRandomUsers()// 場景1：全表查詢，不含分表鍵FindAllOrders()// 場景2：根據訂單號查詢訂單，不含分表健FindOrderByOrderId("20240101ORDER9503")// 場景3：根據用戶ID查詢訂單，含分表健FindOrderByUserID(8648)// 場景4：等值查詢，根據訂單id和product_id查詢訂單。不包含分表健FindOrderByOrderIdAndProductID("20240101ORDER6546", 861)// 場景5：等值查詢，根據用戶id和product_id查詢訂單。包含分表健FindOrderByUserIDAndProductID(4581, 213)// 場景6：in查詢，根據用戶id查詢訂單。包含分表健FindOrderByUserIDIn([]int64{2608, 4581, 2142, 3519})// 場景7：in查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdIn([]string{"20240101ORDER6546", "20250101ORDER2295", "20250101ORDER4465", "20240101ORDER7826"})// 場景8：between查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdBetween("20240101ORDER6546", "20240101ORDER6548")// 場景9：beteeen查詢，根據user_id查詢訂單。包含分表健FindOrderByUserIDBetween(4581, 4583)// 場景10：or查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdOr("20240101ORDER6546", "20250101ORDER2295")// 場景11：or查詢，根據user_id查詢訂單。包含分表健FindOrderByUserIDOr(4581, 3519)// 場景12：>查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdGt("20240101ORDER6546")// 場景13：>查詢，根據user_id查詢訂單。包含分表健FindOrderByUserIDGt(4581)// 場景14：累加聚合查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdSum("20240101ORDER6546")// 場景15：累加聚合查詢，根據user_id查詢訂單。包含分表健FindOrderByUserIDSum(4581)// 場景16：count查詢，根據order_id查詢訂單。不包含分表健FindOrderByOrderIdCount("20240101ORDER6546")// 場景17：count查詢，根據user_id查詢訂單。包含分表健FindOrderByUserIDCount(4581)// 場景18：count查詢，全表查詢。不包含分表健FindAllOrdersCount()// 場景19：sum查詢，全表查詢。不包含分表健FindAllOrdersSum()// 場景20：比較聚合查詢，max查詢，全表查詢。不包含分表健FindAllOrdersMax()// 場景21：比較聚合查詢，min查詢，全表查詢。不包含分表健FindAllOrdersMin()// 場景22：平均聚合查詢，全表查詢。不包含分表健FindAllOrdersAvg()// 場景23：分組聚合查詢，根據order_id分組查詢。不包含分表健FindOrderByOrderIdGroupBy()// 場景24：分組聚合查詢，根據user_id分組查詢。包含分表健FindOrderByUserIDGroupBy()// 場景25：排序、分頁查詢，根據order_id排序，查詢第2頁數據。不包含分表健FindOrderByOrderIdOrderPage(1, 5)// 場景26：排序、分頁查詢，根據user_id排序，查詢第2頁數據。包含分表健FindOrderByUserIDOrderPage(1, 5)// 場景27：去重查詢，根據order_id去重，查詢訂單。不包含分表健FindOrderByOrderIdDistinct()// 場景28：去重查詢，根據user_id去重，查詢訂單。包含分表健FindOrderByUserIDDistinct()// 場景29：join查詢，order表和product表關聯查詢。join條件不包含分表健FindOrderJoinProduct()// 場景30：join查詢，order表和user表關聯查詢。join條件包含分表健FindOrderJoinUser()// 場景31：子查詢，order表和product表關聯查詢作為子查詢，查詢訂單。join條件不包含分表健FindOrderSubQueryProduct()// 場景32：子查詢，order表和user表關聯查詢作為子查詢，查詢訂單。join條件包含分表健FindOrderSubQueryUser()// 場景33：where in 子查詢表FindOrderInSubQuery()// 場景34：union查詢。包含分表健FindOrderUnion()// 場景35：union all查詢。包含分表健FindOrderUnionAll()// 場景36：union 查詢。不包含分表健FindOrderUnionByOrderId()// 場景37：union all查詢。不包含分表健FindOrderUnionAllByOrderId()// 場景38：根據主鍵更新UpdateOrderByID(1866023311733952512, 1)// 場景39：場景39：根據分表鍵更新UpdateOrderByUserID(9148, 1)// 場景40：根據主鍵刪除DeleteOrderByID(1866023311071252480)// 場景41：根據分表鍵刪除DeleteOrderByUserID(4389)
}// 生成product數據插入
func InsertRandomProducts() {// 查詢所有訂單var orders []Ordererr := globalDB.Table("orders").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return}// 生成product數據for _, order := range orders {product := Product{ID:   order.ProductID,Name: fmt.Sprintf("product_%04d", order.ProductID),}InsertProduct(product)}
}// 插入product數據
func InsertProduct(product Product) error {err := globalDB.Table("product").Create(&product).Errorif err != nil {fmt.Println("Error creating product:", err)}return nil
}// 生成user數據插入
func InsertRandomUsers() {// 查詢所有訂單var orders []Ordererr := globalDB.Table("orders").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return}// 生成user數據for _, order := range orders {user := User{ID:   order.UserID,Name: fmt.Sprintf("user_%04d", order.UserID),}InsertUser(user)}
}// 插入user數據
func InsertUser(user User) error {err := globalDB.Table("user").Create(&user).Errorif err != nil {fmt.Println("Error creating user:", err)}return nil
}// 隨機生成一些訂單數據插入
func InsertRandomOrders() {node, err := snowflake.NewNode(1)if err != nil {fmt.Println("Error creating snowflake node:", err)return}now := time.Now()for i := 0; i < 10; i++ {// 雪花id生成// 生成一個IDid := node.Generate()order := Order{ID:        id.Int64(),OrderId:   fmt.Sprintf("20240101ORDER%04d", rand.Int31n(10000)),UserID:    int64(rand.Int31n(10000)),ProductID: int64(rand.Int31n(1000)),OrderDate: now.Unix(),}InsertOrder(order)}// orderDate 用2025年，拼接當前月，日，時，分秒orderDate := time.Date(2025, now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), 0, time.UTC)for i := 0; i < 10; i++ {id := node.Generate()order := Order{ID:        id.Int64(),OrderId:   fmt.Sprintf("20250101ORDER%04d", rand.Int31n(10000)),UserID:    int64(rand.Int31n(10000)),ProductID: int64(rand.Int31n(1000)),OrderDate: orderDate.Unix(),}InsertOrder(order)}
}// 插入訂單數據
func InsertOrder(order Order) error {err := globalDB.Create(&order).Errorif err != nil {fmt.Println("Error creating order:", err)}return nil
}// 場景1：全表查詢，不含分表鍵
func FindAllOrders() ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景1：全表查詢，不含分表鍵 orders:", orders)return orders, err
}// 場景2：根據訂單號查詢訂單，不含分表健
func FindOrderByOrderId(orderId string) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id=?", orderId).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景2：根據訂單號查詢訂單，不含分表健 orders:", orders)return orders, err
}// 場景3：根據用戶ID查詢訂單，含分表健
func FindOrderByUserID(userID int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id=?", userID).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景3：根據用戶ID查詢訂單，含分表健 orders:", orders)return orders, err
}// 場景4：等值查詢，根據訂單id和product_id查詢訂單。不包含分表健
func FindOrderByOrderIdAndProductID(orderId string, productID int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id=? AND product_id=?", orderId, productID).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景4：等值查詢，根據訂單id和product_id查詢訂單 orders:", orders)return orders, err
}// 場景5：等值查詢，根據用戶id和product_id查詢訂單。包含分表健
func FindOrderByUserIDAndProductID(userID int64, productID int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id=? AND product_id=?", userID, productID).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景5：等值查詢，根據用戶id和product_id查詢訂單 orders:", orders)return orders, err
}// 場景6：in查詢，根據用戶id查詢訂單。包含分表健
func FindOrderByUserIDIn(userIDs []int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id IN ?", userIDs).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景6：in查詢，根據用戶id查詢訂單 orders:", orders)return orders, err
}// 場景7：in查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdIn(orderIDs []string) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id IN ?", orderIDs).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景7：in查詢，根據order_id查詢訂單 orders:", orders)return orders, err
}// 場景8：between查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdBetween(orderID1, orderID2 string) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id BETWEEN ? AND ?", orderID1, orderID2).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景8：between查詢，根據order_id查詢訂單 orders:", orders)return orders, err
}// 場景9：beteeen查詢，根據user_id查詢訂單。包含分表健
// 包含分表健的between查詢，似乎不支持。allow-range-query-with-inline-sharding設置為true，可以支持，這個場景待重新測試。
func FindOrderByUserIDBetween(userID1, userID2 int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id BETWEEN ? AND ?", userID1, userID2).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景9：beteeen查詢，根據user_id查詢訂單 orders:", orders)return orders, err
}// 場景10：or查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdOr(orderID1, orderID2 string) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id = ? OR order_id = ?", orderID1, orderID2).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景10：or查詢，根據order_id查詢訂單 orders:", orders)return orders, err
}// 場景11：or查詢，根據user_id查詢訂單。包含分表健
func FindOrderByUserIDOr(userID1, userID2 int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id = ? OR user_id = ?", userID1, userID2).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景11：or查詢，根據user_id查詢訂單 orders:", orders)return orders, err
}// 場景12：>查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdGt(orderID string) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("order_id > ?", orderID).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景12：>查詢，根據order_id查詢訂單 orders:", orders)return orders, err
}// 場景13：>查詢，根據user_id查詢訂單。包含分表健
// 包含分表鍵的>查詢，似乎不支持。allow-range-query-with-inline-sharding設置為true，可以支持，這個場景待重新測試。
func FindOrderByUserIDGt(userID int64) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Where("user_id > ?", userID).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景13：>查詢，根據user_id查詢訂單 orders:", orders)return orders, err
}// 場景14：累加聚合查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdSum(orderID string) (int64, error) {var sum int64err := globalDB.Table("orders").Where("order_id=?", orderID).Select("SUM(product_id)").Scan(&sum).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景14：累加聚合查詢，根據order_id查詢訂單 orders:", sum)return sum, err
}// 場景15：累加聚合查詢，根據user_id查詢訂單。包含分表健
func FindOrderByUserIDSum(userID int64) (int64, error) {var sum int64err := globalDB.Table("orders").Where("user_id=?", userID).Select("SUM(product_id)").Scan(&sum).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景15：累加聚合查詢，根據user_id查詢訂單 orders:", sum)return sum, err
}// 場景16：count查詢，根據order_id查詢訂單。不包含分表健
func FindOrderByOrderIdCount(orderID string) (int64, error) {var count int64err := globalDB.Table("orders").Where("order_id=?", orderID).Count(&count).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景16：count查詢，根據order_id查詢訂單 orders:", count)return count, err
}// 場景17：count查詢，根據user_id查詢訂單。包含分表健
func FindOrderByUserIDCount(userID int64) (int64, error) {var count int64err := globalDB.Table("orders").Where("user_id=?", userID).Count(&count).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景17：count查詢，根據user_id查詢訂單 orders:", count)return count, err
}// 場景18：count查詢，全表查詢。不包含分表健
func FindAllOrdersCount() (int64, error) {var count int64err := globalDB.Table("orders").Count(&count).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景18：count查詢，全表查詢 orders:", count)return count, err
}// 場景19：sum查詢，全表查詢。不包含分表健
func FindAllOrdersSum() (int64, error) {var sum int64err := globalDB.Table("orders").Select("SUM(product_id)").Scan(&sum).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景19：sum查詢，全表查詢 orders:", sum)return sum, err
}// 場景20：比較聚合查詢，max查詢，全表查詢。不包含分表健
func FindAllOrdersMax() (int64, error) {var max int64err := globalDB.Table("orders").Select("MAX(user_id)").Scan(&max).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景20：max查詢，全表查詢 orders:", max)return max, err
}// 場景21：比較聚合查詢，min查詢，全表查詢。不包含分表健
func FindAllOrdersMin() (int64, error) {var min int64err := globalDB.Table("orders").Select("MIN(user_id)").Scan(&min).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景21：min查詢，全表查詢 orders:", min)return min, err
}// 場景22：平均聚合查詢，全表查詢。不包含分表健
func FindAllOrdersAvg() (float64, error) {var avg float64err := globalDB.Table("orders").Select("AVG(user_id)").Scan(&avg).Errorif err != nil {fmt.Println("Error finding orders:", err)return 0, err}fmt.Println("場景22：avg查詢，全表查詢 orders:", avg)return avg, err
}// 場景23：分組聚合查詢，根據order_id分組查詢。不包含分表健
func FindOrderByOrderIdGroupBy() error {var orders []OrderGrouperr := globalDB.Table("orders").Group("order_id").Select("*,SUM(product_id) AS sum_product,MAX(product_id) as max_product").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return err}fmt.Printf("場景23：分組聚合查詢，根據order_id分組查詢 orders:%+v\n", orders)return err
}// 場景24：分組聚合查詢，根據user_id分組查詢。包含分表健
func FindOrderByUserIDGroupBy() error {var orders []OrderGrouperr := globalDB.Table("orders").Group("user_id").Select("*,SUM(product_id) AS sum_product,MAX(product_id) as max_product").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return err}fmt.Printf("場景24：分組聚合查詢，根據user_id分組查詢 orders:%+v\n", orders)return err
}// 場景25：排序、分頁查詢，根據order_id排序，查詢第2頁數據。不包含分表健
func FindOrderByOrderIdOrderPage(page, pageSize int) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Order("order_id desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景25：排序、分頁查詢，根據order_id排序，查詢第2頁數據 orders:", orders)return orders, err
}// 場景26：排序、分頁查詢，根據user_id排序，查詢第2頁數據。包含分表健
func FindOrderByUserIDOrderPage(page, pageSize int) ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Order("user_id desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景26：排序、分頁查詢，根據user_id排序，查詢第2頁數據 orders:", orders)return orders, err
}// 場景27：去重查詢，根據order_id去重，查詢訂單。不包含分表健
func FindOrderByOrderIdDistinct() ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Distinct("order_id").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景27：去重查詢，根據order_id去重，查詢訂單 orders:", orders)return orders, err
}// 場景28：去重查詢，根據user_id去重，查詢訂單。包含分表健
func FindOrderByUserIDDistinct() ([]Order, error) {var orders []Ordererr := globalDB.Table("orders").Distinct("user_id").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景28：去重查詢，根據user_id去重，查詢訂單 orders:", orders)return orders, err
}// 場景29：join查詢，order表和product表關聯查詢。join條件不包含分表健
func FindOrderJoinProduct() ([]OrderProduct, error) {var orders []OrderProducterr := globalDB.Table("orders").Joins("JOIN product ON orders.product_id = product.id").Select("orders.*,product.*").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景29：join查詢，order表和product表關聯查詢 orders:", orders)return orders, err
}// 場景30：join查詢，order表和user表關聯查詢。join條件包含分表健
func FindOrderJoinUser() ([]OrderUser, error) {var orders []OrderUsererr := globalDB.Table("orders").Joins("JOIN user ON orders.user_id = user.id").Select("orders.*,user.*").Find(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景30：join查詢，order表和user表關聯查詢 orders:", orders)return orders, err
}// 場景31：子查詢，order表和product表關聯查詢作為子查詢，查詢訂單。join條件不包含分表健
func FindOrderSubQueryProduct() ([]OrderProduct, error) {var orders []OrderProductsql := `SELECT subquery.* FROM (SELECT orders.* FROM orders JOIN product ON orders.product_id = product.id) AS subquery`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景31：子查詢，order表和product表關聯查詢作為子查詢，查詢訂單 orders:", orders)return orders, err
}// 場景32：子查詢，order表和user表關聯查詢作為子查詢，查詢訂單。join條件包含分表健
func FindOrderSubQueryUser() ([]OrderUser, error) {var orders []OrderUsersql := `SELECT subquery.* FROM (SELECT orders.* FROM orders JOIN user ON orders.user_id = user.id) AS subquery`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景32：子查詢，order表和user表關聯查詢作為子查詢，查詢訂單 orders:", orders)return orders, err
}// 場景33：where in 子查詢表
func FindOrderInSubQuery() ([]Order, error) {var orders []Ordersql := `SELECT * FROM orders WHERE user_id IN (SELECT id FROM user)`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景33：where in 子查詢表 orders:", orders)return orders, err
}// 場景34：union查詢。包含分表健
func FindOrderUnion() ([]Order, error) {var orders []Ordersql := `SELECT * FROM orders WHERE user_id = 8648 UNION SELECT * FROM orders WHERE user_id = 3401`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景34：union查詢 orders:", orders)return orders, err
}// 場景35：union all查詢。包含分表健
func FindOrderUnionAll() ([]Order, error) {var orders []Ordersql := `SELECT * FROM orders WHERE user_id = 8648 UNION ALL SELECT * FROM orders WHERE user_id = 3401`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景35：union all查詢 orders:", orders)return orders, err
}// 場景36：union 查詢。不包含分表健
func FindOrderUnionByOrderId() ([]Order, error) {var orders []Ordersql := `SELECT * FROM orders WHERE order_id = '20240101ORDER6546' UNION SELECT * FROM orders WHERE order_id = '20240101ORDER9728'`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景36：union查詢 orders:", orders)return orders, err
}// 場景37：union all查詢。不包含分表健
func FindOrderUnionAllByOrderId() ([]Order, error) {var orders []Ordersql := `SELECT * FROM orders WHERE order_id = '20240101ORDER6546' UNION ALL SELECT * FROM orders WHERE order_id = '20240101ORDER9728'`err := globalDB.Raw(sql).Scan(&orders).Errorif err != nil {fmt.Println("Error finding orders:", err)return nil, err}fmt.Println("場景37：union all查詢 orders:", orders)return orders, err
}// 場景38：根據主鍵更新
func UpdateOrderByID(ID int64, productID int) error {err := globalDB.Table("orders").Where("id = ?", ID).Update("product_id", productID).Errorif err != nil {fmt.Println("Error updating orders:", err)}return err
}// 場景39：根據分表鍵更新
func UpdateOrderByUserID(userID int64, productID int) error {err := globalDB.Table("orders").Where("user_id = ?", userID).Update("product_id", productID).Errorif err != nil {fmt.Println("Error updating orders:", err)}return err
}// 場景40：根據主鍵刪除
func DeleteOrderByID(ID int64) error {err := globalDB.Table("orders").Where("id = ?", ID).Delete(&Order{}).Errorif err != nil {fmt.Println("Error deleting orders:", err)}return err
}// 場景41：根據分表鍵刪除
func DeleteOrderByUserID(userID int64) error {err := globalDB.Table("orders").Where("user_id = ?", userID).Delete(&Order{}).Errorif err != nil {fmt.Println("Error deleting orders:", err)}return err
}// InitDb 初始化數據庫連接
func InitDb() *gorm.DB {log := logger.Default.LogMode(logger.Info)// 連接到 MySQL 數據庫dsn := "sharding:sharding@tcp(localhost:13308)/sharding"db, err := gorm.Open(mysql.New(mysql.Config{DSN: dsn,}), &gorm.Config{Logger: log,})if err != nil {panic("failed to connect database")}globalDB = dbreturn db
}