下单接口实现

## GORM子查询操作

子查询
子查询（Subquery）是SQL中非常强大的功能，它允许嵌套查询。 当你使用 *gorm.DB 对象作为参数时，GORM 可以自动生成子查询。

// 简单的子查询
db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// SQL: SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");

// 内嵌子查询
subQuery := db.Select("AVG(age)").Where("name LIKE ?", "name%").Table("users")
db.Select("AVG(age) as avgage").Group("name").Having("AVG(age) > (?)", subQuery).Find(&results)
// SQL: SELECT AVG(age) as avgage FROM `users` GROUP BY `name` HAVING AVG(age) > (SELECT AVG(age) FROM `users` WHERE name LIKE "name%")
From 子查询
GORM 允许在 FROM 子句中使用子查询，从而支持复杂的查询和数据组织。

// 在 FROM 子句中使用子查询
db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18).Find(&User{})
// SQL: SELECT * FROM (SELECT `name`,`age` FROM `users`) as u WHERE `age` = 18

// 在 FROM 子句中结合多个子查询
subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})
// SQL: SELECT * FROM (SELECT `name` FROM `users`) as u, (SELECT `name` FROM `pets`) as p

```go
package main

import (
    "fmt"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

type WealthOrder struct {
    Currency    string
    ApplyAmount float64
}

func main() {
    // 连接数据库（以SQLite为例，您可能需要根据实际情况调整）
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 构建子查询SQL
    subQuerySQL := db.Model(&WealthOrder{}).
        Select("currency, applyAmount").
        Where("orderStatus IN ?", []int{4, 100, 200, 300, 400, 450, 500, 501, 600, 601, 602, 700, 800, 900}).
        Order("submitTime DESC").
        Limit(2).
        Offset(1).
        ToSQL(func(tx *gorm.DB) *gorm.DB {
            return tx.Select("currency, SUM(applyAmount) AS totalAmount")
        })

    // 使用子查询
    var results []map[string]interface{}
    db.Raw("SELECT currency, SUM(applyAmount) AS totalAmount FROM (?) AS todr GROUP BY currency", gorm.Expr(subQuerySQL)).Scan(&results)

    // 打印结果
    fmt.Println(results)
}

```


Gorm经验

首先复制前面的build sql。因为不同的数据库可能字段不一样，而我们需要筛选的是当前数据库当前条件下的金额汇总就行了。

其次再最外层加上调用这个方法获得sql的方法，还得修改结构体以便于接收参数。

## build sql函数内的修改

先修改头sql添加头sql方法
```go

```

```go
var sumAmountList []wamapping.CurrencySum

sumAmountSQL, sumAmountValues,err := r.BuildSumAmountSQLWithValues(ctx.Context())
if err != nil {
	return errors.WithMessage(err, "Failed to build SQL for querying the total order amount by currency in the collection")
}
if err = s.DB.Raw(sumAmountSQL, sumAmountValues...).Scan(&sumAmountList).Error; err != nil {
	return errors.WithMessage(err, "search wealth order list failed")
}
	
		err = copier.CopyWithOption(&resp.CurrencySumList, sumAmountList, copier.Option{Converters: []copier.TypeConverter{TimerPoint2StringConverter, String2IntConverter}})
if err != nil {
	l.Info("copy database model to resp model failed", zap.String("error", err.Error()))
	return code.Response(ctx, code.NewDefaultError(code.ErrBuildResp), nil)
}
```


## 票据订单接口

```go
func (w WealthOrderDao) SearchAll(ctx context.Context, tx *gorm.DB, sWrapper *dao.OrderSearchWrapper) (tradedb.TWealthOrders, error) {
	if tx == nil {
		tx = w.DBCtx(ctx)
	}
	ret := make(tradedb.TWealthOrders, 0, 0)
        // 应用 `sWrapper.GormSearch()` 方法提供的 GORM 搜索范围（scopes）
	g := tx.WithContext(ctx).Table(tradedb.TWealthOrderTableName).Scopes(sWrapper.GormSearch())
	if sWrapper.Sort.Valid {
		g = g.Order(sWrapper.Sort.ValueOrZero())
	}
	return ret, g.Find(&ret).Error
}
```

这段 Go 代码定义了一个名为 `SearchList` 的方法，该方法是 `WealthOrderDao` 接口的一个实现，主要用于从数据库中搜索并获取财富订单列表。下面逐行解释代码含义：

1. 定义了一个函数，其接收者 `w` 是实现了 `WealthOrderDao` 接口的对象，参数包括：
   - `ctx`: 上下文对象，通常携带请求相关的元数据及取消信号。
   - `tx`: 可选的数据库事务对象，默认为 `nil`。若传入则使用传入的事务进行数据库操作，否则使用 `w.DBCtx(ctx)` 创建或获取数据库连接。

2. 判断是否提供了数据库事务 `tx`，如果没有提供，则基于 `ctx` 上下文获取数据库连接。

3. 初始化一个空的 `tradedb.TWealthOrders` 类型切片，它应该是预定义的一种用于存储财富订单数据的结构体切片。

4. 使用 `WithContext` 方法将 `ctx` 上下文传递给数据库连接，接着设置查询表名为 `tradedb.TWealthOrderTableName` 并应用 `sWrapper.GormSearch()` 方法提供的 GORM 搜索范围（scopes）。

5. 根据 `sWrapper.Start` 设置查询的偏移量（offset），用于分页查询时跳过前几条记录。

6. 根据 `sWrapper.Count` 设置查询的数量限制（limit），用于控制单次查询返回的记录数量。

7. 检查排序字段 `sWrapper.Sort` 是否有效，如果有效，则按照其值（`sWrapper.Sort.ValueOrZero()`）对查询结果进行排序。

8. 最后，执行数据库查询操作，将查询结果填充到之前初始化的空切片 `ret` 中，并返回填充后的切片以及查询过程中的任何错误。

综上所述，这段代码实现了一个利用 GORM 库针对财富订单表进行条件筛选、排序和分页查询的方法，并返回符合查询条件的财富订单列表及可能发生的错误。



订单金额汇总接口的拓展

项目中可拓展性良好的查询接口实现

## 我这个接口返回这个数据：
```json
{
	"jsonrpc": "2.0",
	"id": "123123123",
	"result": {
		"list": [{
				"portfolioName": "基金多只",
				"portfolioID": "TG20240221000005",
				"portfolioType": 4,
				"subAccountID": "99688015101",
				"followerStatus": 3
			},
			{
				"portfolioName": "基金+债券组合amy",
				"portfolioID": "TG20240223000002",
				"portfolioType": 4,
				"subAccountID": "99688015102",
				"followerStatus": 3
			}
		],
		"count": 2
	}
}
```
我现在需要一次性把里面的数据全部拿出来然后存起来，这样就避免重复的调用http，请问代码该怎么写

要一次性提取这个接口返回的数据并存储起来，你可以按照以下步骤操作：

1. **定义结构体来映射JSON数据**：根据你的需求，定义适合的结构体来接收和存储JSON数据。
2. **发起HTTP请求以获取数据**：使用Go的`net/http`包发起HTTP请求到指定的接口。
3. **解析JSON数据**：使用`encoding/json`包解析接口返回的JSON数据到之前定义的结构体中。
4. **存储数据**：将解析后的数据存储到适当的存储中，这里假设我们只是将其存储在内存中的一个变量里。

以下是一个简化的示例，展示了如何完成这个过程：

```go
package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

// PortfolioItem 定义了list中每个项目的结构
type PortfolioItem struct {
	PortfolioName  string `json:"portfolioName"`
	PortfolioID    string `json:"portfolioID"`
	PortfolioType  int    `json:"portfolioType"`
	SubAccountID   string `json:"subAccountID"`
	FollowerStatus int    `json:"followerStatus"`
}

// Response 定义了整个JSON响应的结构
type Response struct {
	Result struct {
		List  []PortfolioItem `json:"list"`
		Count int             `json:"count"`
	} `json:"result"`
}

func main() {
	// 替换为实际的URL
	url := "http://example.com/api/path"

	resp, err := http.Get(url)
	if err != nil {
		fmt.Printf("Error fetching data: %v\n", err)
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %v\n", err)
		return
	}

	var response Response
	if err := json.Unmarshal(body, &response); err != nil {
		fmt.Printf("Error parsing JSON: %v\n", err)
		return
	}

	// 此时，response.Result.List 包含了所有你需要的数据
	// 以下代码仅为展示如何访问这些数据
	for _, item := range response.Result.List {
		fmt.Printf("%+v\n", item)
	}

	// 在这里，你可以将response.Result.List存储到数据库或其他存储系统中
}
```

在这个示例中，我们首先定义了`PortfolioItem`和`Response`两个结构体来映射JSON数据。然后，我们使用`http.Get`函数从指定的URL获取数据。获取到的响应体被读取并解析为`Response`结构体的实例。最后，我们遍历`response.Result.List`来展示如何访问解析后的数据。

请确保替换`url`变量的值为你实际的接口URL。此外，根据你的实际情况，你可能需要将解析后的数据存储到数据库或其他存储系统中，这一步在示例代码中以注释的形式提到。

GORM子查询操作

具体需求

我这个接口返回这个数据：