Model Commands

    goctl model is one of the components in the tool module under go-zero. It currently supports the recognition of mysql ddl for model layer code generation. It can be selectively generated with or without redis cache through the command line or idea plug-in (supported soon) The code logic.

    • Generated by ddl

      CURD code can be quickly generated after executing the above command.

      2.   │   ├── error.go
      3.   │   └── usermodel.go

    • Generated by datasource

      1.   $ goctl model mysql datasource -url="user:password@tcp(127.0.0.1:3306)/database" -table="*"  -dir="./model"

    • Example code

      1.   package model
      3.   import (
      4.       "database/sql"
      5.       "fmt"
      6.       "strings"
      7.       "time"
      9.       "github.com/tal-tech/go-zero/core/stores/cache"
      10.       "github.com/tal-tech/go-zero/core/stores/sqlc"
      11.       "github.com/tal-tech/go-zero/core/stores/sqlx"
      12.       "github.com/tal-tech/go-zero/core/stringx"
      13.       "github.com/tal-tech/go-zero/tools/goctl/model/sql/builderx"
      14.   )
      16.   var (
      17.       userFieldNames          = builderx.RawFieldNames(&User{})
      18.       userRows                = strings.Join(userFieldNames, ",")
      19.       userRowsExpectAutoSet   = strings.Join(stringx.Remove(userFieldNames, "`id`", "`create_time`", "`update_time`"), ",")
      20.       userRowsWithPlaceHolder = strings.Join(stringx.Remove(userFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
      22.       cacheUserNamePrefix   = "cache#User#name#"
      23.       cacheUserMobilePrefix = "cache#User#mobile#"
      24.       cacheUserIdPrefix     = "cache#User#id#"
      25.       cacheUserPrefix       = "cache#User#user#"
      26.   )
      28.   type (
      29.       UserModel interface {
      30.           Insert(data User) (sql.Result, error)
      31.           FindOne(id int64) (*User, error)
      32.           FindOneByUser(user string) (*User, error)
      33.           FindOneByName(name string) (*User, error)
      34.           FindOneByMobile(mobile string) (*User, error)
      35.           Update(data User) error
      36.           Delete(id int64) error
      37.       }
      39.       defaultUserModel struct {
      40.           sqlc.CachedConn
      41.           table string
      42.       }
      44.       User struct {
      45.           Id         int64     `db:"id"`
      46.           User       string    `db:"user"`     // user
      47.           Name       string    `db:"name"`     // user name
      48.           Password   string    `db:"password"` // user password
      49.           Mobile     string    `db:"mobile"`   // mobile
      50.           Gender     string    `db:"gender"`   // male｜female｜secret
      51.           Nickname   string    `db:"nickname"` // nickname
      52.           CreateTime time.Time `db:"create_time"`
      53.           UpdateTime time.Time `db:"update_time"`
      54.       }
      55.   )
      57.   func NewUserModel(conn sqlx.SqlConn, c cache.CacheConf) UserModel {
      58.       return &defaultUserModel{
      59.           CachedConn: sqlc.NewConn(conn, c),
      60.           table:      "`user`",
      61.       }
      62.   }
      64.   func (m *defaultUserModel) Insert(data User) (sql.Result, error) {
      65.       userNameKey := fmt.Sprintf("%s%v", cacheUserNamePrefix, data.Name)
      66.       userMobileKey := fmt.Sprintf("%s%v", cacheUserMobilePrefix, data.Mobile)
      67.       userKey := fmt.Sprintf("%s%v", cacheUserPrefix, data.User)
      68.       ret, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
      69.           query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?)", m.table, userRowsExpectAutoSet)
      70.           return conn.Exec(query, data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname)
      71.       }, userNameKey, userMobileKey, userKey)
      72.   }
      74.   func (m *defaultUserModel) FindOne(id int64) (*User, error) {
      75.       userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, id)
      76.       var resp User
      78.           query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", userRows, m.table)
      79.           return conn.QueryRow(v, query, id)
      80.       })
      81.       switch err {
      82.       case nil:
      83.           return &resp, nil
      84.       case sqlc.ErrNotFound:
      85.           return nil, ErrNotFound
      86.       default:
      87.           return nil, err
      88.       }
      89.   }
      91.   func (m *defaultUserModel) FindOneByUser(user string) (*User, error) {
      92.       userKey := fmt.Sprintf("%s%v", cacheUserPrefix, user)
      93.       var resp User
      94.       err := m.QueryRowIndex(&resp, userKey, m.formatPrimary, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
      95.           query := fmt.Sprintf("select %s from %s where `user` = ? limit 1", userRows, m.table)
      96.           if err := conn.QueryRow(&resp, query, user); err != nil {
      97.               return nil, err
      98.           }
      99.           return resp.Id, nil
      100.       }, m.queryPrimary)
      101.       switch err {
      102.       case nil:
      103.           return &resp, nil
      104.       case sqlc.ErrNotFound:
      105.           return nil, ErrNotFound
      106.       default:
      107.           return nil, err
      108.       }
      109.   }
      111.   func (m *defaultUserModel) FindOneByName(name string) (*User, error) {
      112.       userNameKey := fmt.Sprintf("%s%v", cacheUserNamePrefix, name)
      113.       var resp User
      114.       err := m.QueryRowIndex(&resp, userNameKey, m.formatPrimary, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
      115.           query := fmt.Sprintf("select %s from %s where `name` = ? limit 1", userRows, m.table)
      116.           if err := conn.QueryRow(&resp, query, name); err != nil {
      117.               return nil, err
      118.           }
      119.           return resp.Id, nil
      120.       }, m.queryPrimary)
      121.       switch err {
      122.       case nil:
      123.           return &resp, nil
      124.       case sqlc.ErrNotFound:
      125.           return nil, ErrNotFound
      126.       default:
      127.           return nil, err
      128.       }
      129.   }
      131.   func (m *defaultUserModel) FindOneByMobile(mobile string) (*User, error) {
      132.       userMobileKey := fmt.Sprintf("%s%v", cacheUserMobilePrefix, mobile)
      133.       var resp User
      134.       err := m.QueryRowIndex(&resp, userMobileKey, m.formatPrimary, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
      135.           query := fmt.Sprintf("select %s from %s where `mobile` = ? limit 1", userRows, m.table)
      136.           if err := conn.QueryRow(&resp, query, mobile); err != nil {
      137.               return nil, err
      138.           }
      139.           return resp.Id, nil
      140.       }, m.queryPrimary)
      141.       switch err {
      142.       case nil:
      143.           return &resp, nil
      144.       case sqlc.ErrNotFound:
      145.           return nil, ErrNotFound
      146.       default:
      147.           return nil, err
      148.       }
      149.   }
      151.   func (m *defaultUserModel) Update(data User) error {
      152.       userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, data.Id)
      153.       _, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
      154.           query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, userRowsWithPlaceHolder)
      155.       }, userIdKey)
      156.       return err
      159.   func (m *defaultUserModel) Delete(id int64) error {
      160.       data, err := m.FindOne(id)
      161.       if err != nil {
      162.           return err
      163.       }
      165.       userNameKey := fmt.Sprintf("%s%v", cacheUserNamePrefix, data.Name)
      166.       userMobileKey := fmt.Sprintf("%s%v", cacheUserMobilePrefix, data.Mobile)
      167.       userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, id)
      168.       userKey := fmt.Sprintf("%s%v", cacheUserPrefix, data.User)
      169.       _, err = m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
      170.           query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
      171.           return conn.Exec(query, id)
      172.       }, userNameKey, userMobileKey, userIdKey, userKey)
      173.       return err
      174.   }
      176.   func (m *defaultUserModel) formatPrimary(primary interface{}) string {
      177.       return fmt.Sprintf("%s%v", cacheUserIdPrefix, primary)
      178.   }
      180.   func (m *defaultUserModel) queryPrimary(conn sqlx.SqlConn, v, primary interface{}) error {
      181.       query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", userRows, m.table)
      182.       return conn.QueryRow(v, query, primary)
      183.   }
    1. NAME:
    2.    goctl model mysql - generate mysql model"
    4. USAGE:
    5.    goctl model mysql command [command options] [arguments...]
    7. COMMANDS:
    8.    ddl         generate mysql model from ddl"
    9.    datasource  generate model from datasource"
    11. OPTIONS:
    12.    --help, -h  show help

    • Default rule

      By default, users will create createTime and updateTime fields (ignoring case and underscore naming style) when creating a table, and the default values are both CURRENT_TIMESTAMP, and updateTime supports ON UPDATE CURRENT_TIMESTAMP. For these two fields, insert, It will be removed when update is not in the assignment scope. Of course, if you don’t need these two fields, it does not matter.

    • With cache mode

      • ddl

        1. $ goctl model mysql -src={patterns} -dir={dir} -cache
        1. NAME:
        2.    goctl model mysql ddl - generate mysql model from ddl
        4. USAGE:
        5.    goctl model mysql ddl [command options] [arguments...]
        7. OPTIONS:
        8.    --src value, -s value  the path or path globbing patterns of the ddl
        9.    --dir value, -d value  the target dir
        10.    --style value          the file naming format, see [https://github.com/tal-tech/go-zero/tree/master/tools/goctl/config/readme.md]
        11.    --cache, -c            generate code with cache [optional]
        12.    --idea                 for idea plugin [optional]

      • datasource

        help

        1. NAME:
        2.    goctl model mysql datasource - generate model from datasource
        4. USAGE:
        5.    goctl model mysql datasource [command options] [arguments...]
        7. OPTIONS:
        8.    --url value              the data source of database,like "root:password@tcp(127.0.0.1:3306)/database
        9.    --table value, -t value  the table or table globbing patterns in the database
        10.    --cache, -c              generate code with cache [optional]
        11.    --dir value, -d value    the target dir
        12.    --style value            the file naming format, see [https://github.com/tal-tech/go-zero/tree/master/tools/goctl/config/readme.md]
        13.    --idea                   for idea plugin [optional]

        [!TIP] Goctl model mysql ddl/datasource has added a new --style parameter to mark the file naming style.

      Currently, only redis cache is supported. If you select the cache mode, the generated FindOne(ByXxx)&Delete code will generate code with cache logic. Currently, only single index fields (except full-text index) are supported. For joint index By default, we believe that there is no need to bring a cache, and it is not a general-purpose code, so it is not placed in the code generation ranks. For example, the id, name, and mobile fields in the user table in the example are all single-field indexes.

    • Without cache mode

      • ddl

        1.   $  goctl model -src={patterns} -dir={dir}

      • datasource

        1.   $  goctl model mysql datasource -url={datasource} -table={patterns}  -dir={dir}

      or

      • ddl

        1.   $  goctl model mysql datasource -url={datasource} -table={patterns}  -dir={dir}

    Generate code only basic CURD structure.

    For the cache, I chose to list it in the form of question and answer. I think this can more clearly describe the function of the cache in the model.

    • What information will the cache?

      For the primary key field cache, the entire structure information will be cached, while for the single index field (except full-text index), the primary key field value will be cached.

    • Does the data update (update) operation clear the cache?

      Yes, but only clear the information in the primary key cache, why? I won’t go into details here.

    • Why not generate updateByXxx and deleteByXxx codes based on single index fields?

      There is no problem in theory, but we believe that the data operations of the model layer are based on the entire structure, including queries. I do not recommend querying only certain fields (no objection), otherwise our cache will be meaningless.

    • Why not support the code generation layer of and findAll?

    Type conversion rules