Golang实现支持1000种查询模板的REST API开发指南

是的，我做到了！

这涉及到大约四百个SQL调用公式。由于公式可能随时更改，因此利用这种数据库方法非常有用。

编程愉快！

Marco_Azevedo:

我将在数据库中创建一个查询目录。意思是…在数据库中创建一张表来存储SQL语句，用唯一ID来标识SQL，而不是在代码中放置上千行SQL。

将查询存储在查找数据库中是我考虑的方案之一。优点是无需部署和重启API即可添加和更新查询。这将真正简化API的维护工作。

缺点在于增加了额外的（延迟？）层，并且API无法轻松迁移到其他服务器。

有人对此有任何看法，或者已经尝试过使用数据库存储查询吗？

对于管理大量 SQL 查询的 Golang REST API，推荐使用代码生成的方式。这种方法既能保持原生 SQL 的可读性，又能提供类型安全和良好的维护性。

以下是一个完整的实现方案：

1. 首先创建查询模板文件（如 queries.sql）：

-- name: GetUserByID
SELECT id, name, email FROM users WHERE id = $1;

-- name: GetProductsByCategory
SELECT id, name, price FROM products WHERE category_id = $1 AND active = true;

-- name: UpdateUserStatus
UPDATE users SET status = $1, updated_at = NOW() WHERE id = $2;

1. 创建代码生成器：

// cmd/generate/main.go
package main

import (
    "database/sql"
    "log"
    "os"
    "strings"
    "text/template"
    
    _ "github.com/lib/pq"
)

type Query struct {
    Name    string
    SQL     string
}

const queriesFile = "./sql/queries.sql"

func main() {
    content, err := os.ReadFile(queriesFile)
    if err != nil {
        log.Fatal(err)
    }

    queries := parseQueries(string(content))
    generateCode(queries)
}

func parseQueries(content string) []Query {
    var queries []Query
    lines := strings.Split(content, "\n")
    
    var currentQuery Query
    var sqlBuilder strings.Builder
    
    for _, line := range lines {
        if strings.HasPrefix(line, "-- name:") {
            if currentQuery.Name != "" {
                currentQuery.SQL = strings.TrimSpace(sqlBuilder.String())
                queries = append(queries, currentQuery)
                sqlBuilder.Reset()
            }
            name := strings.TrimPrefix(line, "-- name:")
            currentQuery = Query{Name: strings.TrimSpace(name)}
        } else if !strings.HasPrefix(line, "--") && line != "" {
            sqlBuilder.WriteString(line + "\n")
        }
    }
    
    if currentQuery.Name != "" {
        currentQuery.SQL = strings.TrimSpace(sqlBuilder.String())
        queries = append(queries, currentQuery)
    }
    
    return queries
}

func generateCode(queries []Query) {
    tmpl := `package database

import "database/sql"

type Queries struct {
    db *sql.DB
}

func NewQueries(db *sql.DB) *Queries {
    return &Queries{db: db}
}

{{range .}}
func (q *Queries) {{.Name}}({{getParams .SQL}}) (*sql.Rows, error) {
    return q.db.Query("{{.SQL}}", {{getArgs .SQL}})
}
{{end}}
`

    funcMap := template.FuncMap{
        "getParams": getParams,
        "getArgs":   getArgs,
    }

    t := template.Must(template.New("queries").Funcs(funcMap).Parse(tmpl))
    
    f, err := os.Create("./database/queries_gen.go")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    if err := t.Execute(f, queries); err != nil {
        log.Fatal(err)
    }
}

func getParams(sql string) string {
    // 解析SQL中的参数位置并生成函数参数
    count := strings.Count(sql, "$")
    if count == 0 {
        return ""
    }
    
    params := make([]string, count)
    for i := 0; i < count; i++ {
        params[i] = "arg" + string(rune('1'+i))
    }
    
    return strings.Join(params, ", ")
}

func getArgs(sql string) string {
    count := strings.Count(sql, "$")
    if count == 0 {
        return ""
    }
    
    args := make([]string, count)
    for i := 0; i < count; i++ {
        args[i] = "arg" + string(rune('1'+i))
    }
    
    return strings.Join(args, ", ")
}

1. 生成的查询代码：

// database/queries_gen.go
package database

import "database/sql"

type Queries struct {
    db *sql.DB
}

func NewQueries(db *sql.DB) *Queries {
    return &Queries{db: db}
}

func (q *Queries) GetUserByID(arg1 int) (*sql.Rows, error) {
    return q.db.Query("SELECT id, name, email FROM users WHERE id = $1", arg1)
}

func (q *Queries) GetProductsByCategory(arg1 int) (*sql.Rows, error) {
    return q.db.Query("SELECT id, name, price FROM products WHERE category_id = $1 AND active = true", arg1)
}

func (q *Queries) UpdateUserStatus(arg1 string, arg2 int) (*sql.Rows, error) {
    return q.db.Query("UPDATE users SET status = $1, updated_at = NOW() WHERE id = $2", arg1, arg2)
}

1. 在API中使用：

// main.go
package main

import (
    "database/sql"
    "encoding/json"
    "log"
    "net/http"
    "strconv"
    
    "yourproject/database"
    _ "github.com/lib/pq"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    db, err := sql.Open("postgresql", "connection-string")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    queries := database.NewQueries(db)
    
    http.HandleFunc("/users/", func(w http.ResponseWriter, r *http.Request) {
        idStr := r.URL.Path[len("/users/"):]
        id, err := strconv.Atoi(idStr)
        if err != nil {
            http.Error(w, "Invalid ID", http.StatusBadRequest)
            return
        }

        rows, err := queries.GetUserByID(id)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        defer rows.Close()

        var user User
        if rows.Next() {
            err := rows.Scan(&user.ID, &user.Name, &user.Email)
            if err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return
            }
        }

        json.NewEncoder(w).Encode(user)
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}

这种方法的优势：

• 保持原生SQL的可读性和性能
• 提供类型安全的函数调用
• 易于维护和扩展
• 编译时检查SQL语法
• 支持IDE的自动补全和跳转

可以通过在构建过程中集成代码生成步骤来自动化整个过程。