go get -u gorm.io/gen

import "gorm.io/gen"

# assume the following code in generate.go file$ cat generate.go

package mainimport "gorm.io/gen"// generate codefunc main() {    // specify the output directory (default: "./query")    // ### if you want to query without context constrain, set mode gen.WithoutContext ###    g := gen.NewGenerator(gen.Config{        OutPath: "../dal/query",        /* Mode: gen.WithoutContext|gen.WithDefaultQuery*/        //if you want the nullable field generation property to be pointer type, set FieldNullable true        /* FieldNullable: true,*/        //if you want to generate index tags from database, set FieldWithIndexTag true        /* FieldWithIndexTag: true,*/        //if you want to generate type tags from database, set FieldWithTypeTag true        /* FieldWithTypeTag: true,*/        //if you need unit tests for query code, set WithUnitTest true        /* WithUnitTest: true, */    })      // reuse the database connection in Project or create a connection here    // if you want to use GenerateModel/GenerateModelAs, UseDB is necessray or it will panic    // db, _ := gorm.Open(mysql.Open("root:@(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True&loc=Local"))    g.UseDB(db)      // apply basic crud api on structs or table models which is specified by table name with function    // GenerateModel/GenerateModelAs. And generator will generate table models' code when calling Excute.    g.ApplyBasic(model.User{}, g.GenerateModel("company"), g.GenerateModelAs("people", "Person", gen.FieldIgnore("address")))        // apply diy interfaces on structs or table models    g.ApplyInterface(func(method model.Method) {}, model.User{}, g.GenerateModel("company"))    // execute the action of code generation    g.Execute()}

demo├── cmd│   └── generate│       └── generate.go # execute it will generate codes├── dal│   ├── dal.go # create connections with database server here│   ├── model│   │   ├── method.go # DIY method interfaces│   │   └── model.go  # store struct which corresponding to the database table│   └── query  # generated code's directory|       ├── user.gen.go # generated code for user│       └── gen.go # generated code├── biz│   └── query.go # call function in dal/gorm_generated.go and query databases├── config│   └── config.go # DSN for database server├── generate.sh # a shell to execute cmd/generate├── go.mod├── go.sum└── main.go

// generate a model struct map to table `people` in databaseg.GenerateModel("people")// generate a struct and specify struct's nameg.GenerateModelAs("people", "People")// add option to ignore fieldg.GenerateModel("people", gen.FieldIgnore("address"), gen.FieldType("id", "int64"))// generate all tables, ex: g.ApplyBasic(g.GenerateAllTable()...)g.GenerateAllTable()

FieldNew           // create new fieldFieldIgnore        // ignore fieldFieldIgnoreReg     // ignore field (match with regexp)FieldRename        // rename field in structFieldType          // specify field typeFieldTypeReg       // specify field type (match with regexp)FieldTag           // specify gorm and json tagFieldJSONTag       // specify json tagFieldGORMTag       // specify gorm tagFieldNewTag        // append new tagFieldNewTagWithNS  // specify new tag with name strategyFieldTrimPrefix    // trim column prefixFieldTrimSuffix    // trim column suffixFieldAddPrefix     // add prefix to struct member's nameFieldAddSuffix     // add suffix to struct member's nameFieldRelate        // specify relationship with other tablesFieldRelateModel   // specify relationship with exist models

dataMap := map[string]func(detailType string) (dataType string){  "int": func(detailType string) (dataType string) { return "int64" },  // bool mapping  "tinyint": func(detailType string) (dataType string) {    if strings.HasPrefix(detailType, "tinyint(1)") {      return "bool"    }    return "int8"  },}g.WithDataTypeMap(dataMap)

import "gorm.io/gen/field"// create a new generic field map to `generic_a`a := field.NewField("table_name", "generic_a")// create a field map to `id`i := field.NewInt("user", "id")// create a field map to `address`s := field.NewString("user", "address")// create a field map to `create_time`t := field.NewTime("user", "create_time")

// generated code// generated code// generated codepackage queryimport "gorm.io/gen"// struct map to table `users` type user struct {    gen.DO    ID       field.Uint    Name     field.String    Age      field.Int    Address  field.Field    Birthday field.Time}// struct collectiontype DB struct {    db       *gorm.DB    User     *user}

// u refer to query.useruser := model.User{Name: "Modi", Age: 18, Birthday: time.Now()}u := query.Use(db).Usererr := u.WithContext(ctx).Create(&user) // pass pointer of data to Createerr // returns error

u := query.Use(db).Useru.WithContext(ctx).Select(u.Name, u.Age).Create(&user)// INSERT INTO `users` (`name`,`age`) VALUES ("modi", 18)

u := query.Use(db).Useru.WithContext(ctx).Omit(u.Name, u.Age).Create(&user)// INSERT INTO `users` (`Address`, `Birthday`) VALUES ("2021-08-17 20:54:12.000", 18)

var users = []model.User{{Name: "modi"}, {Name: "zhangqiang"}, {Name: "songyuan"}}query.Use(db).User.WithContext(ctx).Create(&users)for _, user := range users {    user.ID // 1,2,3}

var users = []User{{Name: "modi_1"}, ...., {Name: "modi_10000"}}// batch size 100query.Use(db).User.WithContext(ctx).CreateInBatches(users, 100)

db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{    CreateBatchSize: 1000,})// ORdb = db.Session(&gorm.Session{CreateBatchSize: 1000})u := query.NewUser(db)var users = []User{{Name: "modi_1"}, ...., {Name: "modi_5000"}}u.WithContext(ctx).Create(&users)// INSERT INTO users xxx (5 batches)

u := query.Use(db).User// Get the first record ordered by primary keyuser, err := u.WithContext(ctx).First()// SELECT * FROM users ORDER BY id LIMIT 1;// Get one record, no specified orderuser, err := u.WithContext(ctx).Take()// SELECT * FROM users LIMIT 1;// Get last record, ordered by primary key descuser, err := u.WithContext(ctx).Last()// SELECT * FROM users ORDER BY id DESC LIMIT 1;// check error ErrRecordNotFounderrors.Is(err, gorm.ErrRecordNotFound)

u := query.Use(db).Useruser, err := u.WithContext(ctx).Where(u.ID.Eq(10)).First()// SELECT * FROM users WHERE id = 10;users, err := u.WithContext(ctx).Where(u.ID.In(1,2,3)).Find()// SELECT * FROM users WHERE id IN (1,2,3);

user, err := u.WithContext(ctx).Where(u.ID.Eq("1b74413f-f3b8-409f-ac47-e8c062e3472a")).First()// SELECT * FROM users WHERE id = "1b74413f-f3b8-409f-ac47-e8c062e3472a";

u := query.Use(db).User// Get all recordsusers, err := u.WithContext(ctx).Find()// SELECT * FROM users;

u := query.Use(db).User// Get first matched recorduser, err := u.WithContext(ctx).Where(u.Name.Eq("modi")).First()// SELECT * FROM users WHERE name = 'modi' ORDER BY id LIMIT 1;// Get all matched recordsusers, err := u.WithContext(ctx).Where(u.Name.Neq("modi")).Find()// SELECT * FROM users WHERE name <> 'modi';// INusers, err := u.WithContext(ctx).Where(u.Name.In("modi", "zhangqiang")).Find()// SELECT * FROM users WHERE name IN ('modi','zhangqiang');// LIKEusers, err := u.WithContext(ctx).Where(u.Name.Like("%modi%")).Find()// SELECT * FROM users WHERE name LIKE '%modi%';// ANDusers, err := u.WithContext(ctx).Where(u.Name.Eq("modi"), u.Age.Gte(17)).Find()// SELECT * FROM users WHERE name = 'modi' AND age >= 17;// Timeusers, err := u.WithContext(ctx).Where(u.Birthday.Gt(birthTime).Find()// SELECT * FROM users WHERE birthday > '2000-01-01 00:00:00';// BETWEENusers, err := u.WithContext(ctx).Where(u.Birthday.Between(lastWeek, today)).Find()// SELECT * FROM users WHERE birthday BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

u := query.Use(db).Useruser, err := u.WithContext(ctx).Not(u.Name.Eq("modi")).First()// SELECT * FROM users WHERE NOT name = "modi" ORDER BY id LIMIT 1;// Not Inusers, err := u.WithContext(ctx).Not(u.Name.In("modi", "zhangqiang")).Find()// SELECT * FROM users WHERE name NOT IN ("modi", "zhangqiang");// Not In slice of primary keysuser, err := u.WithContext(ctx).Not(u.ID.In(1,2,3)).First()// SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;

u := query.Use(db).Userusers, err := u.WithContext(ctx).Where(u.Role.Eq("admin")).Or(u.Role.Eq("super_admin")).Find()// SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';

p := query.Use(db).Pizzapizzas, err := p.WithContext(ctx).Where(    p.WithContext(ctx).Where(p.Pizza.Eq("pepperoni")).        Where(p.Where(p.Size.Eq("small")).Or(p.Size.Eq("medium"))),).Or(    p.WithContext(ctx).Where(p.Pizza.Eq("hawaiian")).Where(p.Size.Eq("xlarge")),).Find()// SELECT * FROM `pizzas` WHERE (pizza = "pepperoni" AND (size = "small" OR size = "medium")) OR (pizza = "hawaiian" AND size = "xlarge")

u := query.Use(db).Userusers, err := u.WithContext(ctx).Select(u.Name, u.Age).Find