goctl added

2020-07-29 17:11:41 +08:00
parent b1975d29a7
commit 121323b8c3
142 changed files with 10690 additions and 0 deletions
--- a/tools/goctl/model/sql/README.MD
+++ b/tools/goctl/model/sql/README.MD
@@ -0,0 +1,430 @@
+<div style="text-align: center;"><h1>Sql生成工具说明文档</h1></div>
+
+<h2>前言</h2>
+在当前Sql代码生成工具是基于sqlc生成的逻辑。
+
+<h2>关键字</h2>
+
+ 查询类型(前暂不支持同一字段多种类型混合生成，如按照campus_id查询单结果又查询All或者Limit)
+  - 单结果查询
+    - FindOne(主键特有)
+    - FindOneByXxx
+  - 多结果查询
+    - FindAllByXxx
+    - FindLimitByXxx
+- withCache
+- withoutCache
+
+<h2>准备工作</h2>
+
+- table
+
+    ```
+    CREATE TABLE `user_info` (
+    `id` bigint(20) NOT NULL COMMENT '主键',
+    `campus_id` bigint(20) DEFAULT NULL COMMENT '整校id',
+    `name` varchar(255) DEFAULT NULL COMMENT '用户姓名',
+    `id_number` varchar(255) DEFAULT NULL COMMENT '身份证',
+    `age` int(10) DEFAULT NULL COMMENT '年龄',
+    `gender` tinyint(1) DEFAULT NULL COMMENT '性别，0-男，1-女，2-不限',
+    `mobile` varchar(20) DEFAULT NULL COMMENT '手机号',
+    `create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+    `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+    PRIMARY KEY (`id`)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+    ```
+
+<h2>imports生成</h2>
+imports代码生成对应model中包的引入管理，仅使用于晓黑板项目中（非相对路径动态生成），目前受`withCache`参数的影响，除此之外其实为固定代码。
+
+- withCache
+  
+    ```
+    import (
+        "database/sql""fmt"
+        "strings"
+        "time"
+
+        "zero/core/stores/sqlc"
+        "zero/core/stores/sqlx"
+        "zero/core/stringx"
+        "xiao/service/shared/builderx"
+    )
+    ```
+
+- withoutCache
+  
+    ```
+    import (
+        "database/sql""fmt"
+        "strings"
+        "time"
+
+        "zero/core/stores/sqlx"
+        "zero/core/stringx"
+        "xiao/service/shared/builderx"
+    )
+    ```
+
+<h2>vars生成</h2>
+
+vars部分对应model中var声明的包含的代码块,由`table`名和`withCache`来决定其中的代码生成内容，`withCache`决定是否要生成缓存key变量的声明。
+
+- withCache
+
+    ```
+    var (
+        UserInfoFieldNames          = builderx.FieldNames(&UserInfo{})
+        UserInfoRows                = strings.Join(UserInfoFieldNames, ",")
+        UserInfoRowsExpectAutoSet   = strings.Join(stringx.Remove(UserInfoFieldNames, "id", "create_time", "update_time"), ",")
+        UserInfoRowsWithPlaceHolder = strings.Join(stringx.Remove(UserInfoFieldNames, "id", "create_time", "update_time"), "=?,") + "=?"
+    
+        cacheUserInfoIdPrefix = "cache#userInfo#id#"
+        cacheUserInfoCampusIdPrefix = "cache#userInfo#campusId#"
+        cacheUserInfoNamePrefix = "cache#userInfo#name#"
+        cacheUserInfoMobilePrefix = "cache#userInfo#mobile#"
+    )
+    ```
+
+- withoutCache
+
+    ```
+    var (
+        UserInfoFieldNames          = builderx.FieldNames(&UserInfo{})
+        UserInfoRows                = strings.Join(UserInfoFieldNames, ",")
+        UserInfoRowsExpectAutoSet   = strings.Join(stringx.Remove(UserInfoFieldNames, "id", "create_time", "update_time"), ",")
+        UserInfoRowsWithPlaceHolder = strings.Join(stringx.Remove(UserInfoFieldNames, "id", "create_time", "update_time"), "=?,") + "=?"
+    )
+    ```
+
+<h2>types生成</h2>
+
+ypes部分对应model中type声明的包含的代码块,由`table`名和`withCache`来决定其中的代码生成内容，`withCache`决定引入sqlc还是sqlx。
+
+- withCache
+    ```
+    type (
+        UserInfoModel struct {
+            conn  sqlc.CachedConn
+            table string
+        }
+
+        UserInfo struct {
+            Id int64 `db:"id"` // 主键id
+            CampusId int64 `db:"campus_id"` // 整校id
+            Name string `db:"name"` // 用户姓名
+            IdNumber string `db:"id_number"` // 身份证
+            Age int64 `db:"age"` // 年龄
+            Gender int64 `db:"gender"` // 性别，0-男，1-女，2-不限
+            Mobile string `db:"mobile"` // 手机号
+            CreateTime time.Time `db:"create_time"` // 创建时间
+            UpdateTime time.Time `db:"update_time"` // 更新时间
+        }
+    )    
+    ```
+
+- withoutCache
+    ```
+    type (
+        UserInfoModel struct {
+            conn  sqlx.SqlConn
+            table string
+        }
+
+        UserInfo struct {
+            Id int64 `db:"id"` // 主键id
+            CampusId int64 `db:"campus_id"` // 整校id
+            Name string `db:"name"` // 用户姓名
+            IdNumber string `db:"id_number"` // 身份证
+            Age int64 `db:"age"` // 年龄
+            Gender int64 `db:"gender"` // 性别，0-男，1-女，2-不限
+            Mobile string `db:"mobile"` // 手机号
+            CreateTime time.Time `db:"create_time"` // 创建时间
+            UpdateTime time.Time `db:"update_time"` // 更新时间
+        }
+    )
+    ```
+<h2>New生成</h2>
+new生成对应model中struct的New函数，受`withCache`影响决定是否要引入cacheRedis
+
+- withCache
+    ```
+    func NewUserInfoModel(conn sqlx.SqlConn, c cache.CacheConf, table string) *UserInfoModel {
+        return &UserInfoModel{
+            CachedConn: sqlc.NewConn(conn, c),
+            table:      table,
+        }
+    }
+    ```
+- withoutCache
+    ```
+    func NewUserInfoModel(conn sqlx.SqlConn, table string) *UserInfoModel {
+	    return &UserInfoModel{conn: conn, table: table}
+    }
+    ```
+
+
+<h2>FindOne查询生成</h2>
+FindOne查询代码生成仅对主键有效。如`user_info`中生成的FindOne如下：
+
+- withCache
+
+    ```
+    func (m *UserInfoModel) FindOne(id int64) (*UserInfo, error) {
+        idKey := fmt.Sprintf("%s%v", cacheUserInfoIdPrefix, id)
+        var resp UserInfo
+        err := m.QueryRow(&resp, idKey, func(conn sqlx.SqlConn, v interface{}) error {
+            query := `select ` + userInfoRows + ` from ` + m.table  + `where id = ? limit 1`
+            return conn.QueryRow(v, query, id)
+        })
+        switch err {
+        case nil:
+            return &resp, nil
+        case sqlc.ErrNotFound:
+            return nil, ErrNotFound
+        default:
+            return nil, err
+        }
+    }
+    ```
+
+- withoutCache
+
+    ```
+    func (m *UserInfoModel) FindOne(id int64) (*UserInfo, error) {
+        
+        query := `select ` + userInfoRows + ` from ` + m.table  + `where id = ? limit 1`
+        var resp UserInfo
+        err := m.conn.QueryRow(&resp, query, id)
+        switch err {
+        case nil:
+            return &resp, nil
+        case sqlx.ErrNotFound:
+            return nil, ErrNotFound
+        default:
+            return nil, err
+        
+    }
+    ```
+
+<h2>FindOneByXxx查询生成</h2>
+
+FindOneByXxx查询生成可以按照单个字段查询、多个字段以AND关系且表达式符号为`=`的查询（下称：组合查询）,对除主键之外的字段有效，对于单个字段可以用`withCache`来控制是否需要缓存，这里的缓存只缓存主键，并不缓存整个struct，注意：这里有一个隐藏的规则，如果单个字段查询需要cache，那么主键一定有cache；多个字段组成的`组合查询`一律没有缓存处理,<strong><i>且组合查询不能相互嵌套</i></strong>，否则会报`circle query with other fields`错误，下面我们按场景来依次查看对应代码生成后的示例。
+
+>注：目前暂不支持除equals之外的条件查询。
+
+ 单字段查询  
+    以name查询为例
+    - withCache
+        ```
+        func (m *UserInfoModel) FindOneByName(name string) (*UserInfo, error) {
+            nameKey := fmt.Sprintf("%s%v", cacheUserInfoNamePrefix, name)
+            var id string
+            err := m.GetCache(key, &id)
+            if err != nil {
+                return nil, err
+            }
+            if id != "" {
+                return m.FindOne(id)
+            }
+            var resp UserInfo
+            query := `select ` + userInfoRows + ` from ` + m.table  + `where name = ? limit 1`
+            err = m.QueryRowNoCache(&resp, query, name)
+            switch err {
+            case nil:
+                err = m.SetCache(nameKey, resp.Id)
+                if err != nil {
+                    logx.Error(err)
+                }
+                return &resp, nil
+            case sqlc.ErrNotFound:
+                return nil, ErrNotFound
+            default:
+                return nil, err
+            }
+        }    
+        ```
+    - withoutCache
+
+        ```
+        func (m *UserInfoModel) FindOneByName(name string) (*UserInfo, error) {
+            var resp UserInfo
+            query := `select ` + userInfoRows + ` from ` + m.table  + `where name = ? limit 1`
+            err = m.conn.QueryRow(&resp, query, name)
+            switch err {
+            case nil:
+                return &resp, nil
+            case sqlx.ErrNotFound:
+                return nil, ErrNotFound
+            default:
+                return nil, err
+            }
+        }
+        ```
+
+- 组合查询  
+    以`campus_id`和`id_number`查询为例。
+    
+        ```
+        func (m *UserInfoModel) FindOneByCampusIdAndIdNumber(campusId int64,idNumber string) (*UserInfo, error) {
+            var resp UserInfo
+            query := `select ` + userInfoRows + ` from ` + m.table  + `where campus_id = ? AND id_number = ? limit 1`
+            err = m.QueryRowNoCache(&resp, query, campusId, idNumber)
+            // err = m.conn.QueryRows(&resp, query, campusId, idNumber)
+            switch err {
+            case nil:
+                return &resp, nil
+            case sqlx.ErrNotFound:
+                return nil, ErrNotFound
+            default:
+                return nil, err
+            }
+        }
+        ```
+<h2>FindAllByXxx生成</h2>
+FindAllByXxx查询和FindOneByXxx功能相似，只是FindOneByXxx限制了limit等于1，而FindAllByXxx是查询所有,以两个例子来说明
+
+- 查询单个字段`name`等于某值的所有数据
+    ```
+    func (m *UserInfoModel) FindAllByName(name string) ([]*UserInfo, error) {
+        var resp []*UserInfo
+        query := `select ` + userInfoRows + ` from ` + m.table  + `where name = ?`
+        err := m.QueryRowsNoCache(&resp, query, name)
+        // err := m.conn.QueryRows(&resp, query, name)
+        if err != nil {
+            return nil, err
+        }
+        return resp, nil
+    }    
+    ```
+- 查询多个组合字段`campus_id`等于某值且`gender`等于某值的所有数据
+    ```
+    func (m *UserInfoModel) FindAllByCampusIdAndGender(campusId int64,gender int64) ([]*UserInfo, error) {
+        var resp []*UserInfo
+        query := `select ` + userInfoRows + ` from ` + m.table  + `where campus_id = ? AND gender = ?`
+        err := m.QueryRowsNoCache(&resp, query, campusId, gender)
+        // err := m.conn.QueryRows(&resp, query, campusId, gender)
+        if err != nil {
+            return nil, err
+        }
+        return resp, nil
+    }    
+    ```
+
+<h2>FindLimitByXxx生成</h2>
+FindLimitByXxx查询和FindAllByXxx功能相似，只是FindAllByXxx限制了limit，除此之外还会生成查询对应Count总数的代码，而FindAllByXxx是查询所有数据,以几个例子来说明
+
+- 查询`gender`等于某值的分页数据，按照`create_time`降序
+    ```
+    func (m *UserInfoModel) FindLimitByGender(gender int64, page, limit int) ([]*UserInfo, error) {
+        var resp []*UserInfo
+        query := `select ` + userInfoRows + `from ` + m.table  + `where gender = ? order by create_time DESC limit ?,?`
+        err := m.QueryRowsNoCache(&resp, query, gender, (page-1)*limit, limit)
+        // err := m.conn.QueryRows(&resp, query, gender, (page-1)*limit, limit)
+        if err != nil {
+            return nil, err
+        }
+        return resp, nil
+    }
+
+    func (m *UserInfoModel) FindAllCountByGender(gender int64) (int64, error) {
+        var count int64
+        query := `select count(1)  from ` + m.table  + `where gender = ? `
+        err := m.QueryRowsNoCache(&count, query, gender)
+        // err := m.conn.QueryRow(&count, query, gender)
+        if err != nil {
+            return 0, err
+        }
+        return count, nil
+    }       
+    ```
+- 查询`gender`等于某值的分页数据，按照`create_time`降序、`update_time`生序排序
+    ```
+    func (m *UserInfoModel) FindLimitByGender(gender int64, page, limit int) ([]*UserInfo, error) {
+        var resp []*UserInfo
+        query := `select ` + userInfoRows + `from ` + m.table  + `where gender = ? order by create_time DESC,update_time ASC limit ?,?`
+        err := m.QueryRowsNoCache(&resp, query, gender, (page-1)*limit, limit)
+       // err := m.conn.QueryRows(&resp, query, gender, (page-1)*limit, limit)
+        if err != nil {
+            return nil, err
+        }
+        return resp, nil
+    }
+
+    func (m *UserInfoModel) FindAllCountByGender(gender int64) (int64, error) {
+        var count int64
+        query := `select count(1)  from ` + m.table  + `where gender = ? `
+        err := m.QueryRowNoCache(&count, query, gender)
+        // err := m.conn.QueryRow(&count, query, gender)
+        if err != nil {
+            return 0, err
+        }
+        return count, nil
+    }          
+    ```
+- 查询`gender`等于某值且`campus_id`为某值按照`create_time`降序的分页数据
+    ```
+    func (m *UserInfoModel) FindLimitByGenderAndCampusId(gender int64,campusId int64, page, limit int) ([]*UserInfo, error) {
+        var resp []*UserInfo
+        query := `select ` + userInfoRows + `from ` + m.table  + `where gender = ? AND campus_id = ? order by create_time DESC limit ?,?`
+        err := m.QueryRowsNoCache(&resp, query, gender, campusId, (page-1)*limit, limit)
+        // err := m.conn.QueryRows(&resp, query, gender, campusId, (page-1)*limit, limit)
+        if err != nil {
+            return nil, err
+        }
+        return resp, nil
+    }
+
+    func (m *UserInfoModel) FindAllCountByGenderAndCampusId(gender int64,campusId int64) (int64, error) {
+        var count int64
+        query := `select count(1)  from ` + m.table  + `where gender = ? AND campus_id = ? `
+        err := m.QueryRowsNoCache(&count, query, gender, campusId)
+        // err := m.conn.QueryRow(&count, query, gender, campusId)
+        if err != nil {
+            return 0, err
+        }
+        return count, nil
+    }      
+    ```
+
+<h2>Delete生成</h2>
+Delete代码根据`withCache`的不同可以生成带缓存逻辑代码和不带缓存逻辑代码，<strong><i>Delete代码生成仅按照主键删除</i></strong>。从FindOneByXxx方法描述得知，非主键`withCache`了那么主键会强制被cache，因此在delete时也会删除主键cache。
+
+- withCache  
+  根据`mobile`查询用户信息
+
+    ```
+    func (m *UserInfoModel) Delete(userId int64) error {
+        userIdKey := fmt.Sprintf("%s%v", cacheUserInfoUserIdPrefix, userId)
+        mobileKey := fmt.Sprintf("%s%v", cacheUserInfoMobilePrefix, mobile)
+        _, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+            query := `delete from ` + m.table +  + `where user_id = ?`
+            return conn.Exec(query, userId)
+        }, userIdKey, mobileKey)
+        return err
+        }
+    ```
+- withoutCache
+    ```
+    func (m *UserInfoModel) Delete(userId int64) error {
+	_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+		query := `delete from ` + m.table +  + `where user_id = ?`
+		return conn.Exec(query, userId)
+	}, )
+	return err
+}
+    ```
+<h2>Insert生成</h2>
+
+<h2>Update生成</h2>
+
+<h2>待完善（TODO）</h2>
+
+- 同一字段多种查询方式代码生成(优先级较高)
+- 条件查询
+- 范围查询
+- ...
+
+<h2>反馈与建议</h2>
+
+- 无
--- a/tools/goctl/model/sql/gen/convert.go
+++ b/tools/goctl/model/sql/gen/convert.go
@@ -0,0 +1,108 @@
+package gen
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"zero/tools/goctl/model/sql/util"
+)
+
+func TableConvert(outerTable OuterTable) (*InnerTable, error) {
+	var table InnerTable
+	table.CreateNotFound = outerTable.CreateNotFound
+	tableSnakeCase, tableUpperCamelCase, tableLowerCamelCase := util.FormatField(outerTable.Table)
+	table.SnakeCase = tableSnakeCase
+	table.UpperCamelCase = tableUpperCamelCase
+	table.LowerCamelCase = tableLowerCamelCase
+	fields := make([]*InnerField, 0)
+	var primaryField *InnerField
+	conflict := make(map[string]struct{})
+	var containsCache bool
+	for _, field := range outerTable.Fields {
+		if field.Cache && !containsCache {
+			containsCache = true
+		}
+		fieldSnakeCase, fieldUpperCamelCase, fieldLowerCamelCase := util.FormatField(field.Name)
+		tag, err := genTag(fieldSnakeCase)
+		if err != nil {
+			return nil, err
+		}
+		var comment string
+		if field.Comment != "" {
+			comment = fmt.Sprintf("// %s", field.Comment)
+		}
+		withFields := make([]InnerWithField, 0)
+		unique := make([]string, 0)
+		unique = append(unique, fmt.Sprintf("%v", field.QueryType))
+		unique = append(unique, field.Name)
+
+		for _, item := range field.WithFields {
+			unique = append(unique, item.Name)
+			withFieldSnakeCase, withFieldUpperCamelCase, withFieldLowerCamelCase := util.FormatField(item.Name)
+			withFields = append(withFields, InnerWithField{
+				Case: Case{
+					SnakeCase:      withFieldSnakeCase,
+					LowerCamelCase: withFieldLowerCamelCase,
+					UpperCamelCase: withFieldUpperCamelCase,
+				},
+				DataType: commonMysqlDataTypeMap[item.DataBaseType],
+			})
+		}
+		sort.Strings(unique)
+		uniqueKey := strings.Join(unique, "#")
+		if _, ok := conflict[uniqueKey]; ok {
+			return nil, ErrCircleQuery
+		} else {
+			conflict[uniqueKey] = struct{}{}
+		}
+		sortFields := make([]InnerSort, 0)
+		for _, sortField := range field.OuterSort {
+			sortSnake, sortUpperCamelCase, sortLowerCamelCase := util.FormatField(sortField.Field)
+			sortFields = append(sortFields, InnerSort{
+				Field: Case{
+					SnakeCase:      sortSnake,
+					LowerCamelCase: sortUpperCamelCase,
+					UpperCamelCase: sortLowerCamelCase,
+				},
+				Asc: sortField.Asc,
+			})
+		}
+		innerField := &InnerField{
+			IsPrimaryKey: field.IsPrimaryKey,
+			InnerWithField: InnerWithField{
+				Case: Case{
+					SnakeCase:      fieldSnakeCase,
+					LowerCamelCase: fieldLowerCamelCase,
+					UpperCamelCase: fieldUpperCamelCase,
+				},
+				DataType: commonMysqlDataTypeMap[field.DataBaseType],
+			},
+			DataBaseType: field.DataBaseType,
+			Tag:          tag,
+			Comment:      comment,
+			Cache:        field.Cache,
+			QueryType:    field.QueryType,
+			WithFields:   withFields,
+			Sort:         sortFields,
+		}
+		if field.IsPrimaryKey {
+			primaryField = innerField
+		}
+		fields = append(fields, innerField)
+	}
+	if primaryField == nil {
+		return nil, errors.New("please ensure that primary exists")
+	}
+	table.ContainsCache = containsCache
+	primaryField.Cache = containsCache
+	table.PrimaryField = primaryField
+	table.Fields = fields
+	cacheKey, err := genCacheKeys(&table)
+	if err != nil {
+		return nil, err
+	}
+	table.CacheKey = cacheKey
+	return &table, nil
+}
--- a/tools/goctl/model/sql/gen/delete.go
+++ b/tools/goctl/model/sql/gen/delete.go
@@ -0,0 +1,51 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genDelete(table *InnerTable) (string, error) {
+	t, err := template.New("delete").Parse(sqltemplate.Delete)
+	if err != nil {
+		return "", nil
+	}
+	deleteBuffer := new(bytes.Buffer)
+	keys := make([]string, 0)
+	keyValues := make([]string, 0)
+	for snake, key := range table.CacheKey {
+		if snake == table.PrimaryField.SnakeCase {
+			keys = append(keys, key.Key)
+		} else {
+			keys = append(keys, key.DataKey)
+		}
+		keyValues = append(keyValues, key.KeyVariable)
+	}
+	var isOnlyPrimaryKeyCache = true
+	for _, item := range table.Fields {
+		if item.IsPrimaryKey {
+			continue
+		}
+		if item.Cache {
+			isOnlyPrimaryKeyCache = false
+			break
+		}
+	}
+	err = t.Execute(deleteBuffer, map[string]interface{}{
+		"upperObject":     table.UpperCamelCase,
+		"containsCache":   table.ContainsCache,
+		"isNotPrimaryKey": !isOnlyPrimaryKeyCache,
+		"lowerPrimaryKey": table.PrimaryField.LowerCamelCase,
+		"dataType":        table.PrimaryField.DataType,
+		"keys":            strings.Join(keys, "\r\n"),
+		"snakePrimaryKey": table.PrimaryField.SnakeCase,
+		"keyValues":       strings.Join(keyValues, ", "),
+	})
+	if err != nil {
+		return "", err
+	}
+	return deleteBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/error.go
+++ b/tools/goctl/model/sql/gen/error.go
@@ -0,0 +1,7 @@
+package gen
+
+import "errors"
+
+var (
+	ErrCircleQuery = errors.New("circle query with other fields")
+)
--- a/tools/goctl/model/sql/gen/field.go
+++ b/tools/goctl/model/sql/gen/field.go
@@ -0,0 +1,39 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genFields(fields []*InnerField) (string, error) {
+	list := make([]string, 0)
+	for _, field := range fields {
+		result, err := genField(field)
+		if err != nil {
+			return "", err
+		}
+		list = append(list, result)
+	}
+	return strings.Join(list, "\r\n"), nil
+}
+
+func genField(field *InnerField) (string, error) {
+	t, err := template.New("types").Parse(sqltemplate.Field)
+	if err != nil {
+		return "", nil
+	}
+	var typeBuffer = new(bytes.Buffer)
+	err = t.Execute(typeBuffer, map[string]string{
+		"name":    field.UpperCamelCase,
+		"type":    field.DataType,
+		"tag":     field.Tag,
+		"comment": field.Comment,
+	})
+	if err != nil {
+		return "", err
+	}
+	return typeBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/findallbyfield.go
+++ b/tools/goctl/model/sql/gen/findallbyfield.go
@@ -0,0 +1,55 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genFindAllByField(table *InnerTable) (string, error) {
+	t, err := template.New("findAllByField").Parse(sqltemplate.FindAllByField)
+	if err != nil {
+		return "", err
+	}
+	list := make([]string, 0)
+	for _, field := range table.Fields {
+		if field.IsPrimaryKey {
+			continue
+		}
+		if field.QueryType != QueryAll {
+			continue
+		}
+		fineOneByFieldBuffer := new(bytes.Buffer)
+		upperFields := make([]string, 0)
+		in := make([]string, 0)
+		expressionFields := make([]string, 0)
+		expressionValuesFields := make([]string, 0)
+		upperFields = append(upperFields, field.UpperCamelCase)
+		in = append(in, field.LowerCamelCase+" "+field.DataType)
+		expressionFields = append(expressionFields, field.SnakeCase+" = ?")
+		expressionValuesFields = append(expressionValuesFields, field.LowerCamelCase)
+		for _, withField := range field.WithFields {
+			upperFields = append(upperFields, withField.UpperCamelCase)
+			in = append(in, withField.LowerCamelCase+" "+withField.DataType)
+			expressionFields = append(expressionFields, withField.SnakeCase+" = ?")
+			expressionValuesFields = append(expressionValuesFields, withField.LowerCamelCase)
+		}
+		err = t.Execute(fineOneByFieldBuffer, map[string]interface{}{
+			"in":               strings.Join(in, ","),
+			"upperObject":      table.UpperCamelCase,
+			"upperFields":      strings.Join(upperFields, "And"),
+			"lowerObject":      table.LowerCamelCase,
+			"snakePrimaryKey":  field.SnakeCase,
+			"expression":       strings.Join(expressionFields, " AND "),
+			"expressionValues": strings.Join(expressionValuesFields, ", "),
+			"containsCache":    table.ContainsCache,
+		})
+		if err != nil {
+			return "", err
+		}
+		list = append(list, fineOneByFieldBuffer.String())
+	}
+	return strings.Join(list, ""), nil
+}
--- a/tools/goctl/model/sql/gen/findallbylimit.go
+++ b/tools/goctl/model/sql/gen/findallbylimit.go
@@ -0,0 +1,63 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genFindLimitByField(table *InnerTable) (string, error) {
+	t, err := template.New("findLimitByField").Parse(sqltemplate.FindLimitByField)
+	if err != nil {
+		return "", err
+	}
+	list := make([]string, 0)
+	for _, field := range table.Fields {
+		if field.IsPrimaryKey {
+			continue
+		}
+		if field.QueryType != QueryLimit {
+			continue
+		}
+		fineOneByFieldBuffer := new(bytes.Buffer)
+		upperFields := make([]string, 0)
+		in := make([]string, 0)
+		expressionFields := make([]string, 0)
+		expressionValuesFields := make([]string, 0)
+		upperFields = append(upperFields, field.UpperCamelCase)
+		in = append(in, field.LowerCamelCase+" "+field.DataType)
+		expressionFields = append(expressionFields, field.SnakeCase+" = ?")
+		expressionValuesFields = append(expressionValuesFields, field.LowerCamelCase)
+		for _, withField := range field.WithFields {
+			upperFields = append(upperFields, withField.UpperCamelCase)
+			in = append(in, withField.LowerCamelCase+" "+withField.DataType)
+			expressionFields = append(expressionFields, withField.SnakeCase+" = ?")
+			expressionValuesFields = append(expressionValuesFields, withField.LowerCamelCase)
+		}
+		sortList := make([]string, 0)
+		for _, item := range field.Sort {
+			var sort = "ASC"
+			if !item.Asc {
+				sort = "DESC"
+			}
+			sortList = append(sortList, item.Field.SnakeCase+" "+sort)
+		}
+		err = t.Execute(fineOneByFieldBuffer, map[string]interface{}{
+			"in":               strings.Join(in, ","),
+			"upperObject":      table.UpperCamelCase,
+			"upperFields":      strings.Join(upperFields, "And"),
+			"lowerObject":      table.LowerCamelCase,
+			"expression":       strings.Join(expressionFields, " AND "),
+			"expressionValues": strings.Join(expressionValuesFields, ", "),
+			"sortExpression":   strings.Join(sortList, ","),
+			"containsCache":    table.ContainsCache,
+		})
+		if err != nil {
+			return "", err
+		}
+		list = append(list, fineOneByFieldBuffer.String())
+	}
+	return strings.Join(list, ""), nil
+}
--- a/tools/goctl/model/sql/gen/findone.go
+++ b/tools/goctl/model/sql/gen/findone.go
@@ -0,0 +1,30 @@
+package gen
+
+import (
+	"bytes"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genFindOne(table *InnerTable) (string, error) {
+	t, err := template.New("findOne").Parse(sqltemplate.FindOne)
+	if err != nil {
+		return "", err
+	}
+	fineOneBuffer := new(bytes.Buffer)
+	err = t.Execute(fineOneBuffer, map[string]interface{}{
+		"withCache":        table.PrimaryField.Cache,
+		"upperObject":      table.UpperCamelCase,
+		"lowerObject":      table.LowerCamelCase,
+		"snakePrimaryKey":  table.PrimaryField.SnakeCase,
+		"lowerPrimaryKey":  table.PrimaryField.LowerCamelCase,
+		"dataType":         table.PrimaryField.DataType,
+		"cacheKey":         table.CacheKey[table.PrimaryField.SnakeCase].Key,
+		"cacheKeyVariable": table.CacheKey[table.PrimaryField.SnakeCase].KeyVariable,
+	})
+	if err != nil {
+		return "", err
+	}
+	return fineOneBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/fineonebyfield.go
+++ b/tools/goctl/model/sql/gen/fineonebyfield.go
@@ -0,0 +1,67 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genFineOneByField(table *InnerTable) (string, error) {
+	t, err := template.New("findOneByField").Parse(sqltemplate.FindOneByField)
+	if err != nil {
+		return "", err
+	}
+	list := make([]string, 0)
+	for _, field := range table.Fields {
+		if field.IsPrimaryKey {
+			continue
+		}
+		if field.QueryType != QueryOne {
+			continue
+		}
+		fineOneByFieldBuffer := new(bytes.Buffer)
+		upperFields := make([]string, 0)
+		in := make([]string, 0)
+		expressionFields := make([]string, 0)
+		expressionValuesFields := make([]string, 0)
+		upperFields = append(upperFields, field.UpperCamelCase)
+		in = append(in, field.LowerCamelCase+" "+field.DataType)
+		expressionFields = append(expressionFields, field.SnakeCase+" = ?")
+		expressionValuesFields = append(expressionValuesFields, field.LowerCamelCase)
+		for _, withField := range field.WithFields {
+			upperFields = append(upperFields, withField.UpperCamelCase)
+			in = append(in, withField.LowerCamelCase+" "+withField.DataType)
+			expressionFields = append(expressionFields, withField.SnakeCase+" = ?")
+			expressionValuesFields = append(expressionValuesFields, withField.LowerCamelCase)
+		}
+		err = t.Execute(fineOneByFieldBuffer, map[string]interface{}{
+			"in":                    strings.Join(in, ","),
+			"upperObject":           table.UpperCamelCase,
+			"upperFields":           strings.Join(upperFields, "And"),
+			"onlyOneFiled":          len(field.WithFields) == 0,
+			"withCache":             field.Cache,
+			"containsCache":         table.ContainsCache,
+			"lowerObject":           table.LowerCamelCase,
+			"lowerField":            field.LowerCamelCase,
+			"snakeField":            field.SnakeCase,
+			"lowerPrimaryKey":       table.PrimaryField.LowerCamelCase,
+			"UpperPrimaryKey":       table.PrimaryField.UpperCamelCase,
+			"primaryKeyDefine":      table.CacheKey[table.PrimaryField.SnakeCase].Define,
+			"primarySnakeField":     table.PrimaryField.SnakeCase,
+			"primaryDataType":       table.PrimaryField.DataType,
+			"primaryDataTypeString": table.PrimaryField.DataType == "string",
+			"upperObjectKey":        table.PrimaryField.UpperCamelCase,
+			"cacheKey":              table.CacheKey[field.SnakeCase].Key,
+			"cacheKeyVariable":      table.CacheKey[field.SnakeCase].KeyVariable,
+			"expression":            strings.Join(expressionFields, " AND "),
+			"expressionValues":      strings.Join(expressionValuesFields, ", "),
+		})
+		if err != nil {
+			return "", err
+		}
+		list = append(list, fineOneByFieldBuffer.String())
+	}
+	return strings.Join(list, ""), nil
+}
--- a/tools/goctl/model/sql/gen/imports.go
+++ b/tools/goctl/model/sql/gen/imports.go
@@ -0,0 +1,23 @@
+package gen
+
+import (
+	"bytes"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genImports(table *InnerTable) (string, error) {
+	t, err := template.New("imports").Parse(sqltemplate.Imports)
+	if err != nil {
+		return "", err
+	}
+	importBuffer := new(bytes.Buffer)
+	err = t.Execute(importBuffer, map[string]interface{}{
+		"containsCache": table.ContainsCache,
+	})
+	if err != nil {
+		return "", err
+	}
+	return importBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/insert.go
+++ b/tools/goctl/model/sql/gen/insert.go
@@ -0,0 +1,37 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genInsert(table *InnerTable) (string, error) {
+	t, err := template.New("insert").Parse(sqltemplate.Insert)
+	if err != nil {
+		return "", nil
+	}
+	insertBuffer := new(bytes.Buffer)
+	expressions := make([]string, 0)
+	expressionValues := make([]string, 0)
+	for _, filed := range table.Fields {
+		if filed.SnakeCase == "create_time" || filed.SnakeCase == "update_time" || filed.IsPrimaryKey {
+			continue
+		}
+		expressions = append(expressions, "?")
+		expressionValues = append(expressionValues, "data."+filed.UpperCamelCase)
+	}
+	err = t.Execute(insertBuffer, map[string]interface{}{
+		"upperObject":      table.UpperCamelCase,
+		"lowerObject":      table.LowerCamelCase,
+		"expression":       strings.Join(expressions, ", "),
+		"expressionValues": strings.Join(expressionValues, ", "),
+		"containsCache":    table.ContainsCache,
+	})
+	if err != nil {
+		return "", err
+	}
+	return insertBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/keys.go
+++ b/tools/goctl/model/sql/gen/keys.go
@@ -0,0 +1,106 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+)
+
+var (
+	cacheKeyExpressionTemplate = `cache{{.upperCamelTable}}{{.upperCamelField}}Prefix = "cache#{{.lowerCamelTable}}#{{.lowerCamelField}}#"`
+	keyTemplate                = `{{.lowerCamelField}}Key := fmt.Sprintf("%s%v", {{.define}}, {{.lowerCamelField}})`
+	keyRespTemplate            = `{{.lowerCamelField}}Key := fmt.Sprintf("%s%v", {{.define}}, resp.{{.upperCamelField}})`
+	keyDataTemplate            = `{{.lowerCamelField}}Key := fmt.Sprintf("%s%v", {{.define}}, data.{{.upperCamelField}})`
+)
+
+type (
+	Key struct {
+		Define      string // cacheKey define,如：cacheUserUserIdPrefix
+		Value       string // cacheKey value expression,如：cache#user#userId#
+		Expression  string // cacheKey expression，如:cacheUserUserIdPrefix="cache#user#userId#"
+		KeyVariable string // cacheKey 声明变量，如：userIdKey
+		Key         string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, userId)
+		DataKey     string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, data.userId)
+		RespKey     string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, resp.userId)
+	}
+)
+
+// key-数据库原始字段名,value-缓存key对象
+func genCacheKeys(table *InnerTable) (map[string]Key, error) {
+	fields := table.Fields
+	var m = make(map[string]Key)
+	if !table.ContainsCache {
+		return m, nil
+	}
+	for _, field := range fields {
+		if !field.Cache && !field.IsPrimaryKey {
+			continue
+		}
+		t, err := template.New("keyExpression").Parse(cacheKeyExpressionTemplate)
+		if err != nil {
+			return nil, err
+		}
+		var expressionBuffer = new(bytes.Buffer)
+		err = t.Execute(expressionBuffer, map[string]string{
+			"upperCamelTable": table.UpperCamelCase,
+			"lowerCamelTable": table.LowerCamelCase,
+			"upperCamelField": field.UpperCamelCase,
+			"lowerCamelField": field.LowerCamelCase,
+		})
+		if err != nil {
+			return nil, err
+		}
+		expression := expressionBuffer.String()
+		expressionAr := strings.Split(expression, "=")
+		define := strings.TrimSpace(expressionAr[0])
+		value := strings.TrimSpace(expressionAr[1])
+		t, err = template.New("key").Parse(keyTemplate)
+		if err != nil {
+			return nil, err
+		}
+		var keyBuffer = new(bytes.Buffer)
+		err = t.Execute(keyBuffer, map[string]string{
+			"lowerCamelField": field.LowerCamelCase,
+			"define":          define,
+		})
+		if err != nil {
+			return nil, err
+		}
+		t, err = template.New("keyData").Parse(keyDataTemplate)
+		if err != nil {
+			return nil, err
+		}
+		var keyDataBuffer = new(bytes.Buffer)
+		err = t.Execute(keyDataBuffer, map[string]string{
+			"lowerCamelField": field.LowerCamelCase,
+			"upperCamelField": field.UpperCamelCase,
+			"define":          define,
+		})
+		if err != nil {
+			return nil, err
+		}
+		t, err = template.New("keyResp").Parse(keyRespTemplate)
+		if err != nil {
+			return nil, err
+		}
+		var keyRespBuffer = new(bytes.Buffer)
+		err = t.Execute(keyRespBuffer, map[string]string{
+			"lowerCamelField": field.LowerCamelCase,
+			"upperCamelField": field.UpperCamelCase,
+			"define":          define,
+		})
+		if err != nil {
+			return nil, err
+		}
+		m[field.SnakeCase] = Key{
+			Define:      define,
+			Value:       value,
+			Expression:  expression,
+			KeyVariable: field.LowerCamelCase + "Key",
+			Key:         keyBuffer.String(),
+			DataKey:     keyDataBuffer.String(),
+			RespKey:     keyRespBuffer.String(),
+		}
+	}
+	return m, nil
+}
--- a/tools/goctl/model/sql/gen/keys_test.go
+++ b/tools/goctl/model/sql/gen/keys_test.go
@@ -0,0 +1,100 @@
+package gen
+
+import (
+	"log"
+	"testing"
+
+	"zero/core/logx"
+)
+
+func TestKeys(t *testing.T) {
+	var table = OuterTable{
+		Table:          "user_info",
+		CreateNotFound: true,
+		Fields: []*OuterFiled{
+			{
+				IsPrimaryKey: true,
+				Name:         "user_id",
+				DataBaseType: "bigint",
+				Comment:      "主键id",
+			},
+			{
+				Name:         "campus_id",
+				DataBaseType: "bigint",
+				Comment:      "整校id",
+				QueryType:    QueryAll,
+				Cache:        false,
+			},
+			{
+				Name:         "name",
+				DataBaseType: "varchar",
+				Comment:      "用户姓名",
+				QueryType:    QueryOne,
+			},
+			{
+				Name:         "id_number",
+				DataBaseType: "varchar",
+				Comment:      "身份证",
+				Cache:        false,
+				QueryType:    QueryNone,
+				WithFields: []OuterWithField{
+					{
+						Name:         "name",
+						DataBaseType: "varchar",
+					},
+				},
+			},
+			{
+				Name:         "age",
+				DataBaseType: "int",
+				Comment:      "年龄",
+				Cache:        false,
+				QueryType:    QueryNone,
+			},
+			{
+				Name:         "gender",
+				DataBaseType: "tinyint",
+				Comment:      "性别，0-男，1-女，2-不限",
+				QueryType:    QueryLimit,
+				WithFields: []OuterWithField{
+					{
+						Name:         "campus_id",
+						DataBaseType: "bigint",
+					},
+				},
+				OuterSort: []OuterSort{
+					{
+						Field: "create_time",
+						Asc:   false,
+					},
+				},
+			},
+			{
+				Name:         "mobile",
+				DataBaseType: "varchar",
+				Comment:      "手机号",
+				QueryType:    QueryOne,
+				Cache:        true,
+			},
+			{
+				Name:         "create_time",
+				DataBaseType: "timestamp",
+				Comment:      "创建时间",
+			},
+			{
+				Name:         "update_time",
+				DataBaseType: "timestamp",
+				Comment:      "更新时间",
+			},
+		},
+	}
+	innerTable, err := TableConvert(table)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	tp, err := GenModel(innerTable)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	logx.Info(tp)
+}
--- a/tools/goctl/model/sql/gen/model.go
+++ b/tools/goctl/model/sql/gen/model.go
@@ -0,0 +1,86 @@
+package gen
+
+import (
+	"bytes"
+	"go/format"
+	"strings"
+	"text/template"
+
+	"zero/core/logx"
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func GenModel(table *InnerTable) (string, error) {
+	t, err := template.New("model").Parse(sqltemplate.Model)
+	if err != nil {
+		return "", nil
+	}
+	modelBuffer := new(bytes.Buffer)
+	importsCode, err := genImports(table)
+	if err != nil {
+		return "", err
+	}
+	varsCode, err := genVars(table)
+	if err != nil {
+		return "", err
+	}
+	typesCode, err := genTypes(table)
+	if err != nil {
+		return "", err
+	}
+	newCode, err := genNew(table)
+	if err != nil {
+		return "", err
+	}
+	insertCode, err := genInsert(table)
+	if err != nil {
+		return "", err
+	}
+	var findCode = make([]string, 0)
+	findOneCode, err := genFindOne(table)
+	if err != nil {
+		return "", err
+	}
+	findOneByFieldCode, err := genFineOneByField(table)
+	if err != nil {
+		return "", err
+	}
+	findAllCode, err := genFindAllByField(table)
+	if err != nil {
+		return "", err
+	}
+	findLimitCode, err := genFindLimitByField(table)
+	if err != nil {
+		return "", err
+	}
+	findCode = append(findCode, findOneCode, findOneByFieldCode, findAllCode, findLimitCode)
+	updateCode, err := genUpdate(table)
+	if err != nil {
+		return "", err
+	}
+	deleteCode, err := genDelete(table)
+	if err != nil {
+		return "", err
+	}
+
+	err = t.Execute(modelBuffer, map[string]interface{}{
+		"imports": importsCode,
+		"vars":    varsCode,
+		"types":   typesCode,
+		"new":     newCode,
+		"insert":  insertCode,
+		"find":    strings.Join(findCode, "\r\n"),
+		"update":  updateCode,
+		"delete":  deleteCode,
+	})
+	if err != nil {
+		return "", err
+	}
+	result := modelBuffer.String()
+	bts, err := format.Source([]byte(result))
+	if err != nil {
+		logx.Errorf("%+v", err)
+		return "", err
+	}
+	return string(bts), nil
+}
--- a/tools/goctl/model/sql/gen/new.go
+++ b/tools/goctl/model/sql/gen/new.go
@@ -0,0 +1,24 @@
+package gen
+
+import (
+	"bytes"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genNew(table *InnerTable) (string, error) {
+	t, err := template.New("new").Parse(sqltemplate.New)
+	if err != nil {
+		return "", err
+	}
+	newBuffer := new(bytes.Buffer)
+	err = t.Execute(newBuffer, map[string]interface{}{
+		"containsCache": table.ContainsCache,
+		"upperObject":   table.UpperCamelCase,
+	})
+	if err != nil {
+		return "", err
+	}
+	return newBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/shared.go
+++ b/tools/goctl/model/sql/gen/shared.go
@@ -0,0 +1,99 @@
+package gen
+
+var (
+	commonMysqlDataTypeMap = map[string]string{
+		"tinyint":    "int64",
+		"smallint":   "int64",
+		"mediumint":  "int64",
+		"int":        "int64",
+		"integer":    "int64",
+		"bigint":     "int64",
+		"float":      "float64",
+		"double":     "float64",
+		"decimal":    "float64",
+		"date":       "time.Time",
+		"time":       "string",
+		"year":       "int64",
+		"datetime":   "time.Time",
+		"timestamp":  "time.Time",
+		"char":       "string",
+		"varchar":    "string",
+		"tinyblob":   "string",
+		"tinytext":   "string",
+		"blob":       "string",
+		"text":       "string",
+		"mediumblob": "string",
+		"mediumtext": "string",
+		"longblob":   "string",
+		"longtext":   "string",
+	}
+)
+
+const (
+	QueryNone  QueryType = 0
+	QueryOne   QueryType = 1 // 仅支持单个字段为查询条件
+	QueryAll   QueryType = 2 // 可支持多个字段为查询条件，且关系均为and
+	QueryLimit QueryType = 3 // 可支持多个字段为查询条件，且关系均为and
+)
+
+type (
+	QueryType int
+
+	Case struct {
+		SnakeCase      string
+		LowerCamelCase string
+		UpperCamelCase string
+	}
+	InnerWithField struct {
+		Case
+		DataType string
+	}
+	InnerTable struct {
+		Case
+		ContainsCache  bool
+		CreateNotFound bool
+		PrimaryField   *InnerField
+		Fields         []*InnerField
+		CacheKey       map[string]Key // key-数据库字段
+	}
+	InnerField struct {
+		IsPrimaryKey bool
+		InnerWithField
+		DataBaseType string // 数据库中字段类型
+		Tag          string // 标签，格式：`db:"xxx"`
+		Comment      string // 注释,以"// 开头"
+		Cache        bool   // 是否缓存模式
+		QueryType    QueryType
+		WithFields   []InnerWithField
+		Sort         []InnerSort
+	}
+	InnerSort struct {
+		Field Case
+		Asc   bool
+	}
+
+	OuterTable struct {
+		Table          string        `json:"table"`
+		CreateNotFound bool          `json:"createNotFound,optional"`
+		Fields         []*OuterFiled `json:"fields"`
+	}
+	OuterWithField struct {
+		Name         string `json:"name"`
+		DataBaseType string `json:"dataBaseType"`
+	}
+	OuterSort struct {
+		Field string `json:"fields"`
+		Asc   bool   `json:"asc,optional"`
+	}
+	OuterFiled struct {
+		IsPrimaryKey bool   `json:"isPrimaryKey,optional"`
+		Name         string `json:"name"`
+		DataBaseType string `json:"dataBaseType"`
+		Comment      string `json:"comment"`
+		Cache        bool   `json:"cache,optional"`
+		// if IsPrimaryKey==false下面字段有效
+		QueryType  QueryType        `json:"queryType"`           // 查找类型
+		WithFields []OuterWithField `json:"withFields,optional"` // 其他字段联合组成条件的字段列表
+		OuterSort  []OuterSort      `json:"sort,optional"`
+	}
+)
--- a/tools/goctl/model/sql/gen/tag.go
+++ b/tools/goctl/model/sql/gen/tag.go
@@ -0,0 +1,26 @@
+package gen
+
+import (
+	"bytes"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genTag(in string) (string, error) {
+	if in == "" {
+		return in, nil
+	}
+	t, err := template.New("tag").Parse(sqltemplate.Tag)
+	if err != nil {
+		return "", err
+	}
+	var tagBuffer = new(bytes.Buffer)
+	err = t.Execute(tagBuffer, map[string]interface{}{
+		"field": in,
+	})
+	if err != nil {
+		return "", err
+	}
+	return tagBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/types.go
+++ b/tools/goctl/model/sql/gen/types.go
@@ -0,0 +1,30 @@
+package gen
+
+import (
+	"bytes"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genTypes(table *InnerTable) (string, error) {
+	fields := table.Fields
+	t, err := template.New("types").Parse(sqltemplate.Types)
+	if err != nil {
+		return "", nil
+	}
+	var typeBuffer = new(bytes.Buffer)
+	fieldsString, err := genFields(fields)
+	if err != nil {
+		return "", err
+	}
+	err = t.Execute(typeBuffer, map[string]interface{}{
+		"upperObject":   table.UpperCamelCase,
+		"containsCache": table.ContainsCache,
+		"fields":        fieldsString,
+	})
+	if err != nil {
+		return "", err
+	}
+	return typeBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/update.go
+++ b/tools/goctl/model/sql/gen/update.go
@@ -0,0 +1,38 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genUpdate(table *InnerTable) (string, error) {
+	t, err := template.New("update").Parse(sqltemplate.Update)
+	if err != nil {
+		return "", nil
+	}
+	updateBuffer := new(bytes.Buffer)
+	expressionValues := make([]string, 0)
+	for _, filed := range table.Fields {
+		if filed.SnakeCase == "create_time" || filed.SnakeCase == "update_time" || filed.IsPrimaryKey {
+			continue
+		}
+		expressionValues = append(expressionValues, "data."+filed.UpperCamelCase)
+	}
+	expressionValues = append(expressionValues, "data."+table.PrimaryField.UpperCamelCase)
+	err = t.Execute(updateBuffer, map[string]interface{}{
+		"containsCache":      table.ContainsCache,
+		"upperObject":        table.UpperCamelCase,
+		"primaryCacheKey":    table.CacheKey[table.PrimaryField.SnakeCase].DataKey,
+		"primaryKeyVariable": table.CacheKey[table.PrimaryField.SnakeCase].KeyVariable,
+		"lowerObject":        table.LowerCamelCase,
+		"primarySnakeCase":   table.PrimaryField.SnakeCase,
+		"expressionValues":   strings.Join(expressionValues, ", "),
+	})
+	if err != nil {
+		return "", err
+	}
+	return updateBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/gen/vars.go
+++ b/tools/goctl/model/sql/gen/vars.go
@@ -0,0 +1,36 @@
+package gen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	sqltemplate "zero/tools/goctl/model/sql/template"
+)
+
+func genVars(table *InnerTable) (string, error) {
+	t, err := template.New("vars").Parse(sqltemplate.Vars)
+	if err != nil {
+		return "", err
+	}
+	varBuffer := new(bytes.Buffer)
+	m, err := genCacheKeys(table)
+	if err != nil {
+		return "", err
+	}
+	keys := make([]string, 0)
+	for _, v := range m {
+		keys = append(keys, v.Expression)
+	}
+	err = t.Execute(varBuffer, map[string]interface{}{
+		"lowerObject":     table.LowerCamelCase,
+		"upperObject":     table.UpperCamelCase,
+		"createNotFound":  table.CreateNotFound,
+		"keysDefine":      strings.Join(keys, "\r\n"),
+		"snakePrimaryKey": table.PrimaryField.SnakeCase,
+	})
+	if err != nil {
+		return "", err
+	}
+	return varBuffer.String(), nil
+}
--- a/tools/goctl/model/sql/sqlctl.go
+++ b/tools/goctl/model/sql/sqlctl.go
@@ -0,0 +1,22 @@
+package sqlgen
+
+import (
+	"errors"
+
+	"zero/tools/goctl/model/sql/gen"
+)
+
+var (
+	ErrCircleQuery = errors.New("circle query with other fields")
+)
+
+func Gen(in gen.OuterTable) (string, error) {
+	t, err := gen.TableConvert(in)
+	if err != nil {
+		if err == gen.ErrCircleQuery {
+			return "", ErrCircleQuery
+		}
+		return "", err
+	}
+	return gen.GenModel(t)
+}
--- a/tools/goctl/model/sql/template/delete.go
+++ b/tools/goctl/model/sql/template/delete.go
@@ -0,0 +1,17 @@
+package sqltemplate
+
+var Delete = `
+func (m *{{.upperObject}}Model) Delete({{.lowerPrimaryKey}} {{.dataType}}) error {
+	{{if .containsCache}}{{if .isNotPrimaryKey}}data,err:=m.FindOne({{.lowerPrimaryKey}})
+	if err!=nil{
+		return err
+	}{{end}}
+	{{.keys}}
+    _, err {{if .isNotPrimaryKey}}={{else}}:={{end}} m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+		query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.snakePrimaryKey}} = ?` + "`" + `
+		return conn.Exec(query, {{.lowerPrimaryKey}})
+	}, {{.keyValues}}){{else}}query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.snakePrimaryKey}} = ?` + "`" + `
+		_,err:=m.ExecNoCache(query, {{.lowerPrimaryKey}}){{end}}
+	return err
+}
+`
--- a/tools/goctl/model/sql/template/errors.go
+++ b/tools/goctl/model/sql/template/errors.go
@@ -0,0 +1,11 @@
+package sqltemplate
+
+var Error = `package model
+
+import "zero/core/stores/sqlx"
+
+var (
+	ErrNotFound = sqlx.ErrNotFound
+)
+
+`
--- a/tools/goctl/model/sql/template/field.go
+++ b/tools/goctl/model/sql/template/field.go
@@ -0,0 +1,3 @@
+package sqltemplate
+
+var Field = `{{.name}} {{.type}} {{.tag}} {{.comment}}`
--- a/tools/goctl/model/sql/template/find.go
+++ b/tools/goctl/model/sql/template/find.go
@@ -0,0 +1,115 @@
+package sqltemplate
+
+// 通过id查询
+var FindOne = `
+func (m *{{.upperObject}}Model) FindOne({{.lowerPrimaryKey}} {{.dataType}}) (*{{.upperObject}}, error) {
+	{{if .withCache}}{{.cacheKey}}
+	var resp {{.upperObject}}
+	err := m.QueryRow(&resp, {{.cacheKeyVariable}}, func(conn sqlx.SqlConn, v interface{}) error {
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakePrimaryKey}} = ? limit 1` + "`" + `
+		return conn.QueryRow(v, query, {{.lowerPrimaryKey}})
+	})
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}{{else}}query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakePrimaryKey}} = ? limit 1` + "`" + `
+	var resp {{.upperObject}}
+	err := m.QueryRowNoCache(&resp, query, {{.lowerPrimaryKey}})
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}{{end}}
+}
+`
+
+// 通过指定字段查询
+var FindOneByField = `
+func (m *{{.upperObject}}Model) FindOneBy{{.upperFields}}({{.in}}) (*{{.upperObject}}, error) {
+	{{if .onlyOneFiled}}{{if .withCache}}{{.cacheKey}}
+	var resp {{.upperObject}}
+	err := m.QueryRowIndex(&resp, {{.cacheKeyVariable}}, func(primary interface{}) string {
+		return fmt.Sprintf("%s%v", {{.primaryKeyDefine}}, primary)
+	}, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakeField}} = ? limit 1` + "`" + `
+		if err := conn.QueryRow(&resp, query, {{.lowerField}}); err != nil {
+			return nil, err
+		}
+		return resp.{{.UpperPrimaryKey}}, nil
+	}, func(conn sqlx.SqlConn, v, primary interface{}) error {
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.primarySnakeField}} = ? limit 1` + "`" + `
+		return conn.QueryRow(v, query, primary)
+	})
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}{{else}}var resp {{.upperObject}}
+	query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.expression}} limit 1` + "`" + `
+	err := m.QueryRowNoCache(&resp, query, {{.expressionValues}})
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}{{end}}{{else}}var resp {{.upperObject}}
+	query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.expression}} limit 1` + "`" + `
+	err := m.QueryRowNoCache(&resp, query, {{.expressionValues}})
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}{{end}}
+}
+`
+
+// 查询all
+var FindAllByField = `
+func (m *{{.upperObject}}Model) FindAllBy{{.upperFields}}({{.in}}) ([]*{{.upperObject}}, error) {
+	var resp []*{{.upperObject}}
+	query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.expression}}` + "`" + `
+	err := m.QueryRowsNoCache(&resp, query, {{.expressionValues}})
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+`
+
+// limit分页查询
+var FindLimitByField = `
+func (m *{{.upperObject}}Model) FindLimitBy{{.upperFields}}({{.in}}, page, limit int) ([]*{{.upperObject}}, error) {
+	var resp []*{{.upperObject}}
+	query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + `from ` + "` + " + `m.table ` + " + `" + ` where {{.expression}} order by {{.sortExpression}} limit ?,?` + "`" + `
+	err := m.QueryRowsNoCache(&resp, query, {{.expressionValues}}, (page-1)*limit, limit)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+func (m *{{.upperObject}}Model) FindAllCountBy{{.upperFields}}({{.in}}) (int64, error) {
+	var count int64
+	query := ` + "`" + `select count(1)  from ` + "` + " + `m.table ` + " + `" + ` where {{.expression}} ` + "`" + `
+	err := m.QueryRowNoCache(&count, query, {{.expressionValues}})
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+`
--- a/tools/goctl/model/sql/template/import.go
+++ b/tools/goctl/model/sql/template/import.go
@@ -0,0 +1,15 @@
+package sqltemplate
+
+var Imports = `
+import (
+	{{if .containsCache}}"database/sql"
+	"fmt"{{end}}
+	"strings"
+	"time"
+
+    "zero/core/stores/cache"
+	"zero/core/stores/sqlc"
+	"zero/core/stores/sqlx"
+	"zero/core/stringx"
+)
+`
--- a/tools/goctl/model/sql/template/insert.go
+++ b/tools/goctl/model/sql/template/insert.go
@@ -0,0 +1,9 @@
+package sqltemplate
+
+var Insert = `
+func (m *{{.upperObject}}Model) Insert(data {{.upperObject}}) error {
+	query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "`(` + " + `{{.lowerObject}}RowsExpectAutoSet` + " + `) value ({{.expression}})` " + `
+	_, err := m.ExecNoCache(query, {{.expressionValues}})
+	return err
+}
+`
--- a/tools/goctl/model/sql/template/model.go
+++ b/tools/goctl/model/sql/template/model.go
@@ -0,0 +1,12 @@
+package sqltemplate
+
+var Model = `package model
+{{.imports}}
+{{.vars}}
+{{.types}}
+{{.new}}
+{{.insert}}
+{{.find}}
+{{.update}}
+{{.delete}}
+`
--- a/tools/goctl/model/sql/template/new.go
+++ b/tools/goctl/model/sql/template/new.go
@@ -0,0 +1,10 @@
+package sqltemplate
+
+var New = `
+func New{{.upperObject}}Model(conn sqlx.SqlConn, c cache.CacheConf, table string) *{{.upperObject}}Model {
+	return &{{.upperObject}}Model{
+		CachedConn: sqlc.NewConn(conn, c),
+		table:      table,
+	}
+}
+`
--- a/tools/goctl/model/sql/template/tag.go
+++ b/tools/goctl/model/sql/template/tag.go
@@ -0,0 +1,3 @@
+package sqltemplate
+
+var Tag = "`db:\"{{.field}}\"`"
--- a/tools/goctl/model/sql/template/types.go
+++ b/tools/goctl/model/sql/template/types.go
@@ -0,0 +1,14 @@
+package sqltemplate
+
+var Types = `
+type (
+	{{.upperObject}}Model struct {
+		sqlc.CachedConn
+		table string
+	}
+
+	{{.upperObject}} struct {
+		{{.fields}}
+	}
+)
+`
--- a/tools/goctl/model/sql/template/update.go
+++ b/tools/goctl/model/sql/template/update.go
@@ -0,0 +1,13 @@
+package sqltemplate
+
+var Update = `
+func (m *{{.upperObject}}Model) Update(data {{.upperObject}}) error {
+	{{if .containsCache}}{{.primaryCacheKey}}
+    _, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+		query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerObject}}RowsWithPlaceHolder` + " + `" + ` where {{.primarySnakeCase}} = ?` + "`" + `
+		return conn.Exec(query, {{.expressionValues}})
+	}, {{.primaryKeyVariable}}){{else}}query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerObject}}RowsWithPlaceHolder` + " + `" + ` where {{.primarySnakeCase}} = ?` + "`" + `
+    _,err:=m.ExecNoCache(query, {{.expressionValues}}){{end}}
+	return err
+}
+`
--- a/tools/goctl/model/sql/template/vars.go
+++ b/tools/goctl/model/sql/template/vars.go
@@ -0,0 +1,14 @@
+package sqltemplate
+
+var Vars = `
+var (
+	{{.lowerObject}}FieldNames          = builderx.FieldNames(&{{.upperObject}}{})
+	{{.lowerObject}}Rows                = strings.Join({{.lowerObject}}FieldNames, ",")
+	{{.lowerObject}}RowsExpectAutoSet   = strings.Join(stringx.Remove({{.lowerObject}}FieldNames, "{{.snakePrimaryKey}}", "create_time", "update_time"), ",")
+	{{.lowerObject}}RowsWithPlaceHolder = strings.Join(stringx.Remove({{.lowerObject}}FieldNames, "{{.snakePrimaryKey}}", "create_time", "update_time"), "=?,") + "=?"
+
+	{{.keysDefine}}
+
+	{{if .createNotFound}}ErrNotFound               = sqlx.ErrNotFound{{end}}
+)
+`
--- a/tools/goctl/model/sql/util/stringurtl_test.go
+++ b/tools/goctl/model/sql/util/stringurtl_test.go
@@ -0,0 +1,12 @@
+package util
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestFormatField(t *testing.T) {
+	var in = "go_java"
+	snakeCase, upperCase, lowerCase := FormatField(in)
+	fmt.Println(snakeCase, upperCase, lowerCase)
+}
--- a/tools/goctl/model/sql/util/stringutil.go
+++ b/tools/goctl/model/sql/util/stringutil.go
@@ -0,0 +1,48 @@
+package util
+
+import (
+	"strings"
+	"unicode"
+)
+
+func FormatField(field string) (snakeCase, upperCamelCase, lowerCamelCase string) {
+	snakeCase = field
+	list := strings.Split(field, "_")
+	upperCaseList := make([]string, 0)
+	lowerCaseList := make([]string, 0)
+	for index, word := range list {
+		upperStart := convertUpperStart(word)
+		lowerStart := convertLowerStart(word)
+		upperCaseList = append(upperCaseList, upperStart)
+		if index == 0 {
+			lowerCaseList = append(lowerCaseList, lowerStart)
+		} else {
+			lowerCaseList = append(lowerCaseList, upperStart)
+		}
+	}
+	upperCamelCase = strings.Join(upperCaseList, "")
+	lowerCamelCase = strings.Join(lowerCaseList, "")
+	return
+}
+
+func convertLowerStart(in string) string {
+	var resp []rune
+	for index, r := range in {
+		if index == 0 {
+			r = unicode.ToLower(r)
+		}
+		resp = append(resp, r)
+	}
+	return string(resp)
+}
+
+func convertUpperStart(in string) string {
+	var resp []rune
+	for index, r := range in {
+		if index == 0 {
+			r = unicode.ToUpper(r)
+		}
+		resp = append(resp, r)
+	}
+	return string(resp)
+}