├── adapters // 封装postgres逻辑 
├── cache    // 支持缓存，使用 buntdb 缓存API处理结果，加速查询
├── cmd      // 子命令
├── config   // 配置解析
├── context  // context管理
├── controllers   // 路由处理，包括元数据、表数据CRUD等入口
├── middlewares   // 中间件
├── plugins    // plugin处理逻辑
├── router  // 路由注册
├── scripts   //  docker脚本等
├── template   // 自定义查询中支持的函数实现
├── testdata  // 测试数据

// 用StrictSlash选项。这意呀着如果路由路径以斜杠/结尾，而请求没有以斜杠结尾，或者相反，路由器将尝试重定向请求到正确的路径（如果可能）。
	router := mux.NewRouter().StrictSlash(true)

// 用户认证
if config.PrestConf.AuthEnabled {
	// 从数据库中获取用户名和密码，成功则生成JWT token
	// 注意：DB的操作方式，虽然使用adater封装了一层，但依然需要上传拼装sql。解耦不彻底。
	router.HandleFunc("/auth", controllers.Auth).Methods("POST")
}

// 数据库列表: 从pg_database中获取数据库列表
router.HandleFunc("/databases", controllers.GetDatabases).Methods("GET")
// schema列表：从information_schema.schemata中查询 schema_name
router.HandleFunc("/schemas", controllers.GetSchemas).Methods("GET")
// table列表：从 pg_catalog.pg_class、pg_catalog.pg_namespace 获取表名
router.HandleFunc("/tables", controllers.GetTables).Methods("GET")

// 自定义查询：从文件或脚本中获取查询语句，并根据参数解析后执行。返回执行结果
router.HandleFunc("/_QUERIES/{queriesLocation}/{script}", controllers.ExecuteFromScripts)

// 插件执行
if runtime.GOOS != "windows" {
	router.HandleFunc("/_PLUGIN/{file}/{func}", plugins.HandlerPlugin)
}
// database/schema下的table列表(可以与上面的table列表合并？)
router.HandleFunc("/{database}/{schema}", controllers.GetTablesByDatabaseAndSchema).Methods("GET")
// 数据库/schema下的table结构
router.HandleFunc("/show/{database}/{schema}/{table}", controllers.ShowTable).Methods("GET")

// 在 / 路径下，注册 CRUD 子路由？？
crudRoutes := mux.NewRouter().PathPrefix("/").Subrouter().StrictSlash(true)

// 健康检查
router.HandleFunc("/_health", controllers.WrappedHealthCheck(controllers.DefaultCheckList)).Methods("GET")

// table CRUD操作
crudRoutes.HandleFunc("/{database}/{schema}/{table}", controllers.SelectFromTables).Methods("GET")
crudRoutes.HandleFunc("/{database}/{schema}/{table}", controllers.InsertInTables).Methods("POST")
crudRoutes.HandleFunc("/batch/{database}/{schema}/{table}", controllers.BatchInsertInTables).Methods("POST")
crudRoutes.HandleFunc("/{database}/{schema}/{table}", controllers.DeleteFromTable).Methods("DELETE")
crudRoutes.HandleFunc("/{database}/{schema}/{table}", controllers.UpdateTable).Methods("PUT", "PATCH")

// 因为下面几个中间件仅针对 CRUD 操作生效
router.PathPrefix("/").Handler(negroni.New(
	middlewares.ExposureMiddleware(),
	middlewares.AccessControl(),
	middlewares.AuthMiddleware(),
	middlewares.CacheMiddleware(&config.PrestConf.Cache),
	// plugins middleware
	plugins.MiddlewarePlugin(),
	negroni.Wrap(crudRoutes), // 仅针对 CRUD 操作生效
))

func Token(u auth.User) (t string, err error) {
	// add start time (NotBefore)
	getToken := time.Now()
	// add expiry time in configuration (in minute format, so we support the maximum need)
	expireToken := time.Now().Add(time.Hour * 6)

	// TODO: JWT any Algorithm support
	sig, err := jose.NewSigner(
		jose.SigningKey{
			Algorithm: jose.HS256,
			Key:       []byte(config.PrestConf.JWTKey)},
		(&jose.SignerOptions{}).WithType("JWT"))
	if err != nil {
		return
	}

	cl := auth.Claims{
		UserInfo:  u,
		NotBefore: jwt.NewNumericDate(getToken),
		Expiry:    jwt.NewNumericDate(expireToken),
	}
	return jwt.Signed(sig).Claims(cl).CompactSerialize()
}

crudRoutes.HandleFunc("/{database}/{schema}/{table}", controllers.SelectFromTables).Methods("GET")

func (adapter *Postgres) QueryCtx(ctx context.Context, SQL string, params ...interface{}) (sc adapters.Scanner) {
	// use the db_name that was set on request to avoid runtime collisions
	db, err := getDBFromCtx(ctx)
	if err != nil {
		log.Errorln(err)
		return &scanner.PrestScanner{Error: err}
	}
	SQL = fmt.Sprintf("SELECT %s(s) FROM (%s) s", config.PrestConf.JSONAggType, SQL)
	log.Debugln("generated SQL:", SQL, " parameters: ", params)
	p, err := Prepare(db, SQL)
	if err != nil {
		log.Errorln(err)
		return &scanner.PrestScanner{Error: err}
	}
	var jsonData []byte
	err = p.QueryRowContext(ctx, params...).Scan(&jsonData)
	if len(jsonData) == 0 {
		jsonData = []byte("[]")
	}
	return &scanner.PrestScanner{
		Error:   err,
		Buff:    bytes.NewBuffer(jsonData),
		IsQuery: true,
	}
}

/{DATABASE}/{SCHEMA}/{TABLE}?_join={TYPE}:{TABLE JOIN}:{TABLE.FIELD}:{OPERATOR}:{TABLE JOIN.FIELD}

funcs := &template.FuncRegistry{TemplateData: templateData}
tpl := gotemplate.New(tplName).Funcs(funcs.RegistryAllFuncs())

// 解析 SQL 模板文件
tpl, err = tpl.ParseFiles(scriptPath)
if err != nil {
	err = fmt.Errorf("could not parse file %s: %v", scriptPath, err)
	return
}

// 执行模板文件
var buff bytes.Buffer
err = tpl.Execute(&buff, funcs.TemplateData)
if err != nil {
	err = fmt.Errorf("could not execute template %v", err)
	return
}

// 返回解析后的 SQL
sqlQuery = buff.String()