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/mongomodel/gen/genmethod.go
+++ b/tools/goctl/model/mongomodel/gen/genmethod.go
@@ -0,0 +1,33 @@
+package gen
+
+import (
+	"strings"
+
+	"zero/tools/goctl/model/mongomodel/utils"
+)
+
+func genMethodTemplate(funcDesc FunctionDesc, needCache bool) (template string) {
+	var tmp string
+	switch funcDesc.Type {
+	case functionTypeGet:
+		if needCache {
+			tmp = getTemplate
+		} else {
+			tmp = noCacheGetTemplate
+		}
+	case functionTypeFind:
+		tmp = findTemplate
+	case functionTypeSet:
+		if needCache {
+			tmp = ""
+		} else {
+			tmp = noCacheSetFieldtemplate
+		}
+	default:
+		return ""
+	}
+	tmp = strings.ReplaceAll(tmp, "{{.Name}}", funcDesc.FieldName)
+	tmp = strings.ReplaceAll(tmp, "{{.name}}", utils.UpperCamelToLower(funcDesc.FieldName))
+	tmp = strings.ReplaceAll(tmp, "{{.type}}", funcDesc.FieldType)
+	return tmp
+}
--- a/tools/goctl/model/mongomodel/gen/genmongomodel.go
+++ b/tools/goctl/model/mongomodel/gen/genmongomodel.go
@@ -0,0 +1,156 @@
+package gen
+
+import (
+	"fmt"
+	"strings"
+	"text/template"
+
+	"zero/tools/goctl/api/spec"
+	"zero/tools/goctl/api/util"
+	"zero/tools/goctl/model/mongomodel/utils"
+)
+
+const (
+	functionTypeGet  = "get"  //GetByField return single model
+	functionTypeFind = "find" // findByField return many model
+	functionTypeSet  = "set"  // SetField  only set specified field
+
+	TagOperate = "o" //字段函数的tag
+	TagComment = "c" //字段注释的tag
+)
+
+type (
+	FunctionDesc struct {
+		Type      string // get,find,set
+		FieldName string // 字段名字 eg:Age
+		FieldType string // 字段类型 eg: string,int64 等
+	}
+)
+
+func GenMongoModel(goFilePath string, needCache bool) error {
+	structs, imports, err := utils.ParseGoFile(goFilePath)
+	if err != nil {
+		return err
+	}
+	if len(structs) != 1 {
+		return fmt.Errorf("only 1 struct should be provided")
+	}
+	structStr, err := genStructs(structs)
+	if err != nil {
+		return err
+	}
+
+	fp, err := util.ClearAndOpenFile(goFilePath)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+
+	var myTemplate string
+	if needCache {
+		myTemplate = cacheTemplate
+	} else {
+		myTemplate = noCacheTemplate
+	}
+	structName := getStructName(structs)
+	functionList := getFunctionList(structs)
+
+	for _, fun := range functionList {
+		funTmp := genMethodTemplate(fun, needCache)
+		if funTmp == "" {
+			continue
+		}
+		myTemplate += "\n"
+		myTemplate += funTmp
+		myTemplate += "\n"
+	}
+
+	t := template.Must(template.New("mongoTemplate").Parse(myTemplate))
+	return t.Execute(fp, map[string]string{
+		"modelName":   structName,
+		"importArray": getImports(imports, needCache),
+		"modelFields": structStr,
+	})
+}
+
+func getFunctionList(structs []utils.Struct) []FunctionDesc {
+	var list []FunctionDesc
+	for _, field := range structs[0].Fields {
+		tagMap := parseTag(field.Tag)
+		if fun, ok := tagMap[TagOperate]; ok {
+			funList := strings.Split(fun, ",")
+			for _, o := range funList {
+				var f FunctionDesc
+				f.FieldType = field.Type
+				f.FieldName = field.Name
+				f.Type = o
+				list = append(list, f)
+			}
+		}
+	}
+	return list
+}
+
+func getStructName(structs []utils.Struct) string {
+	for _, structItem := range structs {
+		return structItem.Name
+	}
+	return ""
+}
+
+func genStructs(structs []utils.Struct) (string, error) {
+	if len(structs) > 1 {
+		return "", fmt.Errorf("input .go file must only one struct")
+	}
+
+	modelFields := `Id             bson.ObjectId ` + quotationMark + `bson:"_id" json:"id,omitempty"` + quotationMark + "\n\t"
+	for _, structItem := range structs {
+		for _, field := range structItem.Fields {
+			modelFields += getFieldLine(field)
+		}
+	}
+	modelFields += "\t" + `CreateTime time.Time ` + quotationMark + `json:"createTime,omitempty" bson:"createTime"` + quotationMark + "\n\t"
+	modelFields += "\t" + `UpdateTime time.Time ` + quotationMark + `json:"updateTime,omitempty" bson:"updateTime"` + quotationMark
+	return modelFields, nil
+}
+
+func getFieldLine(member spec.Member) string {
+	if member.Name == "CreateTime" || member.Name == "UpdateTime" || member.Name == "Id" {
+		return ""
+	}
+	jsonName := utils.UpperCamelToLower(member.Name)
+	result := "\t" + member.Name + ` ` + member.Type + ` ` + quotationMark + `json:"` + jsonName + `,omitempty"` + ` bson:"` + jsonName + `"` + quotationMark
+	tagMap := parseTag(member.Tag)
+	if comment, ok := tagMap[TagComment]; ok {
+		result += ` //` + comment + "\n\t"
+	} else {
+		result += "\n\t"
+	}
+	return result
+}
+
+// tag like `o:"find,get,update" c:"姓名"`
+func parseTag(tag string) map[string]string {
+	var result = make(map[string]string, 0)
+	tags := strings.Split(tag, " ")
+	for _, kv := range tags {
+		temp := strings.Split(kv, ":")
+		if len(temp) > 1 {
+			key := strings.ReplaceAll(strings.ReplaceAll(temp[0], "\"", ""), "`", "")
+			value := strings.ReplaceAll(strings.ReplaceAll(temp[1], "\"", ""), "`", "")
+			result[key] = value
+		}
+	}
+	return result
+}
+
+func getImports(imports []string, needCache bool) string {
+
+	importStr := strings.Join(imports, "\n\t")
+	importStr += "\"errors\"\n\t"
+	importStr += "\"time\"\n\t"
+	importStr += "\n\t\"zero/core/stores/cache\"\n\t"
+	importStr += "\"zero/core/stores/mongoc\"\n\t"
+	importStr += "\n\t\"github.com/globalsign/mgo/bson\""
+	return importStr
+}
--- a/tools/goctl/model/mongomodel/gen/genmongomodelbynetwork.go
+++ b/tools/goctl/model/mongomodel/gen/genmongomodelbynetwork.go
@@ -0,0 +1,67 @@
+package gen
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"zero/tools/goctl/model/mongomodel/utils"
+)
+
+func GenMongoModelByNetwork(input string, needCache bool) (string, error) {
+	if strings.TrimSpace(input) == "" {
+		return "", errors.New("struct不能为空")
+	}
+	if strings.Index(strings.TrimSpace(input), "type") != 0 {
+		input = "type " + input
+	}
+
+	if strings.Index(strings.TrimSpace(input), "package") != 0 {
+		input = "package model\r\n" + input
+	}
+
+	structs, imports, err := utils.ParseGoFileByNetwork(input)
+	if err != nil {
+		return "", err
+	}
+	if len(structs) != 1 {
+		return "", fmt.Errorf("only 1 struct should be provided")
+	}
+	structStr, err := genStructs(structs)
+	if err != nil {
+		return "", err
+	}
+
+	var myTemplate string
+	if needCache {
+		myTemplate = cacheTemplate
+	} else {
+		myTemplate = noCacheTemplate
+	}
+	structName := getStructName(structs)
+	functionList := getFunctionList(structs)
+
+	for _, fun := range functionList {
+		funTmp := genMethodTemplate(fun, needCache)
+		if funTmp == "" {
+			continue
+		}
+		myTemplate += "\n"
+		myTemplate += funTmp
+		myTemplate += "\n"
+	}
+
+	t := template.Must(template.New("mongoTemplate").Parse(myTemplate))
+	var result bytes.Buffer
+	err = t.Execute(&result, map[string]string{
+		"modelName":   structName,
+		"importArray": getImports(imports, needCache),
+		"modelFields": structStr,
+	})
+	if err != nil {
+		return "", err
+	}
+	return result.String(), nil
+}
--- a/tools/goctl/model/mongomodel/gen/templatemodel.go
+++ b/tools/goctl/model/mongomodel/gen/templatemodel.go
@@ -0,0 +1,238 @@
+package gen
+
+const (
+	quotationMark = "`"
+	//templates that do not use caching
+	noCacheTemplate = `package model
+
+import (
+	{{.importArray}}
+)
+
+var ErrNotFound = mongoc.ErrNotFound
+
+type (
+	{{.modelName}}Model struct {
+		*mongoc.Model
+	}
+
+	{{.modelName}} struct {
+		{{.modelFields}}
+	}
+)
+
+func New{{.modelName}}Model(url, database, collection string, c cache.CacheConf, opts ...cache.Option) *{{.modelName}}Model {
+	return &{{.modelName}}Model{mongoc.MustNewModel(url, database, collection, c, opts...)}
+}
+
+func (m *{{.modelName}}Model) FindOne(id string) (*{{.modelName}}, error) {
+	session, err := m.Model.TakeSession()
+	if err != nil {
+		return nil, err
+	}
+	defer m.Model.PutSession(session)
+
+	var result {{.modelName}}
+	err = m.GetCollection(session).FindOneIdNoCache(&result,bson.ObjectIdHex(id))
+	if err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (m *{{.modelName}}Model) Delete(id string) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+	return m.GetCollection(session).RemoveIdNoCache(bson.ObjectIdHex(id))
+}
+
+func (m *{{.modelName}}Model) Insert(data *{{.modelName}}) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	return m.GetCollection(session).Insert(data)
+}
+
+func (m *{{.modelName}}Model) Update(data *{{.modelName}}) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	data.UpdateTime = time.Now()
+	return m.GetCollection(session).UpdateIdNoCache(data.Id, data)
+}
+`
+
+	//use cache template
+	cacheTemplate = `package model
+
+import (
+	{{.importArray}}
+)
+
+var ErrNotFound = errors.New("not found")
+
+const (
+	Prefix{{.modelName}}CacheKey = "#{{.modelName}}#cache" //todo please modify this prefix
+)
+
+type (
+	{{.modelName}}Model struct {
+		*mongoc.Model
+	}
+
+	{{.modelName}} struct {
+		{{.modelFields}}
+	}
+)
+
+func New{{.modelName}}Model(url, database, collection string, c cache.CacheConf, opts ...cache.Option) *{{.modelName}}Model {
+	return &{{.modelName}}Model{mongoc.MustNewModel(url, database, collection, c, opts...)}
+}
+
+func (m *{{.modelName}}Model) FindOne(id string) (*{{.modelName}}, error) {
+	key := Prefix{{.modelName}}CacheKey + id
+	session, err := m.Model.TakeSession()
+	if err != nil {
+		return nil, err
+	}
+	defer m.Model.PutSession(session)
+
+	var result {{.modelName}}
+	err = m.GetCollection(session).FindOneId(&result, key, bson.ObjectIdHex(id))
+	switch err {
+	case nil:
+		return &result, nil
+	case mongoc.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}
+}
+
+func (m *{{.modelName}}Model) Delete(id string) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	key := Prefix{{.modelName}}CacheKey + id
+	return m.GetCollection(session).RemoveId(bson.ObjectIdHex(id), key)
+}
+
+func (m *{{.modelName}}Model) Insert(data *{{.modelName}}) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	return m.GetCollection(session).Insert(data)
+}
+
+func (m *{{.modelName}}Model) Update(data *{{.modelName}}) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	data.UpdateTime = time.Now()
+	key := Prefix{{.modelName}}CacheKey + data.Id.Hex()
+	return m.GetCollection(session).UpdateId(data.Id, data, key)
+}
+`
+	cacheSetFieldtemplate = `func (m *{{.modelName}}Model) Set{{.Name}}(id string, {{.name}} {{.type}}) error {
+	_, err := m.cache.Del(Prefix{{.modelName}}CacheKey + id)
+	if err != nil {
+		return err
+	}
+
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	update := bson.M{"$set": bson.M{"{{.name}}": {{.name}}, "updateTime": time.Now()}}
+	return m.GetCollection(session).UpdateId(bson.ObjectIdHex(id), update)
+}`
+
+	noCacheSetFieldtemplate = `func (m *{{.modelName}}Model) Set{{.Name}}(id string, {{.name}} {{.type}}) error {
+	session, err := m.TakeSession()
+	if err != nil {
+		return err
+	}
+	defer m.PutSession(session)
+
+	update := bson.M{"$set": bson.M{"{{.name}}": {{.name}}, "updateTime": time.Now()}}
+	return m.GetCollection(session).UpdateId(bson.ObjectIdHex(id), update)
+}`
+
+	noCacheGetTemplate = `func (m *{{.modelName}}Model) GetBy{{.Name}}({{.name}} {{.type}}) (*{{.modelName}},error) {
+	session, err := m.TakeSession()
+	if err != nil {
+		return nil,err
+	}
+	defer m.PutSession(session)
+	var result {{.modelName}}
+	query := bson.M{"{{.name}}":{{.name}}}
+	err = m.GetCollection(session).FindOneNoCache(&result, query)
+	if err != nil {
+		if err == mgo.ErrNotFound {
+			return nil,ErrNotFound
+		}
+		return nil,err
+	}
+	return &result,nil
+}`
+	// GetByField return single model
+	getTemplate = `func (m *{{.modelName}}Model) GetBy{{.Name}}({{.name}} {{.type}}) (*{{.modelName}},error) {
+	session, err := m.TakeSession()
+	if err != nil {
+		return nil,err
+	}
+	defer m.PutSession(session)
+	var result {{.modelName}}
+	query := bson.M{"{{.name}}":{{.name}}}
+	key := getCachePrimaryKeyBy{{.Name}}({{.name}})
+	err = m.GetCollection(session).FindOne(&result,key,query)
+	if err != nil {
+		if err == mgo.ErrNotFound {
+			return nil,ErrNotFound
+		}
+		return nil,err
+	}
+	return &result,nil
+}
+
+func getCachePrimaryKeyBy{{.Name}}({{.name}} {{.type}}) string {
+	return "" //todo 请补全这里
+}
+`
+
+	findTemplate = `func (m *{{.modelName}}Model) FindBy{{.Name}}({{.name}} string) ([]{{.modelName}},error) {
+	session, err := m.TakeSession()
+	if err != nil {
+		return nil,err
+	}
+	defer m.PutSession(session)
+	
+	query := bson.M{"{{.name}}":{{.name}}}
+	var result []{{.modelName}}
+	err = m.GetCollection(session).FindAllNoCache(&result,query)
+	if err != nil {
+		return nil,err
+	}
+	return result,nil
+}`
+)
--- a/tools/goctl/model/mongomodel/genmongocmd.go
+++ b/tools/goctl/model/mongomodel/genmongocmd.go
@@ -0,0 +1,30 @@
+package mongomodel
+
+import (
+	"errors"
+	"fmt"
+
+	"zero/core/lang"
+	"zero/tools/goctl/model/mongomodel/gen"
+
+	"github.com/logrusorgru/aurora"
+	"github.com/urfave/cli"
+)
+
+func ModelCommond(c *cli.Context) error {
+	src := c.String("src")
+	cache := c.String("cache")
+
+	if len(src) == 0 {
+		return errors.New("missing -src")
+	}
+	var needCache bool
+	if cache == "yes" {
+		needCache = true
+	}
+
+	lang.Must(gen.GenMongoModel(src, needCache))
+
+	fmt.Println(aurora.Green("Done."))
+	return nil
+}
--- a/tools/goctl/model/mongomodel/utils/parsesimplegofile.go
+++ b/tools/goctl/model/mongomodel/utils/parsesimplegofile.go
@@ -0,0 +1,167 @@
+package utils
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"strings"
+
+	"zero/tools/goctl/api/spec"
+)
+
+const (
+	StructArr = "struct"
+	ImportArr = "import"
+	Unknown   = "unknown"
+)
+
+type Struct struct {
+	Name   string
+	Fields []spec.Member
+}
+
+func readFile(filePath string) (string, error) {
+	b, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func ParseNetworkGoFile(io string) ([]Struct, []string, error) {
+	fset := token.NewFileSet() // 位置是相对于节点
+
+	f, err := parser.ParseFile(fset, "", io, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	return parse(f)
+}
+
+func ParseGoFile(pathOrStr string) ([]Struct, []string, error) {
+	var goFileStr string
+	var err error
+	goFileStr, err = readFile(pathOrStr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	fset := token.NewFileSet() // 位置是相对于节点
+
+	f, err := parser.ParseFile(fset, "", goFileStr, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	return parse(f)
+}
+
+func ParseGoFileByNetwork(io string) ([]Struct, []string, error) {
+	fset := token.NewFileSet() // 位置是相对于节点
+
+	f, err := parser.ParseFile(fset, "", io, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	return parse(f)
+}
+
+//使用ast包解析golang文件
+func parse(f *ast.File) ([]Struct, []string, error) {
+	if len(f.Decls) == 0 {
+		return nil, nil, fmt.Errorf("you should provide as least 1 struct")
+	}
+	var structList []Struct
+	var importList []string
+	for _, decl := range f.Decls {
+		structs, imports, err := getStructAndImportInfo(decl)
+		if err != nil {
+			return nil, nil, err
+		}
+		structList = append(structList, structs...)
+		importList = append(importList, imports...)
+	}
+	return structList, importList, nil
+}
+
+func getStructAndImportInfo(decl ast.Decl) (structs []Struct, imports []string, err error) {
+	var structList []Struct
+	var importList []string
+	genDecl, ok := decl.(*ast.GenDecl)
+	if !ok {
+		return nil, nil, fmt.Errorf("please input right file")
+	}
+	for _, tpyObj := range genDecl.Specs {
+		switch tpyObj.(type) {
+		case *ast.ImportSpec: // import
+			importSpec := tpyObj.(*ast.ImportSpec)
+			s := importSpec.Path.Value
+			importList = append(importList, s)
+		case *ast.TypeSpec: //type
+			typeSpec := tpyObj.(*ast.TypeSpec)
+			switch typeSpec.Type.(type) {
+			case *ast.StructType: // struct
+				struct1, err := parseStruct(typeSpec)
+				if err != nil {
+					return nil, nil, err
+				}
+				structList = append(structList, *struct1)
+			}
+		default:
+
+		}
+	}
+	return structList, importList, nil
+}
+
+func parseStruct(typeSpec *ast.TypeSpec) (*Struct, error) {
+	var result Struct
+	structName := typeSpec.Name.Name
+	result.Name = structName
+	structType, ok := typeSpec.Type.(*ast.StructType)
+	if !ok {
+		return nil, fmt.Errorf("not struct")
+	}
+
+	for _, item := range structType.Fields.List {
+		var member spec.Member
+		var err error
+		member.Name = parseFiledName(item.Names)
+		member.Type, err = parseFiledType(item.Type)
+		if err != nil {
+			return nil, err
+		}
+		if item.Tag != nil {
+			member.Tag = item.Tag.Value
+		}
+		result.Fields = append(result.Fields, member)
+	}
+	return &result, nil
+}
+
+func parseFiledType(expr ast.Expr) (string, error) {
+	switch expr.(type) {
+	case *ast.Ident:
+		return expr.(*ast.Ident).Name, nil
+	case *ast.SelectorExpr:
+		selectorExpr := expr.(*ast.SelectorExpr)
+		return selectorExpr.X.(*ast.Ident).Name + "." + selectorExpr.Sel.Name, nil
+	default:
+		return "", fmt.Errorf("can't parse type")
+	}
+}
+
+func parseFiledName(idents []*ast.Ident) string {
+	for _, name := range idents {
+		return name.Name
+	}
+	return ""
+}
+
+func UpperCamelToLower(name string) string {
+	if len(name) == 0 {
+		return ""
+	}
+	return strings.ToLower(name[:1]) + name[1:]
+}
--- 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)
+}
--- a/tools/goctl/model/sqlmodel/deletesql.go
+++ b/tools/goctl/model/sqlmodel/deletesql.go
@@ -0,0 +1,37 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+)
+
+var deleteTemplate = `
+func ({{.pointer}} *{{.model}}Model) Delete({{.conditions}}) error {
+	sql := ` + "`" + `delete from` + " ` + " + `{{.pointer}}.table ` + "+ `" + ` where {{.valueConditions}}` + "`\n" +
+	`	_, err := {{.pointer}}.conn.Exec(sql, {{.values}})
+	return err
+}
+`
+
+func (s *structExp) genDelete() (string, error) {
+	idType := "string"
+	if s.idAutoIncrement {
+		idType = "int64"
+	}
+	conditionExp, valueConditions := s.buildCondition()
+	t := template.Must(template.New("deleteTemplate").Parse(deleteTemplate))
+	var tmplBytes bytes.Buffer
+	err := t.Execute(&tmplBytes, map[string]string{
+		"pointer":         "m",
+		"model":           s.name,
+		"idType":          idType,
+		"valueConditions": valueConditions,
+		"conditions":      conditionExp,
+		"values":          strings.Join(s.conditionNames(), ", "),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}
--- a/tools/goctl/model/sqlmodel/errors.go
+++ b/tools/goctl/model/sqlmodel/errors.go
@@ -0,0 +1,7 @@
+package sqlmodel
+
+import "errors"
+
+func sqlError(str string) error {
+	return errors.New("sql error: " + str)
+}
--- a/tools/goctl/model/sqlmodel/gen.go
+++ b/tools/goctl/model/sqlmodel/gen.go
@@ -0,0 +1,46 @@
+package sqlmodel
+
+import (
+	"go/format"
+
+	"zero/core/logx"
+)
+
+type (
+	Column struct {
+		DataType string `json:"dataType"`
+		Name     string `json:"name"`
+		Comment  string `json:"comment"`
+	}
+
+	Table struct {
+		Name       string    `json:"table"`
+		PrimaryKey string    `json:"primaryKey"`
+		Columns    []*Column `json:"columns"`
+	}
+)
+
+func GenMysqlGoModel(req *Table, conditions []string) (string, error) {
+	resp, err := generateTypeModel(req.Name, req.Columns)
+	if err != nil {
+		return "", err
+	}
+	resp.PrimaryKey = req.PrimaryKey
+	s, err := NewStructExp(*resp)
+	if len(conditions) == 0 {
+		s.conditions = []string{resp.PrimaryKey}
+	} else {
+		s.conditions = conditions
+	}
+	if err != nil {
+		return "", err
+	}
+	result, err := s.genMysqlCRUD()
+	// code format
+	bts, err := format.Source([]byte(result))
+	if err != nil {
+		logx.Errorf("%+v", err)
+		return "", err
+	}
+	return string(bts), err
+}
--- a/tools/goctl/model/sqlmodel/genmodel.go
+++ b/tools/goctl/model/sqlmodel/genmodel.go
@@ -0,0 +1,185 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"text/template"
+
+	"zero/core/stringx"
+	"zero/tools/goctl/api/spec"
+	"zero/tools/goctl/util"
+)
+
+var (
+	commonTemplate = `
+var (
+	{{.modelWithLowerStart}}FieldNames = builderx.FieldNames(&{{.model}}{})
+	{{.modelWithLowerStart}}Rows = strings.Join({{.modelWithLowerStart}}FieldNames, ",")
+	{{.modelWithLowerStart}}RowsExpectAutoSet = strings.Join(stringx.Remove({{.modelWithLowerStart}}FieldNames, {{.expected}}), ",")
+	{{.modelWithLowerStart}}RowsWithPlaceHolder = strings.Join(stringx.Remove({{.modelWithLowerStart}}FieldNames, {{.expected}}), "=?,") + "=?"
+)
+`
+)
+
+type (
+	fieldExp struct {
+		name string
+		tag  string
+		ty   string
+	}
+	structExp struct {
+		genStruct       GenStruct
+		name            string
+		idAutoIncrement bool
+		Fields          []fieldExp
+		primaryKey      string
+		conditions      []string
+		ignoreFields    []string
+	}
+)
+
+func NewStructExp(s GenStruct) (*structExp, error) {
+	src := s.TableStruct
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "", src, 0)
+
+	if err != nil {
+		return nil, err
+	}
+	if len(file.Decls) == 0 {
+		return nil, sqlError("no struct inspect")
+	}
+	typeDecl := file.Decls[0].(*ast.GenDecl)
+
+	if len(typeDecl.Specs) == 0 {
+		return nil, sqlError("no type specs")
+	}
+	typeSpec := typeDecl.Specs[0].(*ast.TypeSpec)
+	structDecl := typeSpec.Type.(*ast.StructType)
+
+	var strExp structExp
+	strExp.genStruct = s
+	strExp.primaryKey = s.PrimaryKey
+	strExp.name = typeSpec.Name.Name
+	fields := structDecl.Fields.List
+	for _, field := range fields {
+		typeExpr := field.Type
+
+		start := typeExpr.Pos() - 1
+		end := typeExpr.End() - 1
+
+		typeInSource := src[start:end]
+		if len(field.Names) == 0 {
+			return nil, sqlError("field name empty")
+		}
+		var name = field.Names[0].Name
+		var tag = util.Untitle(name)
+		if field.Tag != nil {
+			tag = src[field.Tag.Pos():field.Tag.End()]
+		}
+		dbTag := getDBColumnName(tag, name)
+		strExp.Fields = append(strExp.Fields, fieldExp{
+			name: name,
+			ty:   typeInSource,
+			tag:  dbTag,
+		})
+		if dbTag == strExp.primaryKey && typeInSource == "int64" {
+			strExp.ignoreFields = append(strExp.ignoreFields, dbTag)
+			strExp.idAutoIncrement = true
+		}
+		if name == "UpdateTime" || name == "CreateTime" {
+			strExp.ignoreFields = append(strExp.ignoreFields, dbTag)
+		}
+	}
+	return &strExp, nil
+}
+
+func (s *structExp) genMysqlCRUD() (string, error) {
+	commonStr, err := s.genCommon()
+	if err != nil {
+		return "", err
+	}
+	insertStr, err := s.genInsert()
+	if err != nil {
+		return "", err
+	}
+	updateStr, err := s.genUpdate()
+	if err != nil {
+		return "", err
+	}
+
+	deleteStr, err := s.genDelete()
+	if err != nil {
+		return "", err
+	}
+
+	queryOneStr, err := s.genQueryOne()
+	if err != nil {
+		return "", err
+	}
+
+	queryListStr, err := s.genQueryList()
+	if err != nil {
+		return "", err
+	}
+	return strings.Join([]string{"package model \n", commonStr, s.genStruct.TableModel, queryOneStr, queryListStr, deleteStr, insertStr, updateStr}, "\n"), nil
+}
+
+func getDBColumnName(tag, name string) string {
+	matches := spec.TagRe.FindStringSubmatch(tag)
+	for i := range matches {
+		name := spec.TagSubNames[i]
+		if name == "name" {
+			return matches[i]
+		}
+	}
+
+	return util.Untitle(name)
+}
+
+func (s *structExp) genCommon() (string, error) {
+	templateName := commonTemplate
+	t := template.Must(template.New("commonTemplate").Parse(templateName))
+	var tmplBytes bytes.Buffer
+	var ignoreFieldsQuota []string
+	for _, item := range s.ignoreFields {
+		ignoreFieldsQuota = append(ignoreFieldsQuota, fmt.Sprintf("\"%s\"", item))
+	}
+	err := t.Execute(&tmplBytes, map[string]string{
+		"model":               s.name,
+		"expected":            strings.Join(ignoreFieldsQuota, ", "),
+		"modelWithLowerStart": fmtUnderLine2Camel(s.name, false),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}
+
+func (s *structExp) buildCondition() (string, string) {
+	var conditionExp []string
+	var valueConditions []string
+	for _, field := range s.Fields {
+		if stringx.Contains(s.conditions, strings.ToLower(field.tag)) ||
+			stringx.Contains(s.conditions, strings.ToLower(field.name)) {
+			conditionExp = append(conditionExp, fmt.Sprintf("%s %s", util.Untitle(field.name), field.ty))
+			valueConditions = append(valueConditions, fmt.Sprintf("%s = ?", field.tag))
+		}
+	}
+	return strings.Join(conditionExp, ", "), strings.Join(valueConditions, " and ")
+}
+
+func (s *structExp) conditionNames() []string {
+	var conditionExp []string
+	for _, field := range s.Fields {
+		if stringx.Contains(s.conditions, strings.ToLower(field.tag)) ||
+			stringx.Contains(s.conditions, strings.ToLower(field.name)) {
+			conditionExp = append(conditionExp, util.Untitle(field.name))
+		}
+	}
+	return conditionExp
+}
--- a/tools/goctl/model/sqlmodel/insertsql.go
+++ b/tools/goctl/model/sqlmodel/insertsql.go
@@ -0,0 +1,46 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"zero/core/stringx"
+)
+
+var insertTemplate = `
+func ({{.pointer}} *{{.model}}Model) Insert(data {{.model}}) error {
+	sql := ` + "`" + `insert into` + " ` + " + `{{.pointer}}.table ` + " + `(` + " + "{{.modelWithLowerStart}}RowsExpectAutoSet" + " + `" + `) value ({{.valueHolder}})` + "`\n" +
+	`	_, err := {{.pointer}}.conn.Exec(sql, {{.values}})
+	return err
+}
+`
+
+func (s *structExp) genInsert() (string, error) {
+	var valueHolder []string
+	var values []string
+	for _, field := range s.Fields {
+		if stringx.Contains(s.ignoreFields, field.name) || stringx.Contains(s.ignoreFields, field.tag) {
+			continue
+		}
+		valueHolder = append(valueHolder, "?")
+		values = append(values, fmt.Sprintf("data.%s", field.name))
+	}
+
+	t := template.Must(template.New("insertTemplate").Parse(insertTemplate))
+	var tmplBytes bytes.Buffer
+	var columns = "rowsExpectAutoSet"
+	err := t.Execute(&tmplBytes, map[string]string{
+		"pointer":             "m",
+		"model":               s.name,
+		"columns":             columns,
+		"valueHolder":         strings.Join(valueHolder, ","),
+		"values":              strings.Join(values, ", "),
+		"modelWithLowerStart": fmtUnderLine2Camel(s.name, false),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}
--- a/tools/goctl/model/sqlmodel/querysql.go
+++ b/tools/goctl/model/sqlmodel/querysql.go
@@ -0,0 +1,75 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+)
+
+var queryOneTemplate = `
+func ({{.pointer}} *{{.model}}Model) FindOne({{.conditions}}) (*{{.model}}, error) {
+	sql :=` + " `" + "select " + "` +" + ` {{.modelWithLowerStart}}Rows + ` + "`" + ` from ` + "` + " + `{{.pointer}}.table +` + " ` " + `where {{.valueConditions}} limit 1` + "`" + `
+	var resp {{.model}}
+	err := {{.pointer}}.conn.QueryRow(&resp, sql, {{.values}})
+	if err != nil {
+		if err == sqlx.ErrNotFound {
+			return nil, ErrNotFound
+		}
+		return nil, err
+	}
+	return &resp, nil
+}
+`
+
+var queryListTemplate = `
+func ({{.pointer}} *{{.model}}Model) Find({{.conditions}}) ([]{{.model}}, error) {
+	sql :=` + " `" + "select " + "` +" + ` {{.modelWithLowerStart}}Rows + ` + "`" + ` from ` + "` + " + `{{.pointer}}.table +` + " ` " + `where {{.valueConditions}}` + "`" + `
+	var resp []{{.model}}
+	err := {{.pointer}}.conn.QueryRows(&resp, sql, {{.values}})
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+`
+
+func (s *structExp) genQueryOne() (string, error) {
+	conditionExp, valueConditions := s.buildCondition()
+
+	t := template.Must(template.New("queryOneTemplate").Parse(queryOneTemplate))
+	var tmplBytes bytes.Buffer
+	err := t.Execute(&tmplBytes, map[string]string{
+		"pointer":             "m",
+		"model":               s.name,
+		"conditions":          conditionExp,
+		"valueConditions":     valueConditions,
+		"values":              strings.Join(s.conditionNames(), ", "),
+		"modelWithLowerStart": fmtUnderLine2Camel(s.name, false),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}
+
+func (s *structExp) genQueryList() (string, error) {
+	if len(s.conditions) == 1 && s.conditions[0] == s.primaryKey {
+		return "", nil
+	}
+	conditionExp, valueConditions := s.buildCondition()
+
+	t := template.Must(template.New("queryListTemplate").Parse(queryListTemplate))
+	var tmplBytes bytes.Buffer
+	err := t.Execute(&tmplBytes, map[string]string{
+		"pointer":             "m",
+		"model":               s.name,
+		"conditions":          conditionExp,
+		"valueConditions":     valueConditions,
+		"values":              strings.Join(s.conditionNames(), ", "),
+		"modelWithLowerStart": fmtUnderLine2Camel(s.name, false),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}
--- a/tools/goctl/model/sqlmodel/table2struct.go
+++ b/tools/goctl/model/sqlmodel/table2struct.go
@@ -0,0 +1,208 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"text/template"
+
+	util2 "zero/tools/modelctl/util"
+)
+
+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",
+	}
+)
+
+var modelTemplate = `
+type ( 
+
+	{{.ModelCamelWithUpperStart}}Model struct {
+		table string
+		conn  sqlx.SqlConn
+	}
+
+	{{.ModelCamelWithUpperStart}} struct {
+		{{.Fields}}
+	}
+)
+
+func New{{.ModelCamelWithUpperStart}}Model(table string, conn sqlx.SqlConn) *{{.ModelCamelWithUpperStart}}Model {
+	return &{{.ModelCamelWithUpperStart}}Model{table: table, conn: conn}
+}
+`
+
+const (
+	fieldTemplateText = "{{.NameCamelWithUpperStart}} {{.DataType}} `db:\"{{.NameWithUnderline}}\"` {{.Comment}}"
+)
+
+type (
+	Template struct {
+		ModelCamelWithUpperStart string
+		Fields                   string
+	}
+
+	StructField struct {
+		// 字段名称,下划线
+		NameWithUnderline string
+		// 字段名称,驼峰式,大写开头
+		NameCamelWithUpperStart string
+		// 字段名称,驼峰式,小写开头
+		NameCamelWithLowerStart string
+		// 字段数据类型
+		DataType string
+		// 字段注释
+		Comment string
+	}
+
+	GenStruct struct {
+		// 表对应的struct
+		TableStruct string `json:"tableStruct"`
+		// 表对应生成的model信息，参考模板${modelTemplate}
+		TableModel string `json:"tableModel"`
+		// 主键
+		PrimaryKey string `json:"primaryKey"`
+	}
+)
+
+func generateTypeModel(table string, fields []*Column) (*GenStruct, error) {
+	var resp GenStruct
+	structString, fieldsString, err := convertStruct(table, fields)
+	if err != nil {
+		return nil, err
+	}
+	templateStruct := Template{
+		ModelCamelWithUpperStart: util2.FmtUnderLine2Camel(table, true),
+		Fields:                   fieldsString,
+	}
+	tl, err := template.New("").Parse(modelTemplate)
+	if err != nil {
+		return nil, err
+	}
+	var resultBuffer = bytes.NewBufferString("")
+	err = tl.Execute(resultBuffer, templateStruct)
+	if err != nil {
+		return nil, err
+	}
+	resp.TableStruct = structString
+	resp.TableModel = resultBuffer.String()
+	return &resp, nil
+}
+
+// returns struct、fields、error
+func convertStruct(table string, columns []*Column) (string, string, error) {
+	var structBuffer, fieldsBuffer bytes.Buffer
+	structBuffer.WriteString("package model \n\n")
+	structBuffer.WriteString("type " + fmtUnderLine2Camel(table, true) + " struct {\n")
+	for index, item := range columns {
+		goType, ok := commonMysqlDataTypeMap[item.DataType]
+		if !ok {
+			return "", "", errors.New(fmt.Sprintf("table: %s,the data type %s of %s does not match", table, item.DataType, item.Name))
+		}
+		out, err := convertField(&StructField{
+			NameWithUnderline:       item.Name,
+			NameCamelWithUpperStart: fmtUnderLine2Camel(item.Name, true),
+			NameCamelWithLowerStart: fmtUnderLine2Camel(item.Name, false),
+			DataType:                goType,
+			Comment:                 item.Comment,
+		})
+		if err != nil {
+			return "", "", err
+		}
+		structBuffer.WriteString("\t" + out)
+		structBuffer.WriteString("\n")
+
+		if index == 0 {
+			fieldsBuffer.WriteString(out)
+		} else {
+			fieldsBuffer.WriteString("\t\t" + out)
+		}
+		if index < len(columns)-1 {
+			fieldsBuffer.WriteString("\n")
+		}
+
+	}
+	structBuffer.WriteString("}")
+	return structBuffer.String(), fieldsBuffer.String(), nil
+}
+
+// column转换成struct field
+func convertField(field *StructField) (string, error) {
+	if strings.TrimSpace(field.Comment) != "" {
+		field.Comment = "// " + field.Comment
+	}
+	tl, err := template.New("").Parse(fieldTemplateText)
+	if err != nil {
+		return "", err
+	}
+	buf := bytes.NewBufferString("")
+	err = tl.Execute(buf, field)
+	if err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}
+
+// 简单的下划线转驼峰格式
+func fmtUnderLine2Camel(in string, upperStart bool) string {
+	if strings.TrimSpace(in) == "" {
+		return ""
+	}
+	var words []string
+	if strings.Contains(in, "_") {
+		words = strings.Split(in, "_")
+		if len(words) == 0 {
+			return ""
+		}
+	}
+	if len(words) == 0 {
+		if !upperStart {
+			bts := []byte(in)
+			r := bytes.ToLower([]byte{bts[0]})
+			bts[0] = r[0]
+			return string(bts)
+		} else {
+			return strings.Title(in)
+		}
+	}
+	var buffer bytes.Buffer
+	for index, word := range words {
+		if strings.TrimSpace(word) == "" {
+			continue
+		}
+		bts := []byte(word)
+		if index == 0 && !upperStart {
+			bts[0] = bytes.ToLower([]byte{bts[0]})[0]
+			buffer.Write(bts)
+			continue
+		}
+		bts = bytes.Title(bts)
+		buffer.Write(bts)
+	}
+	return buffer.String()
+}
--- a/tools/goctl/model/sqlmodel/updatesql.go
+++ b/tools/goctl/model/sqlmodel/updatesql.go
@@ -0,0 +1,53 @@
+package sqlmodel
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"zero/core/stringx"
+)
+
+var updateTemplate = `
+func ({{.pointer}} *{{.model}}Model) Update(data {{.model}}{{.conditions}}) error {
+	sql := ` + "`" + `update ` + "` + " + `{{.pointer}}.table` + " + `" + ` set ` + "` +" + ` {{.modelWithLowerStart}}RowsWithPlaceHolder + ` + "` where" + ` {{.valueConditions}}` + "`\n" +
+	`	_, err := {{.pointer}}.conn.Exec(sql, {{.values}})
+	return err
+}
+`
+
+func (s *structExp) genUpdate() (string, error) {
+	var updateValues []string
+	var conditionsValues []string
+	for _, field := range s.Fields {
+		key := fmt.Sprintf("data.%s", field.name)
+		if stringx.Contains(s.conditions, field.tag) ||
+			stringx.Contains(s.conditions, field.name) {
+			conditionsValues = append(conditionsValues, key)
+		} else if !stringx.Contains(s.ignoreFields, field.name) && !stringx.Contains(s.ignoreFields, field.tag) {
+			updateValues = append(updateValues, key)
+		}
+	}
+	conditionExp, valueConditions := s.buildCondition()
+	if len(s.conditions) == 1 && s.conditions[0] == s.primaryKey {
+		conditionExp = ""
+	} else {
+		conditionExp = ", " + conditionExp
+	}
+	t := template.Must(template.New("updateTemplate").Parse(updateTemplate))
+	var tmplBytes bytes.Buffer
+	err := t.Execute(&tmplBytes, map[string]string{
+		"pointer":             "m",
+		"model":               s.name,
+		"values":              strings.Join(append(updateValues, conditionsValues...), ", "),
+		"primaryKey":          s.primaryKey,
+		"valueConditions":     valueConditions,
+		"conditions":          conditionExp,
+		"modelWithLowerStart": fmtUnderLine2Camel(s.name, false),
+	})
+	if err != nil {
+		return "", err
+	}
+	return tmplBytes.String(), nil
+}