goctl added

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
+}

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)
+}

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
+}

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
+}

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
+}

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
+}

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()
+}

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
+}