reactor sql generation

go.mod

@@ -41,6 +41,7 @@ require (
 	github.com/stretchr/testify v1.5.1
 	github.com/tmc/grpc-websocket-proxy v0.0.0-20171017195756-830351dc03c6 // indirect
 	github.com/urfave/cli v1.22.4
+	github.com/xwb1989/sqlparser v0.0.0-20180606152119-120387863bf2
 	github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb // indirect
 	go.etcd.io/etcd v0.0.0-20200402134248-51bdeb39e698
 	go.uber.org/automaxprocs v1.3.0

go.sum

@@ -266,6 +266,8 @@ github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 h1:eY9dn8+vbi4tKz5
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6 h1:YdYsPAZ2pC6Tow/nPZOPQ96O3hm/ToAkGsPLzedXERk=
 github.com/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
+github.com/xwb1989/sqlparser v0.0.0-20180606152119-120387863bf2 h1:zzrxE1FKn5ryBNl9eKOeqQ58Y/Qpo3Q9QNxKHX5uzzQ=
+github.com/xwb1989/sqlparser v0.0.0-20180606152119-120387863bf2/go.mod h1:hzfGeIUDq/j97IG+FhNqkowIyEcD88LrW6fyU3K3WqY=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb h1:ZkM6LRnq40pR1Ox0hTHlnpkcOTuFIDQpZ1IN8rKKhX0=
 github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb/go.mod h1:gqRgreBUhTSL0GeU64rtZ3Uq3wtjOa/TB2YfrtkCbVQ=

tools/goctl/goctl.go

@@ -16,6 +16,7 @@ import (
 	"github.com/tal-tech/go-zero/tools/goctl/configgen"
 	"github.com/tal-tech/go-zero/tools/goctl/docker"
 	"github.com/tal-tech/go-zero/tools/goctl/feature"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/command"
 	"github.com/urfave/cli"
 )
 
@@ -172,14 +173,19 @@ var (
 			Usage: "generate sql model",
 			Flags: []cli.Flag{
 				cli.StringFlag{
-					Name:  "config, c",
+					Name:  "src, s",
-					Usage: "the file that contains main function",
+					Usage: "the file path of sql",
 				},
 				cli.StringFlag{
 					Name:  "dir, d",
 					Usage: "the target dir",
 				},
+				cli.BoolFlag{
+					Name:  "cache, c",
+					Usage: "generate code with cache",
+				},
 			},
+			Action: command.Mysql,
 		},
 		{
 			Name:  "config",

tools/goctl/model/sql/command/command.go

@@ -0,0 +1,14 @@
+package command
+
+import (
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/gen"
+	"github.com/urfave/cli"
+)
+
+func Mysql(ctx *cli.Context) error {
+	src := ctx.String("src")
+	dir := ctx.String("dir")
+	cache := ctx.Bool("cache")
+	generator := gen.NewDefaultGenerator(src, dir)
+	return generator.Start(cache)
+}

tools/goctl/model/sql/converter/types.go

@@ -0,0 +1,46 @@
+package converter
+
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	commonMysqlDataTypeMap = map[string]string{
+		// For consistency, all integer types are converted to int64
+		"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",
+	}
+)
+
+func ConvertDataType(dataBaseType string) (goDataType string, err error) {
+	tp, ok := commonMysqlDataTypeMap[strings.ToLower(dataBaseType)]
+	if !ok {
+		err = fmt.Errorf("unexpected database type: %s", dataBaseType)
+		return
+	}
+	goDataType = tp
+	return
+}

tools/goctl/model/sql/gen/convert.go

@@ -1,108 +0,0 @@
-package gen
-
-import (
-	"errors"
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/tal-tech/go-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
-}

tools/goctl/model/sql/gen/delete.go

@@ -1,51 +1,46 @@
 package gen
 
 import (
-	"bytes"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/core/collection"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genDelete(table *InnerTable) (string, error) {
+func genDelete(table Table, withCache bool) (string, error) {
-	t, err := template.New("delete").Parse(sqltemplate.Delete)
+	keySet := collection.NewSet()
-	if err != nil {
+	keyVariableSet := collection.NewSet()
-		return "", nil
+	for fieldName, key := range table.CacheKey {
-	}
+		keySet.AddStr(key.KeyExpression)
-	deleteBuffer := new(bytes.Buffer)
+		if fieldName != table.PrimaryKey.Name.Source() {
-	keys := make([]string, 0)
+			keySet.AddStr(key.DataKeyExpression)
-	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)
+		keyVariableSet.AddStr(key.Variable)
 	}
-	var isOnlyPrimaryKeyCache = true
+	var containsIndexCache = false
 	for _, item := range table.Fields {
-		if item.IsPrimaryKey {
+		if item.IsKey {
-			continue
+			containsIndexCache = true
-		}
-		if item.Cache {
-			isOnlyPrimaryKeyCache = false
 			break
 		}
 	}
-	err = t.Execute(deleteBuffer, map[string]interface{}{
+	camel := table.Name.Snake2Camel()
-		"upperObject":     table.UpperCamelCase,
+	output, err := templatex.With("delete").
-		"containsCache":   table.ContainsCache,
+		Parse(template.Delete).
-		"isNotPrimaryKey": !isOnlyPrimaryKeyCache,
+		Execute(map[string]interface{}{
-		"lowerPrimaryKey": table.PrimaryField.LowerCamelCase,
+			"upperStartCamelObject":     camel,
-		"dataType":        table.PrimaryField.DataType,
+			"withCache":                 withCache,
-		"keys":            strings.Join(keys, "\r\n"),
+			"containsIndexCache":        containsIndexCache,
-		"snakePrimaryKey": table.PrimaryField.SnakeCase,
+			"lowerStartCamelPrimaryKey": stringx.From(camel).LowerStart(),
-		"keyValues":       strings.Join(keyValues, ", "),
+			"dataType":                  table.PrimaryKey.DataType,
-	})
+			"keys":                      strings.Join(keySet.KeysStr(), "\n"),
+			"originalPrimaryKey":        table.PrimaryKey.Name.Source(),
+			"keyValues":                 strings.Join(keyVariableSet.KeysStr(), ", "),
+		})
 	if err != nil {
 		return "", err
 	}
-	return deleteBuffer.String(), nil
+	return output.String(), nil
 }

tools/goctl/model/sql/gen/field.go

@@ -1,15 +1,15 @@
 package gen
 
 import (
-	"bytes"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/parser"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genFields(fields []*InnerField) (string, error) {
+func genFields(fields []parser.Field) (string, error) {
-	list := make([]string, 0)
+	var list []string
 	for _, field := range fields {
 		result, err := genField(field)
 		if err != nil {
@@ -17,23 +17,20 @@ func genFields(fields []*InnerField) (string, error) {
 		}
 		list = append(list, result)
 	}
-	return strings.Join(list, "\r\n"), nil
+	return strings.Join(list, "\n"), nil
 }
 
-func genField(field *InnerField) (string, error) {
+func genField(field parser.Field) (string, error) {
-	t, err := template.New("types").Parse(sqltemplate.Field)
+	output, err := templatex.With("types").
-	if err != nil {
+		Parse(template.Field).
-		return "", nil
+		Execute(map[string]string{
-	}
+			"name":    field.Name.Snake2Camel(),
-	var typeBuffer = new(bytes.Buffer)
+			"type":    field.DataType,
-	err = t.Execute(typeBuffer, map[string]string{
+			"tag":     field.Name.Source(),
-		"name":    field.UpperCamelCase,
+			"comment": field.Comment,
-		"type":    field.DataType,
+		})
-		"tag":     field.Tag,
-		"comment": field.Comment,
-	})
 	if err != nil {
 		return "", err
 	}
-	return typeBuffer.String(), nil
+	return output.String(), nil
 }

tools/goctl/model/sql/gen/findallbyfield.go

@@ -1,55 +0,0 @@
-package gen
-
-import (
-	"bytes"
-	"strings"
-	"text/template"
-
-	sqltemplate "github.com/tal-tech/go-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
-}

tools/goctl/model/sql/gen/findallbylimit.go

@@ -1,63 +0,0 @@
-package gen
-
-import (
-	"bytes"
-	"strings"
-	"text/template"
-
-	sqltemplate "github.com/tal-tech/go-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
-}

tools/goctl/model/sql/gen/findone.go

@@ -1,30 +1,27 @@
 package gen
 
 import (
-	"bytes"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
-	"text/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
-
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
 )
 
-func genFindOne(table *InnerTable) (string, error) {
+func genFindOne(table Table, withCache bool) (string, error) {
-	t, err := template.New("findOne").Parse(sqltemplate.FindOne)
+	camel := table.Name.Snake2Camel()
+	output, err := templatex.With("findOne").
+		Parse(template.FindOne).
+		Execute(map[string]interface{}{
+			"withCache":                 withCache,
+			"upperStartCamelObject":     camel,
+			"lowerStartCamelObject":     stringx.From(camel).LowerStart(),
+			"originalPrimaryKey":        table.PrimaryKey.Name.Source(),
+			"lowerStartCamelPrimaryKey": stringx.From(table.PrimaryKey.Name.Snake2Camel()).LowerStart(),
+			"dataType":                  table.PrimaryKey.DataType,
+			"cacheKey":                  table.CacheKey[table.PrimaryKey.Name.Source()].KeyExpression,
+			"cacheKeyVariable":          table.CacheKey[table.PrimaryKey.Name.Source()].Variable,
+		})
 	if err != nil {
 		return "", err
 	}
-	fineOneBuffer := new(bytes.Buffer)
+	return output.String(), nil
-	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
 }

tools/goctl/model/sql/gen/fineonebyfield.go

@@ -1,67 +1,41 @@
 package gen
 
 import (
-	"bytes"
+	"fmt"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genFineOneByField(table *InnerTable) (string, error) {
+func genFineOneByField(table Table, withCache bool) (string, error) {
-	t, err := template.New("findOneByField").Parse(sqltemplate.FindOneByField)
+	t := templatex.With("findOneByField").Parse(template.FindOneByField)
-	if err != nil {
+	var list []string
-		return "", err
+	camelTableName := table.Name.Snake2Camel()
-	}
-	list := make([]string, 0)
 	for _, field := range table.Fields {
 		if field.IsPrimaryKey {
 			continue
 		}
-		if field.QueryType != QueryOne {
+		camelFieldName := field.Name.Snake2Camel()
-			continue
+		output, err := t.Execute(map[string]interface{}{
-		}
+			"upperStartCamelObject":     camelTableName,
-		fineOneByFieldBuffer := new(bytes.Buffer)
+			"upperField":                camelFieldName,
-		upperFields := make([]string, 0)
+			"in":                        fmt.Sprintf("%s %s", stringx.From(camelFieldName).LowerStart(), field.DataType),
-		in := make([]string, 0)
+			"withCache":                 withCache,
-		expressionFields := make([]string, 0)
+			"cacheKey":                  table.CacheKey[field.Name.Source()].KeyExpression,
-		expressionValuesFields := make([]string, 0)
+			"cacheKeyVariable":          table.CacheKey[field.Name.Source()].Variable,
-		upperFields = append(upperFields, field.UpperCamelCase)
+			"primaryKeyLeft":            table.CacheKey[table.Name.Source()].Left,
-		in = append(in, field.LowerCamelCase+" "+field.DataType)
+			"lowerStartCamelObject":     stringx.From(camelTableName).LowerStart(),
-		expressionFields = append(expressionFields, field.SnakeCase+" = ?")
+			"lowerStartCamelField":      stringx.From(camelFieldName).LowerStart(),
-		expressionValuesFields = append(expressionValuesFields, field.LowerCamelCase)
+			"upperStartCamelPrimaryKey": table.PrimaryKey.Name.Snake2Camel(),
-		for _, withField := range field.WithFields {
+			"originalField":             field.Name.Source(),
-			upperFields = append(upperFields, withField.UpperCamelCase)
+			"originalPrimaryField":      table.PrimaryKey.Name.Source(),
-			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())
+		list = append(list, output.String())
 	}
-	return strings.Join(list, ""), nil
+	return strings.Join(list, "\n"), nil
 }

tools/goctl/model/sql/gen/gen.go

@@ -0,0 +1,160 @@
+package gen
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/parser"
+	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
+)
+
+const (
+	pwd             = "."
+	createTableFlag = `(?m)CREATE\s+TABLE`
+)
+
+type (
+	defaultGenerator struct {
+		source string
+		src    string
+		dir    string
+	}
+)
+
+func NewDefaultGenerator(src, dir string) *defaultGenerator {
+	if src == "" {
+		src = pwd
+	}
+	if dir == "" {
+		dir = pwd
+	}
+	return &defaultGenerator{src: src, dir: dir}
+}
+
+func (g *defaultGenerator) Start(withCache bool) error {
+	fileSrc, err := filepath.Abs(g.src)
+	if err != nil {
+		return err
+	}
+	dirAbs, err := filepath.Abs(g.dir)
+	if err != nil {
+		return err
+	}
+	err = util.MkdirIfNotExist(dirAbs)
+	if err != nil {
+		return err
+	}
+	data, err := ioutil.ReadFile(fileSrc)
+	if err != nil {
+		return err
+	}
+	g.source = string(data)
+	modelList, err := g.genFromDDL(withCache)
+	if err != nil {
+		return err
+	}
+
+	for tableName, code := range modelList {
+		filename := filepath.Join(dirAbs, fmt.Sprintf("%smodel.go", stringx.From(tableName).Lower()))
+		err = ioutil.WriteFile(filename, []byte(code), os.ModePerm)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ret1: key-table name,value-code
+func (g *defaultGenerator) genFromDDL(withCache bool) (map[string]string, error) {
+	ddlList := g.split()
+	m := make(map[string]string)
+	for _, ddl := range ddlList {
+		table, err := parser.Parse(ddl)
+		if err != nil {
+			return nil, err
+		}
+		code, err := g.genModel(*table, withCache)
+		if err != nil {
+			return nil, err
+		}
+		m[table.Name.Source()] = code
+	}
+	return m, nil
+}
+
+type (
+	Table struct {
+		parser.Table
+		CacheKey map[string]Key
+	}
+)
+
+func (g *defaultGenerator) genModel(in parser.Table, withCache bool) (string, error) {
+	t := templatex.With("model").
+		Parse(sqltemplate.Model).
+		GoFmt(true)
+
+	m, err := genCacheKeys(in)
+	if err != nil {
+		return "", err
+	}
+	importsCode := genImports()
+	var table Table
+	table.Table = in
+	table.CacheKey = m
+
+	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, withCache)
+	if err != nil {
+		return "", err
+	}
+	findOneByFieldCode, err := genFineOneByField(table, withCache)
+	if err != nil {
+		return "", err
+	}
+	findCode = append(findCode, findOneCode, findOneByFieldCode)
+	updateCode, err := genUpdate(table, withCache)
+	if err != nil {
+		return "", err
+	}
+	deleteCode, err := genDelete(table, withCache)
+	if err != nil {
+		return "", err
+	}
+	output, err := t.Execute(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
+	}
+	return output.String(), nil
+}

tools/goctl/model/sql/gen/imports.go

@@ -1,23 +1,9 @@
 package gen
 
 import (
-	"bytes"
-	"text/template"
-
 	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
 )
 
-func genImports(table *InnerTable) (string, error) {
+func genImports() string {
-	t, err := template.New("imports").Parse(sqltemplate.Imports)
+	return 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
 }

tools/goctl/model/sql/gen/insert.go

@@ -1,37 +1,38 @@
 package gen
 
 import (
-	"bytes"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genInsert(table *InnerTable) (string, error) {
+func genInsert(table Table) (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 {
+		camel := filed.Name.Snake2Camel()
+		if camel == "CreateTime" || camel == "UpdateTime" {
+			continue
+		}
+		if filed.IsPrimaryKey && table.PrimaryKey.AutoIncrement {
 			continue
 		}
 		expressions = append(expressions, "?")
-		expressionValues = append(expressionValues, "data."+filed.UpperCamelCase)
+		expressionValues = append(expressionValues, "data."+camel)
 	}
-	err = t.Execute(insertBuffer, map[string]interface{}{
+	camel := table.Name.Snake2Camel()
-		"upperObject":      table.UpperCamelCase,
+	output, err := templatex.With("insert").
-		"lowerObject":      table.LowerCamelCase,
+		Parse(template.Insert).
-		"expression":       strings.Join(expressions, ", "),
+		Execute(map[string]interface{}{
-		"expressionValues": strings.Join(expressionValues, ", "),
+			"upperStartCamelObject": camel,
-		"containsCache":    table.ContainsCache,
+			"lowerStartCamelObject": stringx.From(camel).LowerStart(),
-	})
+			"expression":            strings.Join(expressions, ", "),
+			"expressionValues":      strings.Join(expressionValues, ", "),
+		})
 	if err != nil {
 		return "", err
 	}
-	return insertBuffer.String(), nil
+	return output.String(), nil
 }

tools/goctl/model/sql/gen/keys.go

@@ -1,105 +1,50 @@
 package gen
 
 import (
-	"bytes"
+	"fmt"
-	"strings"
-	"text/template"
-)
 
-var (
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/parser"
-	cacheKeyExpressionTemplate = `cache{{.upperCamelTable}}{{.upperCamelField}}Prefix = "cache#{{.lowerCamelTable}}#{{.lowerCamelField}}#"`
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
-	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 (
+	// tableName:user
+	// {{prefix}}=cache
+	// key:id
 	Key struct {
-		Define      string // cacheKey define,如：cacheUserUserIdPrefix
+		VarExpression     string // cacheUserIdPrefix="cache#user#id#"
-		Value       string // cacheKey value expression,如：cache#user#userId#
+		Left              string // cacheUserIdPrefix
-		Expression  string // cacheKey expression，如:cacheUserUserIdPrefix="cache#user#userId#"
+		Right             string // cache#user#id#
-		KeyVariable string // cacheKey 声明变量，如：userIdKey
+		Variable          string // userIdKey
-		Key         string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, userId)
+		KeyExpression     string // userIdKey: = fmt.Sprintf("cache#user#id#%v", userId)
-		DataKey     string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, data.userId)
+		DataKeyExpression string // userIdKey: = fmt.Sprintf("cache#user#id#%v", data.userId)
-		RespKey     string // 缓存key的代码,如 userIdKey:=fmt.Sprintf("%s%v", cacheUserUserIdPrefix, resp.userId)
+		RespKeyExpression string // userIdKey: = fmt.Sprintf("cache#user#id#%v", resp.userId)
 	}
 )
 
-// key-数据库原始字段名,value-缓存key对象
+// key-数据库原始字段名,value-缓存key相关数据
-func genCacheKeys(table *InnerTable) (map[string]Key, error) {
+func genCacheKeys(table parser.Table) (map[string]Key, error) {
 	fields := table.Fields
-	var m = make(map[string]Key)
+	m := make(map[string]Key)
-	if !table.ContainsCache {
+	camelTableName := table.Name.Snake2Camel()
-		return m, nil
+	lowerStartCamelTableName := stringx.From(camelTableName).LowerStart()
-	}
 	for _, field := range fields {
-		if !field.Cache && !field.IsPrimaryKey {
+		if !field.IsKey {
 			continue
 		}
-		t, err := template.New("keyExpression").Parse(cacheKeyExpressionTemplate)
+		camelFieldName := field.Name.Snake2Camel()
-		if err != nil {
+		lowerStartCamelFieldName := stringx.From(camelFieldName).LowerStart()
-			return nil, err
+		left := fmt.Sprintf("cache%s%sPrefix", camelTableName, camelFieldName)
-		}
+		right := fmt.Sprintf("cache#%s#%s#", lowerStartCamelTableName, lowerStartCamelFieldName)
-		var expressionBuffer = new(bytes.Buffer)
+		variable := fmt.Sprintf("%s%sKey", lowerStartCamelTableName, camelFieldName)
-		err = t.Execute(expressionBuffer, map[string]string{
+		m[field.Name.Source()] = Key{
-			"upperCamelTable": table.UpperCamelCase,
+			VarExpression:     fmt.Sprintf(`%s = "%s"`, left, right),
-			"lowerCamelTable": table.LowerCamelCase,
+			Left:              left,
-			"upperCamelField": field.UpperCamelCase,
+			Right:             right,
-			"lowerCamelField": field.LowerCamelCase,
+			Variable:          variable,
-		})
+			KeyExpression:     fmt.Sprintf(`%s := fmt.Sprintf("cache#user#id#%s", %s)`, variable, "%s", lowerStartCamelFieldName),
-		if err != nil {
+			DataKeyExpression: fmt.Sprintf(`%s := fmt.Sprintf("cache#user#id#%s", data.%s)`, variable, "%s", lowerStartCamelFieldName),
-			return nil, err
+			RespKeyExpression: fmt.Sprintf(`%s := fmt.Sprintf("cache#user#id#%s", resp.%s)`, variable, "%s", lowerStartCamelFieldName),
-		}
-		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

tools/goctl/model/sql/gen/keys_test.go

@@ -1,100 +0,0 @@
-package gen
-
-import (
-	"log"
-	"testing"
-
-	"github.com/tal-tech/go-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)
-}

tools/goctl/model/sql/gen/model.go

@@ -1,86 +0,0 @@
-package gen
-
-import (
-	"bytes"
-	"go/format"
-	"strings"
-	"text/template"
-
-	"github.com/tal-tech/go-zero/core/logx"
-	sqltemplate "github.com/tal-tech/go-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
-}

tools/goctl/model/sql/gen/new.go

@@ -1,24 +1,18 @@
 package gen
 
 import (
-	"bytes"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
-	"text/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
-
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
 )
 
-func genNew(table *InnerTable) (string, error) {
+func genNew(table Table) (string, error) {
-	t, err := template.New("new").Parse(sqltemplate.New)
+	output, err := templatex.With("new").
+		Parse(template.New).
+		Execute(map[string]interface{}{
+			"upperStartCamelObject": table.Name.Snake2Camel(),
+		})
 	if err != nil {
 		return "", err
 	}
-	newBuffer := new(bytes.Buffer)
+	return output.String(), nil
-	err = t.Execute(newBuffer, map[string]interface{}{
-		"containsCache": table.ContainsCache,
-		"upperObject":   table.UpperCamelCase,
-	})
-	if err != nil {
-		return "", err
-	}
-	return newBuffer.String(), nil
 }

tools/goctl/model/sql/gen/shared.go

@@ -1,99 +0,0 @@
-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"`
-	}
-)

tools/goctl/model/sql/gen/split.go

@@ -0,0 +1,23 @@
+package gen
+
+import (
+	"regexp"
+)
+
+func (g *defaultGenerator) split() []string {
+	reg := regexp.MustCompile(createTableFlag)
+	index := reg.FindAllStringIndex(g.source, -1)
+	list := make([]string, 0)
+	source := g.source
+	for i := len(index) - 1; i >= 0; i-- {
+		subIndex := index[i]
+		if len(subIndex) == 0 {
+			continue
+		}
+		start := subIndex[0]
+		ddl := source[start:]
+		list = append(list, ddl)
+		source = source[:start]
+	}
+	return list
+}

tools/goctl/model/sql/gen/tag.go

@@ -1,26 +1,21 @@
 package gen
 
 import (
-	"bytes"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
-	"text/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
-
-	sqltemplate "github.com/tal-tech/go-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)
+	output, err := templatex.With("tag").
+		Parse(template.Tag).
+		Execute(map[string]interface{}{
+			"field": in,
+		})
 	if err != nil {
 		return "", err
 	}
-	var tagBuffer = new(bytes.Buffer)
+	return output.String(), nil
-	err = t.Execute(tagBuffer, map[string]interface{}{
-		"field": in,
-	})
-	if err != nil {
-		return "", err
-	}
-	return tagBuffer.String(), nil
 }

tools/goctl/model/sql/gen/types.go

@@ -1,30 +1,24 @@
 package gen
 
 import (
-	"bytes"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
-	"text/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
-
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
 )
 
-func genTypes(table *InnerTable) (string, error) {
+func genTypes(table Table) (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{}{
+	output, err := templatex.With("types").
-		"upperObject":   table.UpperCamelCase,
+		Parse(template.Types).
-		"containsCache": table.ContainsCache,
+		Execute(map[string]interface{}{
-		"fields":        fieldsString,
+			"upperStartCamelObject": table.Name.Snake2Camel(),
-	})
+			"fields":                fieldsString,
+		})
 	if err != nil {
 		return "", err
 	}
-	return typeBuffer.String(), nil
+	return output.String(), nil
 }

tools/goctl/model/sql/gen/update.go

@@ -1,38 +1,40 @@
 package gen
 
 import (
-	"bytes"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genUpdate(table *InnerTable) (string, error) {
+func genUpdate(table Table, withCache bool) (string, error) {
-	t, err := template.New("update").Parse(sqltemplate.Update)
+	expressionValues := make([]string, 0)
+	for _, filed := range table.Fields {
+		camel := filed.Name.Snake2Camel()
+		if camel == "CreateTime" || camel == "UpdateTime" {
+			continue
+		}
+		if filed.IsPrimaryKey {
+			continue
+		}
+		expressionValues = append(expressionValues, "data."+camel)
+	}
+	expressionValues = append(expressionValues, "data."+table.PrimaryKey.Name.Snake2Camel())
+	camelTableName := table.Name.Snake2Camel()
+	output, err := templatex.With("update").
+		Parse(template.Update).
+		Execute(map[string]interface{}{
+			"withCache":             withCache,
+			"upperStartCamelObject": camelTableName,
+			"primaryCacheKey":       table.CacheKey[table.PrimaryKey.Name.Source()].DataKeyExpression,
+			"primaryKeyVariable":    table.CacheKey[table.PrimaryKey.Name.Source()].Variable,
+			"lowerStartCamelObject": stringx.From(camelTableName).LowerStart(),
+			"originalPrimaryKey":    table.PrimaryKey.Name.Source(),
+			"expressionValues":      strings.Join(expressionValues, ", "),
+		})
 	if err != nil {
 		return "", nil
 	}
-	updateBuffer := new(bytes.Buffer)
+	return output.String(), nil
-	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
 }

tools/goctl/model/sql/gen/vars.go

@@ -1,36 +1,32 @@
 package gen
 
 import (
-	"bytes"
 	"strings"
-	"text/template"
 
-	sqltemplate "github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/template"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/tal-tech/go-zero/tools/goctl/util/templatex"
 )
 
-func genVars(table *InnerTable) (string, error) {
+func genVars(table Table) (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 {
+	for _, v := range table.CacheKey {
-		keys = append(keys, v.Expression)
+		keys = append(keys, v.VarExpression)
 	}
-	err = t.Execute(varBuffer, map[string]interface{}{
+	camel := table.Name.Snake2Camel()
-		"lowerObject":     table.LowerCamelCase,
+	output, err := templatex.With("var").
-		"upperObject":     table.UpperCamelCase,
+		Parse(template.Vars).
-		"createNotFound":  table.CreateNotFound,
+		GoFmt(true).
-		"keysDefine":      strings.Join(keys, "\r\n"),
+		Execute(map[string]interface{}{
-		"snakePrimaryKey": table.PrimaryField.SnakeCase,
+			"lowerStartCamelObject": stringx.From(camel).LowerStart(),
-	})
+			"upperStartCamelObject": camel,
+			"cacheKeys":             strings.Join(keys, "\r\n"),
+			"autoIncrement":         table.PrimaryKey.AutoIncrement,
+			"originalPrimaryKey":    table.PrimaryKey.Name.Source(),
+		})
 	if err != nil {
 		return "", err
 	}
-	return varBuffer.String(), nil
+
+	return output.String(), nil
 }

tools/goctl/model/sql/parser/error.go

@@ -0,0 +1,11 @@
+package parser
+
+import (
+	"errors"
+)
+
+var (
+	unSupportDDL        = errors.New("unexpected type")
+	tableBodyIsNotFound = errors.New("create table spec not found")
+	errPrimaryKey       = errors.New("unexpected joint primary key")
+)

tools/goctl/model/sql/parser/parser.go

@@ -0,0 +1,104 @@
+package parser
+
+import (
+	"fmt"
+
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/converter"
+	"github.com/tal-tech/go-zero/tools/goctl/util/stringx"
+	"github.com/xwb1989/sqlparser"
+)
+
+type (
+	Table struct {
+		Name       stringx.String
+		PrimaryKey Primary
+		Fields     []Field
+	}
+	Primary struct {
+		Field
+		AutoIncrement bool
+	}
+	Field struct {
+		Name         stringx.String
+		DataBaseType string
+		DataType     string
+		IsKey        bool
+		IsPrimaryKey bool
+		Comment      string
+	}
+)
+
+func Parse(ddl string) (*Table, error) {
+	stmt, err := sqlparser.ParseStrictDDL(ddl)
+	if err != nil {
+		return nil, err
+	}
+	ddlStmt, ok := stmt.(*sqlparser.DDL)
+	if !ok {
+		return nil, unSupportDDL
+	}
+	action := ddlStmt.Action
+	if action != sqlparser.CreateStr {
+		return nil, fmt.Errorf("expected [CREATE] action,but found: %s", action)
+	}
+	tableName := ddlStmt.NewName.Name.String()
+	tableSpec := ddlStmt.TableSpec
+	if tableSpec == nil {
+		return nil, tableBodyIsNotFound
+	}
+
+	columns := tableSpec.Columns
+	indexes := tableSpec.Indexes
+
+	for _, index := range indexes {
+		info := index.Info
+		if info == nil {
+			continue
+		}
+		if info.Primary {
+			if len(index.Columns) > 1 {
+				return nil, errPrimaryKey
+			}
+			break
+		}
+	}
+	var (
+		fields     []Field
+		primaryKey Primary
+	)
+	for _, column := range columns {
+		if column == nil {
+			continue
+		}
+		var comment string
+		if column.Type.Comment != nil {
+			comment = string(column.Type.Comment.Val)
+		}
+		dataType, err := converter.ConvertDataType(column.Type.Type)
+		if err != nil {
+			return nil, err
+		}
+		var field Field
+		field.Name = stringx.From(column.Name.String())
+		field.DataBaseType = column.Type.Type
+		field.DataType = dataType
+		field.Comment = comment
+		// see line 1194 https://github.com/xwb1989/sqlparser/blob/master/ast.go
+		field.IsKey = column.Type.KeyOpt != 0
+		field.IsPrimaryKey = column.Type.KeyOpt == 1
+		fields = append(fields, field)
+		// see line 1195 https://github.com/xwb1989/sqlparser/blob/master/ast.go
+		if column.Type.KeyOpt == 1 {
+			primaryKey.Field = field
+			if column.Type.Autoincrement {
+				primaryKey.AutoIncrement = true
+			}
+		}
+	}
+	return &Table{
+		Name:       stringx.From(tableName),
+		PrimaryKey: primaryKey,
+		Fields:     fields,
+	}, nil
+
+}

tools/goctl/model/sql/sqlctl.go

@@ -1,22 +0,0 @@
-package sqlgen
-
-import (
-	"errors"
-
-	"github.com/tal-tech/go-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)
-}

tools/goctl/model/sql/template/delete.go

@@ -1,17 +1,17 @@
-package sqltemplate
+package template
 
 var Delete = `
-func (m *{{.upperObject}}Model) Delete({{.lowerPrimaryKey}} {{.dataType}}) error {
+func (m *{{.upperStartCamelObject}}Model) Delete({{.lowerStartCamelPrimaryKey}} {{.dataType}}) error {
-	{{if .containsCache}}{{if .isNotPrimaryKey}}data,err:=m.FindOne({{.lowerPrimaryKey}})
+	{{if .withCache}}{{if .containsIndexCache}}data,err:=m.FindOne({{.lowerStartCamelPrimaryKey}})
 	if err!=nil{
 		return err
 	}{{end}}
 	{{.keys}}
-    _, err {{if .isNotPrimaryKey}}={{else}}:={{end}} m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+    _, err {{if .containsIndexCache}}={{else}}:={{end}} m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
-		query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.snakePrimaryKey}} = ?` + "`" + `
+		query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
-		return conn.Exec(query, {{.lowerPrimaryKey}})
+		return conn.Exec(query, {{.lowerStartCamelPrimaryKey}})
-	}, {{.keyValues}}){{else}}query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.snakePrimaryKey}} = ?` + "`" + `
+	}, {{.keyValues}}){{else}}query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
-		_,err:=m.ExecNoCache(query, {{.lowerPrimaryKey}}){{end}}
+		_,err:=m.ExecNoCache(query, {{.lowerStartCamelPrimaryKey}}){{end}}
 	return err
 }
 `

tools/goctl/model/sql/template/errors.go

@@ -1,4 +1,4 @@
-package sqltemplate
+package template
 
 var Error = `package model
 

tools/goctl/model/sql/template/field.go

@@ -1,3 +1,3 @@
-package sqltemplate
+package template
 
 var Field = `{{.name}} {{.type}} {{.tag}} {{.comment}}`

tools/goctl/model/sql/template/find.go

@@ -1,13 +1,13 @@
-package sqltemplate
+package template
 
 // 通过id查询
 var FindOne = `
-func (m *{{.upperObject}}Model) FindOne({{.lowerPrimaryKey}} {{.dataType}}) (*{{.upperObject}}, error) {
+func (m *{{.upperStartCamelObject}}Model) FindOne({{.lowerStartCamelPrimaryKey}} {{.dataType}}) (*{{.upperStartCamelObject}}, error) {
 	{{if .withCache}}{{.cacheKey}}
-	var resp {{.upperObject}}
+	var resp {{.upperStartCamelObject}}
 	err := m.QueryRow(&resp, {{.cacheKeyVariable}}, func(conn sqlx.SqlConn, v interface{}) error {
-		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakePrimaryKey}} = ? limit 1` + "`" + `
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryKey}} = ? limit 1` + "`" + `
-		return conn.QueryRow(v, query, {{.lowerPrimaryKey}})
+		return conn.QueryRow(v, query, {{.lowerStartCamelPrimaryKey}})
 	})
 	switch err {
 	case nil:
@@ -16,9 +16,9 @@ func (m *{{.upperObject}}Model) FindOne({{.lowerPrimaryKey}} {{.dataType}}) (*{{
 		return nil, ErrNotFound
 	default:
 		return nil, err
-	}{{else}}query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakePrimaryKey}} = ? limit 1` + "`" + `
+	}{{else}}query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryKey}} = ? limit 1` + "`" + `
-	var resp {{.upperObject}}
+	var resp {{.upperStartCamelObject}}
-	err := m.QueryRowNoCache(&resp, query, {{.lowerPrimaryKey}})
+	err := m.QueryRowNoCache(&resp, query, {{.lowerStartCamelPrimaryKey}})
 	switch err {
 	case nil:
 		return &resp, nil
@@ -32,19 +32,19 @@ func (m *{{.upperObject}}Model) FindOne({{.lowerPrimaryKey}} {{.dataType}}) (*{{
 
 // 通过指定字段查询
 var FindOneByField = `
-func (m *{{.upperObject}}Model) FindOneBy{{.upperFields}}({{.in}}) (*{{.upperObject}}, error) {
+func (m *{{.upperStartCamelObject}}Model) FindOneBy{{.upperField}}({{.in}}) (*{{.upperStartCamelObject}}, error) {
-	{{if .onlyOneFiled}}{{if .withCache}}{{.cacheKey}}
+	{{if .withCache}}{{.cacheKey}}
-	var resp {{.upperObject}}
+	var resp {{.upperStartCamelObject}}
 	err := m.QueryRowIndex(&resp, {{.cacheKeyVariable}}, func(primary interface{}) string {
-		return fmt.Sprintf("%s%v", {{.primaryKeyDefine}}, primary)
+		return fmt.Sprintf("%s%v", {{.primaryKeyLeft}}, primary)
 	}, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
-		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.snakeField}} = ? limit 1` + "`" + `
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalField}} = ? limit 1` + "`" + `
-		if err := conn.QueryRow(&resp, query, {{.lowerField}}); err != nil {
+		if err := conn.QueryRow(&resp, query, {{.lowerStartCamelField}}); err != nil {
 			return nil, err
 		}
-		return resp.{{.UpperPrimaryKey}}, nil
+		return resp.{{.upperStartCamelPrimaryKey}}, nil
 	}, func(conn sqlx.SqlConn, v, primary interface{}) error {
-		query := ` + "`" + `select ` + "`" + ` + {{.lowerObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.primarySnakeField}} = ? limit 1` + "`" + `
+		query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryField}} = ? limit 1` + "`" + `
 		return conn.QueryRow(v, query, primary)
 	})
 	switch err {
@@ -54,62 +54,6 @@ func (m *{{.upperObject}}Model) FindOneBy{{.upperFields}}({{.in}}) (*{{.upperObj
 		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
 }
 `

tools/goctl/model/sql/template/import.go

@@ -1,13 +1,12 @@
-package sqltemplate
+package template
 
 var Imports = `
 import (
-	{{if .containsCache}}"database/sql"
+	"database/sql"
-	"fmt"{{end}}
 	"strings"
 	"time"
 
-    "github.com/tal-tech/go-zero/core/stores/cache"
+  "github.com/tal-tech/go-zero/core/stores/cache"
 	"github.com/tal-tech/go-zero/core/stores/sqlc"
 	"github.com/tal-tech/go-zero/core/stores/sqlx"
 	"github.com/tal-tech/go-zero/core/stringx"

tools/goctl/model/sql/template/insert.go

@@ -1,8 +1,8 @@
-package sqltemplate
+package template
 
 var Insert = `
-func (m *{{.upperObject}}Model) Insert(data {{.upperObject}}) error {
+func (m *{{.upperStartCamelObject}}Model) Insert(data {{.upperStartCamelObject}}) error {
-	query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "`(` + " + `{{.lowerObject}}RowsExpectAutoSet` + " + `) value ({{.expression}})` " + `
+	query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "`(` + " + `{{.lowerStartCamelObject}}RowsExpectAutoSet` + " + `) value ({{.expression}})` " + `
 	_, err := m.ExecNoCache(query, {{.expressionValues}})
 	return err
 }

tools/goctl/model/sql/template/model.go

@@ -1,4 +1,4 @@
-package sqltemplate
+package template
 
 var Model = `package model
 {{.imports}}

tools/goctl/model/sql/template/new.go

@@ -1,8 +1,8 @@
-package sqltemplate
+package template
 
 var New = `
-func New{{.upperObject}}Model(conn sqlx.SqlConn, c cache.CacheConf, table string) *{{.upperObject}}Model {
+func New{{.upperStartCamelObject}}Model(conn sqlx.SqlConn, c cache.CacheConf, table string) *{{.upperStartCamelObject}}Model {
-	return &{{.upperObject}}Model{
+	return &{{.upperStartCamelObject}}Model{
 		CachedConn: sqlc.NewConn(conn, c),
 		table:      table,
 	}

tools/goctl/model/sql/template/tag.go

@@ -1,3 +1,3 @@
-package sqltemplate
+package template
 
 var Tag = "`db:\"{{.field}}\"`"

tools/goctl/model/sql/template/types.go

@@ -1,13 +1,13 @@
-package sqltemplate
+package template
 
 var Types = `
 type (
-	{{.upperObject}}Model struct {
+	{{.upperStartCamelObject}}Model struct {
 		sqlc.CachedConn
 		table string
 	}
 
-	{{.upperObject}} struct {
+	{{.upperStartCamelObject}} struct {
 		{{.fields}}
 	}
 )

tools/goctl/model/sql/template/update.go

@@ -1,12 +1,12 @@
-package sqltemplate
+package template
 
 var Update = `
-func (m *{{.upperObject}}Model) Update(data {{.upperObject}}) error {
+func (m *{{.upperStartCamelObject}}Model) Update(data {{.upperStartCamelObject}}) error {
-	{{if .containsCache}}{{.primaryCacheKey}}
+	{{if .withCache}}{{.primaryCacheKey}}
     _, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
-		query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerObject}}RowsWithPlaceHolder` + " + `" + ` where {{.primarySnakeCase}} = ?` + "`" + `
+		query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerStartCamelObject}}RowsWithPlaceHolder` + " + `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
 		return conn.Exec(query, {{.expressionValues}})
-	}, {{.primaryKeyVariable}}){{else}}query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerObject}}RowsWithPlaceHolder` + " + `" + ` where {{.primarySnakeCase}} = ?` + "`" + `
+	}, {{.primaryKeyVariable}}){{else}}query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerStartCamelObject}}RowsWithPlaceHolder` + " + `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
     _,err:=m.ExecNoCache(query, {{.expressionValues}}){{end}}
 	return err
 }

tools/goctl/model/sql/template/vars.go

@@ -1,14 +1,14 @@
-package sqltemplate
+package template
 
 var Vars = `
 var (
-	{{.lowerObject}}FieldNames          = builderx.FieldNames(&{{.upperObject}}{})
+	{{.lowerStartCamelObject}}FieldNames          = builderx.FieldNames(&{{.upperStartCamelObject}}{})
-	{{.lowerObject}}Rows                = strings.Join({{.lowerObject}}FieldNames, ",")
+	{{.lowerStartCamelObject}}Rows                = strings.Join({{.lowerStartCamelObject}}FieldNames, ",")
-	{{.lowerObject}}RowsExpectAutoSet   = strings.Join(stringx.Remove({{.lowerObject}}FieldNames, "{{.snakePrimaryKey}}", "create_time", "update_time"), ",")
+	{{.lowerStartCamelObject}}RowsExpectAutoSet   = strings.Join(stringx.Remove({{.lowerStartCamelObject}}FieldNames, {{.if autoIncrement}}"{{.originalPrimaryKey}}",{{end}} "create_time", "update_time"), ",")
-	{{.lowerObject}}RowsWithPlaceHolder = strings.Join(stringx.Remove({{.lowerObject}}FieldNames, "{{.snakePrimaryKey}}", "create_time", "update_time"), "=?,") + "=?"
+	{{.lowerStartCamelObject}}RowsWithPlaceHolder = strings.Join(stringx.Remove({{.lowerStartCamelObject}}FieldNames, "{{.originalPrimaryKey}}", "create_time", "update_time"), "=?,") + "=?"
 
-	{{.keysDefine}}
+	{{.cacheKeys}}
 
-	{{if .createNotFound}}ErrNotFound               = sqlx.ErrNotFound{{end}}
+	ErrNotFound   = sqlx.ErrNotFound
 )
 `

tools/goctl/model/sql/util/stringurtl_test.go

@@ -1,12 +0,0 @@
-package util
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestFormatField(t *testing.T) {
-	var in = "go_java"
-	snakeCase, upperCase, lowerCase := FormatField(in)
-	fmt.Println(snakeCase, upperCase, lowerCase)
-}

tools/goctl/model/sql/util/stringutil.go

@@ -1,48 +0,0 @@
-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)
-}

tools/goctl/util/stringx/string.go

@@ -0,0 +1,145 @@
+package stringx
+
+import (
+	"bytes"
+	"strings"
+	"unicode"
+)
+
+const (
+	emptyString = ""
+)
+
+type (
+	String struct {
+		source string
+	}
+)
+
+func From(data string) String {
+	return String{source: data}
+}
+func (s String) IsEmptyOrSpace() bool {
+	if len(s.source) == 0 {
+		return true
+	}
+	if strings.TrimSpace(s.source) == "" {
+		return true
+	}
+	return false
+}
+
+func (s String) Lower() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	return strings.ToLower(s.source)
+}
+func (s String) Upper() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	return strings.ToUpper(s.source)
+}
+func (s String) Title() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	return strings.Title(s.source)
+}
+
+// snake->camel(upper start)
+func (s String) Snake2Camel() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	list := s.splitBy(func(r rune) bool {
+		return r == '_'
+	}, true)
+	var target []string
+	for _, item := range list {
+		target = append(target, From(item).Title())
+	}
+	return strings.Join(target, "")
+}
+
+// camel->snake
+func (s String) Camel2Snake() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	list := s.splitBy(func(r rune) bool {
+		return unicode.IsUpper(r)
+	}, false)
+	var target []string
+	for _, item := range list {
+		target = append(target, From(item).Lower())
+	}
+	return strings.Join(target, "_")
+}
+
+// return original string if rune is not letter at index 0
+func (s String) LowerStart() string {
+	if s.IsEmptyOrSpace() {
+		return s.source
+	}
+	r := rune(s.source[0])
+	if !unicode.IsUpper(r) && !unicode.IsLower(r) {
+		return s.source
+	}
+	return string(r) + s.source[1:]
+}
+
+// it will not ignore spaces
+func (s String) splitBy(fn func(r rune) bool, remove bool) []string {
+	if s.IsEmptyOrSpace() {
+		return nil
+	}
+	var list []string
+	buffer := new(bytes.Buffer)
+	for _, r := range s.source {
+		if fn(r) {
+			if buffer.Len() != 0 {
+				list = append(list, buffer.String())
+				buffer.Reset()
+			}
+			if !remove {
+				buffer.WriteRune(r)
+			}
+			continue
+		}
+		buffer.WriteRune(r)
+	}
+	if buffer.Len() != 0 {
+		list = append(list, buffer.String())
+	}
+	return list
+}
+
+func (s String) Replace(old, new string) string {
+	return strings.ReplaceAll(s.source, old, new)
+}
+
+func (s String) ReplaceAll(old, new string) string {
+	return strings.ReplaceAll(s.source, old, new)
+}
+
+func (s String) Source() string {
+	return s.source
+}
+
+func Title(s string) string {
+	if len(s) == 0 {
+		return s
+	}
+
+	return strings.ToUpper(s[:1]) + s[1:]
+}
+
+func Untitle(s string) string {
+	if len(s) == 0 {
+		return s
+	}
+
+	return strings.ToLower(s[:1]) + s[1:]
+}

tools/goctl/util/stringx/string_test.go

@@ -0,0 +1,42 @@
+package stringx
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestString_IsEmptyOrSpace(t *testing.T) {
+	ret := From("  ").IsEmptyOrSpace()
+	assert.Equal(t, true, ret)
+	ret2 := From("ll??").IsEmptyOrSpace()
+	assert.Equal(t, false, ret2)
+	ret3 := From(`
+   		`).IsEmptyOrSpace()
+	assert.Equal(t, true, ret3)
+}
+
+func TestString_Snake2Camel(t *testing.T) {
+	ret := From("____this_is_snake").Snake2Camel()
+	assert.Equal(t, "ThisIsSnake", ret)
+
+	ret2 := From("测试_test_Data").Snake2Camel()
+	assert.Equal(t, "测试TestData", ret2)
+
+	ret3 := From("___").Snake2Camel()
+	assert.Equal(t, "", ret3)
+
+	ret4 := From("testData_").Snake2Camel()
+	assert.Equal(t, "TestData", ret4)
+
+	ret5 := From("testDataTestData").Snake2Camel()
+	assert.Equal(t, "TestDataTestData", ret5)
+}
+
+func TestString_Camel2Snake(t *testing.T) {
+	ret := From("ThisIsCCCamel").Camel2Snake()
+	assert.Equal(t, "this_is_c_c_camel", ret)
+
+	ret2 := From("测试Test_Data_test_data").Camel2Snake()
+	assert.Equal(t, "测试_test__data_test_data", ret2)
+}

tools/goctl/util/templatex/templatex.go

@@ -0,0 +1,67 @@
+package templatex
+
+import (
+	"bytes"
+	goformat "go/format"
+	"io/ioutil"
+	"os"
+	"text/template"
+)
+
+type (
+	defaultTemplate struct {
+		name     string
+		text     string
+		goFmt    bool
+		savePath string
+	}
+)
+
+func With(name string) *defaultTemplate {
+	return &defaultTemplate{
+		name: name,
+	}
+}
+func (t *defaultTemplate) Parse(text string) *defaultTemplate {
+	t.text = text
+	return t
+}
+
+func (t *defaultTemplate) GoFmt(format bool) *defaultTemplate {
+	t.goFmt = format
+	return t
+}
+
+func (t *defaultTemplate) SaveTo(data interface{}, path string) error {
+	output, err := t.execute(data)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(path, output.Bytes(), os.ModePerm)
+}
+
+func (t *defaultTemplate) Execute(data interface{}) (*bytes.Buffer, error) {
+	return t.execute(data)
+}
+
+func (t *defaultTemplate) execute(data interface{}) (*bytes.Buffer, error) {
+	tem, err := template.New(t.name).Parse(t.text)
+	if err != nil {
+		return nil, err
+	}
+	buf := new(bytes.Buffer)
+	err = tem.Execute(buf, data)
+	if err != nil {
+		return nil, err
+	}
+	if !t.goFmt {
+		return buf, nil
+	}
+	formatOutput, err := goformat.Source(buf.Bytes())
+	if err != nil {
+		return nil, err
+	}
+	buf.Reset()
+	buf.Write(formatOutput)
+	return buf, nil
+}