Go+typescript+GraphQL+react构建简书网站（三） 编写Model
2014 年 8 月 5 日
补遗：数据库增加Tag表
新建tag表：
CREATE TABLE "public"."tag" (
"id" int8 NOT NULL,
"name" varchar(255) NOT NULL,
"created_at" timestamp(6) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" timestamp(6) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"deleted_at" timestamp(6) NOT NULL,
PRIMARY KEY ("id")
)
;
COMMENT ON COLUMN "public"."tag"."id" IS 'ID';
COMMENT ON COLUMN "public"."tag"."name" IS '标签名';
COMMENT ON COLUMN "public"."tag"."created_at" IS '创建时间';
COMMENT ON COLUMN "public"."tag"."updated_at" IS '更新时间';
COMMENT ON COLUMN "public"."tag"."deleted_at" IS '删除时间';
这里不得不说一下，由于是一边写代码一边写文章（文章的作用只是用来给自己厘清思路），所以文章中的代码内容很可能下一次就变了，毕竟文章中的代码，只是我初步写时的思路，肯定存在错漏之处，后续会慢慢完善。如要看最新的代码，还请移步： https://github.com/unrotten/h…
编写CURD基础方法
依然先看结果，修改 db.go 文件：
package model
import (
"context"
"database/sql"
"database/sql/driver"
"fmt"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
"github.com/rs/zerolog"
"github.com/sony/sonyflake"
"github.com/spf13/viper"
"github.com/unrotten/builder"
"github.com/unrotten/sqlex"
"log"
"os"
"reflect"
"time"
)
var (
DB *sqlx.DB
psql sqlex.StatementBuilderType
idfetcher *sonyflake.Sonyflake
)
const defaultSkip int = 2
type cv map[string]interface{}
type where []sqlex.Sqlex
type result struct {
b builder.Builder
success bool
}
// 初始化数据库连接
func init() {
viper.AddConfigPath("../config") // 测试使用
viper.ReadInConfig()
// 获取数据库配置信息
user := viper.Get("storage.user")
password := viper.Get("storage.password")
host := viper.Get("storage.host")
port := viper.Get("storage.port")
dbname := viper.Get("storage.dbname")
// 连接数据库
psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
host, port, user, password, dbname)
DB = sqlx.MustOpen("postgres", psqlInfo)
if err := DB.Ping(); err != nil {
log.Fatalf("连接数据库失败:%s", err)
}
// 初始化sql构建器，指定format形式
psql = sqlex.StatementBuilder.PlaceholderFormat(sqlex.Dollar)
sqlex.SetLogger(os.Stdout)
// 初始化sonyflake
st := sonyflake.Settings{
StartTime: time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local),
}
idfetcher = sonyflake.NewSonyflake(st)
}
func get(query *sql.Rows, columnTypes []*sql.ColumnType, logger zerolog.Logger) result {
dest := make([]interface{}, len(columnTypes))
for index, col := range columnTypes {
switch col.ScanType().String() {
case "string", "interface {}":
dest[index] = &sql.NullString{}
case "bool":
dest[index] = &sql.NullBool{}
case "float64":
dest[index] = &sql.NullFloat64{}
case "int32":
dest[index] = &sql.NullInt32{}
case "int64":
dest[index] = &sql.NullInt64{}
case "time.Time":
dest[index] = &sql.NullTime{}
default:
dest[index] = reflect.New(col.ScanType()).Interface()
}
}
err := query.Scan(dest...)
if err != nil {
logger.Error().Caller(2).Err(err).Send()
return result{success: false}
}
build := builder.EmptyBuilder
for index, col := range columnTypes {
switch val := dest[index].(type) {
case driver.Valuer:
var value interface{}
switch col.ScanType().String() {
case "string", "interface {}":
value = dest[index].(*sql.NullString).String
case "bool":
value = dest[index].(*sql.NullBool).Bool
case "float64":
value = dest[index].(*sql.NullFloat64).Float64
case "int32":
value = dest[index].(*sql.NullInt32).Int32
case "int64":
value = dest[index].(*sql.NullInt64).Int64
case "time.Time":
value = dest[index].(*sql.NullTime).Time
}
build = builder.Set(build, col.Name(), value).(builder.Builder)
default:
build = builder.Set(build, col.Name(), val).(builder.Builder)
}
}
return result{success: true, b: build}
}
func selectList(ctx context.Context, table string, where where, columns ...string) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
var selectBuilder sqlex.SelectBuilder
if len(columns) > 0 {
selectBuilder = psql.Select(columns...).From(table).Where("deleted_at is null")
} else {
selectBuilder = psql.Select("*").From(table).Where("deleted_at is null")
}
for _, arg := range where {
selectBuilder = selectBuilder.Where(arg)
}
query, err := selectBuilder.RunWith(tx).Query()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
columnTypes, err := query.ColumnTypes()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
var resultSlice []interface{}
for query.Next() {
r := get(query, columnTypes, logger)
if !r.success {
return r
}
resultSlice = append(resultSlice, r.b)
}
return result{success: true, b: builder.Set(builder.EmptyBuilder, "list", resultSlice).(builder.Builder)}
}
func selectOne(ctx context.Context, table string, where where, columns ...string) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
var selectBuilder sqlex.SelectBuilder
if len(columns) > 0 {
selectBuilder = psql.Select(columns...).From(table).Where("deleted_at is null").Limit(1)
} else {
selectBuilder = psql.Select("*").From(table).Where("deleted_at is null").Limit(1)
}
for _, arg := range where {
selectBuilder = selectBuilder.Where(arg)
}
query, err := selectBuilder.RunWith(tx).Query()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
columnTypes, err := query.ColumnTypes()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
if query.Next() {
return get(query, columnTypes, logger)
}
return result{success: false}
}
func selectReal(ctx context.Context, table string, where where, columns ...string) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
var selectBuilder sqlex.SelectBuilder
if len(columns) > 0 {
selectBuilder = psql.Select(columns...).From(table).Where("deleted_at is not null")
} else {
selectBuilder = psql.Select("*").From(table).Where("deleted_at is not null")
}
for _, arg := range where {
selectBuilder = selectBuilder.Where(arg)
}
query, err := selectBuilder.RunWith(tx).Query()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
columnTypes, err := query.ColumnTypes()
if err != nil {
logger.Error().Caller(1).Err(err).Send()
return result{success: false}
}
var resultSlice []interface{}
for query.Next() {
r := get(query, columnTypes, logger)
if !r.success {
return r
}
resultSlice = append(resultSlice, r.b)
}
return result{success: true, b: builder.Set(builder.EmptyBuilder, "list", resultSlice).(builder.Builder)}
}
func insertOne(ctx context.Context, table string, cv cv) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
build := builder.EmptyBuilder
cv["created_at"], cv["updated_at"] = time.Now(), time.Now()
columns, values := make([]string, 0, len(cv)), make([]interface{}, 0, len(cv))
for col, value := range cv {
build = builder.Set(build, col, value).(builder.Builder)
columns, values = append(columns, col), append(values, value)
}
r, err := psql.Insert(table).Columns(columns...).Values(values...).RunWith(tx).Exec()
return assertSqlResult(r, err, logger)
}
func update(ctx context.Context, table string, cv cv, where where, directSet ...string) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
cv["updated_at"] = time.Now()
updateBuilder := psql.Update(table).SetMap(cv).Where("deleted_at is null")
for _, set := range directSet {
updateBuilder = updateBuilder.DirectSet(set)
}
for _, arg := range where {
updateBuilder = updateBuilder.Where(arg)
}
r, err := updateBuilder.RunWith(tx).Exec()
return assertSqlResult(r, err, logger)
}
// note: if where is null,then will delete the whole table
func remove(ctx context.Context, table string, where where) result {
logger := ctx.Value("logger").(zerolog.Logger)
tx := ctx.Value("tx").(*sqlx.Tx)
updateBuilder := psql.Update(table).Set("deleted_at", time.Now()).Where("deleted_at is null")
for _, arg := range where {
updateBuilder = updateBuilder.Where(arg)
}
r, err := updateBuilder.RunWith(tx).Exec()
return assertSqlResult(r, err, logger)
}
func assertSqlResult(r sql.Result, err error, logger zerolog.Logger, skip ...int) result {
sk := defaultSkip
if len(skip) > 0 {
sk += skip[0]
}
if err != nil {
logger.Error().Caller(sk).Err(err).Send()
return result{success: false}
}
affected, err := r.RowsAffected()
if err != nil {
logger.Error().Caller(2).Err(err).Send()
return result{success: false}
}
if affected == 0 {
return result{success: false}
}
return result{success: true}
}
在这里我们只看查询，selectList和selectOne依托于get方法实现，而get的核心就是设值。因为在数据库中，数据存在NULL的情况，而Go中的基础类型如string，int64等并不支持，所以我们必须使用其对应的sql.NullString等类型去scan。作者这里为了保持model中定义的struct能够继续使用string等基础类型，在get中进行了类型的判断，不可空的基础类型通过两次switch转换，最终即便对于NULL值，也会得到基础类型的默认空值。
在get方法中，我们使用 reflect.New(col.ScanType()).Interface() 方法，获得字段对应的指针值，这里使用了反射，效果等同于new()。
在记录错误日志 logger.Error().Caller(sk).Err(err).Send() 时，我们先指定了日志的类别为Error，再调用了Caller(sk)，获取运行时上下文。Caller的原理是调用 runtime.Caller(skip) 方法，以获取指定的代码段位置。最终效果就是通常我们程序报错时，在控制台能够看到的，各个文件的指定行。
在get方法的最后，我们通过 builder.Set(build, col.Name(), value).(builder.Builder) 这样的代码段，将数据对应的名字和值存入指定的builer中。builder的效果类似于map，只是使用builder库可以更方便直接将map转为指定的struct。
再把目光转到selectOne方法，可以看到我们从上下文context中获取了logger和事务tx，这里是方便后续的工作。我们需要注意的是，sqlex库进行sql构建时，严格按照了sql语法的规定，当然where和from之间的顺序在这里可以不用管。我们在初始化selectBuilder的时候， Where("1=1") 给定了一个初始的where条件，这样做的用意是，由于sqlex库提供了IF操作，譬如：
psql.Select("*").From("user").Where(sqlex.IF{Condition: "a" == "", Sq: sqlex.Eq{"a": "3"}})
这样的代码，由于 “a”==“” 不满足，所以IF中的 ”a”==“3” 并不会被纳入构建器中，可是也因为调用了Where，所以构建器中sql中必然会增加一个where，最终得到错误的 sql：SELECT * FROM "user" WHERE 。
编写Model
在 model 目录下新建 user.go 文件：
package model
import (
"context"
"errors"
"github.com/unrotten/builder"
"time"
)
type User struct {
Id int64 `json:"id" db:"id"`
Username string `json:"username" db:"username"`
Email string `json:"email" db:"email"`
Password string `json:"password" db:"password"`
Avatar string `json:"avatar" db:"avatar"`
Gender string `json:"gender" db:"gender"`
Introduce string `json:"introduce" db:"introduce"`
State string `json:"state" db:"state"`
Root bool `json:"root" db:"root"`
CreatedAt time.Time `json:"createdAt" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
DeletedAt time.Time `json:"deletedAt" db:"deleted_at"`
}
func GetUsers(ctx context.Context, where where) ([]User, error) {
result := selectList(ctx, `"user"`, where)
if !result.success {
return nil, errors.New("获取用户列表失败")
}
list, ok := builder.Get(result.b, "list")
if !ok {
return nil, errors.New("获取用户列表失败")
}
users := make([]User, 0, len(list.([]interface{})))
for _, item := range list.([]interface{}) {
users = append(users, builder.GetStructLikeByTag(item.(builder.Builder), User{}, "db").(User))
}
return users, nil
}
func GetUser(ctx context.Context, where where) (User, error) {
result := selectOne(ctx, `"user"`, where)
if !result.success {
return User{}, errors.New("查询用户数据失败")
}
return builder.GetStructLikeByTag(result.b, User{}, "db").(User), nil
}
func InsertUser(ctx context.Context, cv map[string]interface{}) (User, error) {
id, err := idfetcher.NextID()
if err != nil {
return User{}, err
}
cv["id"] = int64(id)
result := insertOne(ctx, `"user"`, cv)
if !result.success {
return User{}, errors.New("插入用户数据失败")
}
return builder.GetStructLikeByTag(result.b, User{}, "db").(User), nil
}
func UpdateUser(ctx context.Context, cv cv, where where) error {
result := update(ctx, `"user"`, cv, where)
if !result.success {
return errors.New("更新用户数据失败")
}
return nil
}
这里唯一需要注意的是，我们使用 builder.GetStructLikeByTag(result.b, User{}, "db").(User) 方法，将CURD中获得的Builder根据指定的tag内容，转化为对应结构体。
接下来，就是继续完善其他的model。
userCount.go :
package model
import (
"context"
"errors"
"github.com/unrotten/builder"
"github.com/unrotten/sqlex"
"time"
)
type UserCount struct {
Uid int64 `json:"uid" db:"uid"`
FansNum int32 `json:"fansNum" db:"fans_num"`
FollowNum int32 `json:"followNum" db:"follow_num"`
ArticleNum int32 `json:"articleNum" db:"article_num"`
Words int32 `json:"words" db:"words"`
ZanNum int32 `json:"zanNum" db:"zan_num"`
CreatedAt time.Time `json:"createdAt" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
DeletedAt time.Time `json:"deletedAt" db:"deleted_at"`
}
func GetUserCount(ctx context.Context, uid int64, columns ...string) (UserCount, error) {
result := selectOne(ctx, "user_count", append(where{}, sqlex.Eq{"uid": uid}), columns...)
if !result.success {
return UserCount{}, errors.New("查询用户计数失败")
}
return builder.GetStructLikeByTag(result.b, UserCount{}, "db").(UserCount), nil
}
func InsertUserCount(ctx context.Context, uid int64) error {
result := insertOne(ctx, "user_count", cv{"uid": uid})
if !result.success {
return errors.New("保存用户计数表失败")
}
return nil
}
func UpdateUserCount(ctx context.Context, uid int64, add bool, columns ...string) error {
directSets, directSet := make([]string, 0, len(columns)), " + 1"
if !add {
directSet = " - 1"
}
for _, col := range columns {
directSets = append(directSets, col+directSet)
}
if !update(ctx, "user_count", cv{}, where{sqlex.Eq{"uid": uid}}, directSets...).success {
return errors.New("增加用户计数失败")
}
return nil
}
我们为了改变userCount中的计数值，定义了方法UpdateUserCount。可以通过指定加减和相应字段来实现计数值的加减。我们可以注意到了，这里在调用update的时候，传入了directSets，最终将通过update中的：
for _, set := range directSet {
updateBuilder = updateBuilder.DirectSet(set)
}
将设置好的值构建到SQL中。DirectSet目的是构建无参数的set语句，所以并不建议暴露给从接口传入的参数，否则会有SQL注入的风险。
userFollow.go ：
package model
import (
"context"
"errors"
"github.com/unrotten/builder"
"github.com/unrotten/sqlex"
"time"
)
type UserFollow struct {
Id int64 `json:"id" db:"id"`
Uid int64 `json:"uid" db:"uid"`
Fuid int64 `json:"fuid" db:"fuid"`
CreatedAt time.Time `json:"createdAt" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
DeletedAt time.Time `json:"deletedAt" db:"deleted_at"`
}
func InsertUserFollow(ctx context.Context, uid, fuid int64) error {
id, err := idfetcher.NextID()
if err != nil {
return err
}
if result := insertOne(ctx, "user_follow", cv{"id": int64(id), "uid": uid, "fuid": fuid}); !result.success {
return errors.New("插入用户关注表失败")
}
return nil
}
func RemoveUserFollow(ctx context.Context, uid, fuid int64) error {
if !remove(ctx, "user_follow", where{sqlex.Eq{"uid": uid, "fuid": fuid}}).success {
return errors.New("删除用户关注失败")
}
return nil
}
// 获取用户关注列表
func GetUserFollowList(ctx context.Context, fuid int64) ([]int64, error) {
result := selectList(ctx, "user_follow", where{sqlex.Eq{"fuid": fuid}}, "uid")
if !result.success {
return nil, errors.New("获取用户关注列表失败")
}
b, _ := builder.Get(result.b, "list")
list := b.([]interface{})
userList := make([]int64, 0, len(list))
for _, item := range list {
uid, _ := builder.Get(item.(builder.Builder), "uid")
userList = append(userList, uid.(int64))
}
return userList, nil
}
// 获取用户粉丝列表
func GetFollowUserList(ctx context.Context, uid int64) ([]int64, error) {
result := selectList(ctx, "user_follow", where{sqlex.Eq{"uid": uid}}, "fuid")
if !result.success {
return nil, errors.New("获取用户关注列表失败")
}
b, _ := builder.Get(result.b, "list")
list := b.([]interface{})
userList := make([]int64, 0, len(list))
for _, item := range list {
uid, _ := builder.Get(item.(builder.Builder), "fuid")
userList = append(userList, uid.(int64))
}
return userList, nil
}
在这里无论是粉丝列表还是关注列表，我们都指定了获取对应的userId列表，而非UserFollow数组。这是为了便于后续dataloader的使用，以后会提到。
到这里用户相关的model就编写完了，后面真正与前端一起联调时，定还有许多更改。而其他诸如文章，评论等的model，便不再赘述。用户相关的model，已经将基本的CURD涵盖。
看完这里，我们可以发现，对于user的扩展表user_count 和 user_follow, 我们并没有在model层面去设计他们的关系，在数据的获取，新增，修改上，也都是独立的。这是因为我们所有定义的数据之间的关系，都交由GraphQL去描述了，在数据层我们反而不用多在意这些关系的实现。
作者个人博客地址： https://unrotten.org
作者微信公众号地址：
About The Author
