ShardingSphere-Proxy分表场景：go测试案例

接续上篇文章《ShardingSphere-Proxy分表场景测试案例》

go测试用例：

package main

import (
	"fmt"
	"math/rand"
	"time"

	"github.com/bwmarrin/snowflake"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

var globalDB *gorm.DB

type Order struct {
	ID        int64  `gorm:"primaryKey"`
	OrderId   string `gorm:"sharding:order_id"` // 指明 OrderId 是分片键
	UserID    int64  `gorm:"sharding:user_id"`
	ProductID int64
	OrderDate 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  int64
	OrderDate  int64
	SumProduct int64
	MaxProduct int64
}

type OrderProduct struct {
	Order
	Product
}

type User struct {
	ID   int64  `gorm:"primaryKey"`
	Name string `gorm:"name"`
}

type OrderUser struct {
	Order
	User
}

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 []Order
	err := globalDB.Table("orders").Find(&orders).Error
	if 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).Error
	if err != nil {
		fmt.Println("Error creating product:", err)
	}
	return nil
}

// 生成user数据插入
func InsertRandomUsers() {
	// 查询所有订单
	var orders []Order
	err := globalDB.Table("orders").Find(&orders).Error
	if 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).Error
	if 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生成
		// 生成一个ID
		id := 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).Error
	if err != nil {
		fmt.Println("Error creating order:", err)
	}
	return nil
}

// 场景1：全表查询，不含分表键
func FindAllOrders() ([]Order, error) {
	var orders []Order
	err := globalDB.Table("orders").Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id=?", orderId).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id=?", userID).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id=? AND product_id=?", orderId, productID).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id=? AND product_id=?", userID, productID).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id IN ?", userIDs).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id IN ?", orderIDs).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id BETWEEN ? AND ?", orderID1, orderID2).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id BETWEEN ? AND ?", userID1, userID2).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id = ? OR order_id = ?", orderID1, orderID2).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id = ? OR user_id = ?", userID1, userID2).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("order_id > ?", orderID).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Where("user_id > ?", userID).Find(&orders).Error
	if 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 int64
	err := globalDB.Table("orders").Where("order_id=?", orderID).Select("SUM(product_id)").Scan(&sum).Error
	if 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 int64
	err := globalDB.Table("orders").Where("user_id=?", userID).Select("SUM(product_id)").Scan(&sum).Error
	if 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 int64
	err := globalDB.Table("orders").Where("order_id=?", orderID).Count(&count).Error
	if 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 int64
	err := globalDB.Table("orders").Where("user_id=?", userID).Count(&count).Error
	if 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 int64
	err := globalDB.Table("orders").Count(&count).Error
	if 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 int64
	err := globalDB.Table("orders").Select("SUM(product_id)").Scan(&sum).Error
	if 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 int64
	err := globalDB.Table("orders").Select("MAX(user_id)").Scan(&max).Error
	if 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 int64
	err := globalDB.Table("orders").Select("MIN(user_id)").Scan(&min).Error
	if 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 float64
	err := globalDB.Table("orders").Select("AVG(user_id)").Scan(&avg).Error
	if 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 []OrderGroup
	err := globalDB.Table("orders").Group("order_id").Select("*,SUM(product_id) AS sum_product,MAX(product_id) as max_product").Find(&orders).Error
	if 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 []OrderGroup
	err := globalDB.Table("orders").Group("user_id").Select("*,SUM(product_id) AS sum_product,MAX(product_id) as max_product").Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Order("order_id desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Order("user_id desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Distinct("order_id").Find(&orders).Error
	if 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 []Order
	err := globalDB.Table("orders").Distinct("user_id").Find(&orders).Error
	if 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 []OrderProduct
	err := globalDB.Table("orders").Joins("JOIN product ON orders.product_id = product.id").Select("orders.*,product.*").Find(&orders).Error
	if 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 []OrderUser
	err := globalDB.Table("orders").Joins("JOIN user ON orders.user_id = user.id").Select("orders.*,user.*").Find(&orders).Error
	if 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 []OrderProduct
	sql := `SELECT subquery.* FROM (SELECT orders.* FROM orders JOIN product ON orders.product_id = product.id) AS subquery`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []OrderUser
	sql := `SELECT subquery.* FROM (SELECT orders.* FROM orders JOIN user ON orders.user_id = user.id) AS subquery`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []Order
	sql := `SELECT * FROM orders WHERE user_id IN (SELECT id FROM user)`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []Order
	sql := `SELECT * FROM orders WHERE user_id = 8648 UNION SELECT * FROM orders WHERE user_id = 3401`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []Order
	sql := `SELECT * FROM orders WHERE user_id = 8648 UNION ALL SELECT * FROM orders WHERE user_id = 3401`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []Order
	sql := `SELECT * FROM orders WHERE order_id = '20240101ORDER6546' UNION SELECT * FROM orders WHERE order_id = '20240101ORDER9728'`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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 []Order
	sql := `SELECT * FROM orders WHERE order_id = '20240101ORDER6546' UNION ALL SELECT * FROM orders WHERE order_id = '20240101ORDER9728'`
	err := globalDB.Raw(sql).Scan(&orders).Error
	if 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).Error
	if 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).Error
	if 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{}).Error
	if 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{}).Error
	if 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 = db
	return db
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/946357.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【赵渝强老师】MongoDB文档级别的并发控制

【赵渝强老师】MongoDB文档级别的并发控制

MongoDB在执行写操作时&#xff0c;WiredTiger存储引擎会在文档级别进行并发控制。换句话说在同一时间点上&#xff0c;多个写操作能够修改同一个集合中的不同文档&#xff1b;而当多个写操作修改同一个文档时&#xff0c;必须以序列化方式执行。这意味着如果当前文档正在被修改…
阅读更多...
Java开发 PDF文件生成方案

Java开发 PDF文件生成方案

业务需求背景 业务端需要能够将考试答卷内容按指定格式呈现并导出为pdf格式进行存档&#xff0c;作为紧急需求插入。导出内容存在样式复杂性&#xff0c;包括特定的字体&#xff08;中文&#xff09;、字号、颜色&#xff0c;页面得有页眉、页码&#xff0c;数据需要进行表格聚…
阅读更多...
C++文件流 例题

C++文件流 例题

问题&#xff1a; 设计一个留言类&#xff0c;实现以下的功能&#xff1a; 1) 程序第一次运行时&#xff0c;建立一个 message.txt 文本文件&#xff0c;并把用 户输入的信息存入该文件&#xff1b; 2) 以后每次运行时&#xff0c;都先读取该文件的内容并显示给用户&#xf…
阅读更多...
Xilinx DCI技术

Xilinx DCI技术

Xilinx DCI技术 DCI技术概述Xilinx DCI技术实际使用某些Bank特殊DCI要求 DCI级联技术DCI端接方式阻抗控制驱动器&#xff08;源端接&#xff09;半阻抗控制阻抗驱动器&#xff08;源端接&#xff09;分体式DCI&#xff08;戴维宁等效端接到VCCO/2&#xff09;DCI和三态DCI&…
阅读更多...
「Mac畅玩鸿蒙与硬件51」UI互动应用篇28 - 模拟记账应用

「Mac畅玩鸿蒙与硬件51」UI互动应用篇28 - 模拟记账应用

本篇教程将介绍如何创建一个模拟记账应用&#xff0c;通过账单输入、动态列表展示和实时统计功能&#xff0c;学习接口定义和组件间的数据交互。 关键词 UI互动应用接口定义动态列表实时统计数据交互 一、功能说明 模拟记账应用包含以下功能&#xff1a; 账单输入&#xff1…
阅读更多...
阴阳师の新手如何速刷5个SP/SSR?!（急速育成）

阴阳师の新手如何速刷5个SP/SSR?!（急速育成）

目标&#xff1a;攒5个SP/SSR式神&#xff0c;参与急速育成&#xff0c;省四个黑蛋&#xff08;想要快速升级技能而且经常上场的式神在攒够5个式神前先不升级&#xff09;【理论上组成&#xff1a;10蓝40蓝预约召唤福利20修行or抽卡】 关键点&#xff1a;蓝票&#xff0c;新手…
阅读更多...
Linux应用软件编程-多任务处理（进程，线程）-通信（管道，信号，内存共享）

Linux应用软件编程-多任务处理（进程，线程）-通信（管道，信号，内存共享）

多任务处理&#xff1a;让系统具备同时处理多个事件的能力。让系统具备并发性能。方法&#xff1a;进程和线程。这里先讲进程。 进程&#xff08;process&#xff09;&#xff1a;正在执行的程序&#xff0c;执行过程中需要消耗内存和CPU。 进程的创建&#xff1a;操作系统在…
阅读更多...
使用 TensorFlow 打造企业智能数据分析平台

使用 TensorFlow 打造企业智能数据分析平台

文章目录 摘要引言平台架构设计核心架构技术栈选型 数据采集与预处理代码详解 数据分析与预测代码详解 数据可视化ECharts 配置 总结未来展望参考资料 摘要 在大数据时代&#xff0c;企业决策正越来越依赖数据分析。然而&#xff0c;面对海量数据&#xff0c;传统分析工具常因…
阅读更多...
初始JavaEE篇 —— Maven相关配置

初始JavaEE篇 —— Maven相关配置

找往期文章包括但不限于本期文章中不懂的知识点&#xff1a; 个人主页&#xff1a;我要学编程程(ಥ_ಥ)-CSDN博客 所属专栏&#xff1a;JavaEE 目录 介绍 创建第一个Maven项目 Maven的核心功能 项目构建 依赖管理 添加依赖 依赖排除 依赖调解 Maven仓库 配置本地仓…
阅读更多...
Linux套接字通信学习

Linux套接字通信学习

Linux套接字通信 代码源码&#xff1a;https://github.com/say-Hai/TcpSocketLearn/tree/CThreadSocket 在网络通信的时候, 程序猿需要负责的应用层数据的处理(最上层)&#xff0c;而底层的数据封装与解封装&#xff08;如TCP/IP协议栈的功能&#xff09;通常由操作系统、网络协…
阅读更多...
职场常用Excel基础01-数据验证

职场常用Excel基础01-数据验证

大家好&#xff0c;excel在职场中使用非常频繁&#xff0c;今天和大家一起分享一下excel中数据验证相关的内容~ 在Excel中&#xff0c;数据验证&#xff08;Data Validation&#xff09;是一项非常有用的功能&#xff0c;它可以帮助用户限制输入到单元格中的数据类型和范围&am…
阅读更多...
建造者设计模式学习

建造者设计模式学习

1.介绍 建造者模式是一种创建型设计模式&#xff0c;它将一个复杂对象的构建过程与它的表示分离&#xff0c;使得相同的构建过程可以创建不同的表示。通过分步骤地构建对象&#xff0c;建造者模式提供了更细粒度的控制和灵活性&#xff0c;特别适合需要灵活创建复杂对象的场景…
阅读更多...
ROS2+OpenCV综合应用--10. AprilTag标签码追踪

ROS2+OpenCV综合应用--10. AprilTag标签码追踪

1. 简介 apriltag标签码追踪是在apriltag标签码识别的基础上&#xff0c;增加了小车摄像头云台运动的功能&#xff0c;摄像头会保持标签码在视觉中间而运动&#xff0c;根据这一特性&#xff0c;从而实现标签码追踪功能。 2. 启动 2.1 程序启动前的准备 本次apriltag标签码使…
阅读更多...
mysql乱码、mysql数据中文问号

mysql乱码、mysql数据中文问号

网上排出此错误方法的很多&#xff0c;但是 都不简洁&#xff0c;找不到根本原因 主要排查两点&#xff1a; 1.代码中jdbc链接的编码规则 urljdbc:mysql://localhost:3306/title?useUnicodetrue&amp;characterEncodingutf8 将characterEncoding设置为utf8 2.设置mysq…
阅读更多...
Presto-简单了解-230403

Presto-简单了解-230403

presto是什么了解一下&#xff1a; 秒级查询引擎&#xff08;不做存储&#xff09;&#xff0c;GB-PB级不依赖于yarn&#xff0c;有自己的资源管理和执行计划支持多种数据源&#xff1a;hive、redis、kafka presto架构 presto优缺点 presto优点 内存到内存的传输&#xff0…
阅读更多...
openGauss连接是报org.opengauss.util.PSQLException: 尝试连线已失败

openGauss连接是报org.opengauss.util.PSQLException: 尝试连线已失败

安装好高斯数据库后然后用java连接时报如下错误: 解决方法: 在openGauss数据库的安装路径下/opt/opengauss/data/single_node&#xff08;这个路径根据自己实际情况变化&#xff09;有个pg_hba.conf文件&#xff0c;修改里面host内容如下&#xff0c;我这里设置的是所有ip都能…
阅读更多...
mybatis-plus自动填充时间的配置类实现

mybatis-plus自动填充时间的配置类实现

mybatis-plus自动填充时间的配置类实现 在实际操作过程中&#xff0c;我们并不希望创建时间、修改时间这些来手动进行&#xff0c;而是希望通过自动化来完成&#xff0c;而mybatis-plus则也提供了自动填充功能来实现这一操作&#xff0c;接下来&#xff0c;就来了解一下mybatis…
阅读更多...
【Java项目】基于SpringBoot的【人职匹配推荐系统】

【Java项目】基于SpringBoot的【人职匹配推荐系统】

【Java项目】基于SpringBoot的【人职匹配推荐系统】 技术简介&#xff1a;本系统使用采用B/S架构、Spring Boot框架、MYSQL数据库进行开发设计。 系统简介&#xff1a;人职匹配推荐系统分为管理员和用户、企业三个权限子模块。 管理员所能使用的功能主要有&#xff1a;首页、个…
阅读更多...
Flutter 调试环境下浏览器网络请求跨域问题解决方案

Flutter 调试环境下浏览器网络请求跨域问题解决方案

本篇文章主要讲解&#xff0c;Flutter调试环境情况下&#xff0c;浏览器调试报错跨域问题的解决方法&#xff0c;通过本篇文章你可以快速掌握Flutter调试环境情况下的跨域问题。 日期&#xff1a;2024年12月28日 作者&#xff1a;任聪聪 报错现象&#xff1a; 报文信息&#xf…
阅读更多...
【每日学点鸿蒙知识】导入cardEmulation、自定义装饰器、CallState状态码顺序、kv配置、签名文件配置

【每日学点鸿蒙知识】导入cardEmulation、自定义装饰器、CallState状态码顺序、kv配置、签名文件配置

1、HarmonyOS 无法导入cardEmulation&#xff1f; 在工程entry mudule里的index.ets文件里导入cardEmulation失败 可以按照下面方式添加SystemCapability&#xff1b;在src/main/syscap.json(此文件需要手动创建&#xff09;中添加如下内容 {"devices": {"gen…
阅读更多...
最新文章

Copyright @ 2022~2023