golang Gorm framework explanation

Full function ORM
Related (Has One，Has Many，Belongs To，Many To Many，Polymorphic，Single table inheritance)
Create，Save，Update，Delete，Find Hook method
support Preload、Joins Preloading
Transactions，嵌套Transactions，Save Point，Rollback To Saved Point
Context，Precompiled mode，DryRun model
Batch Insert，FindInBatches，Find/Create with Map，use SQL expression、Context Valuer conduct CRUD
SQL Builder，Upsert，Database lock，Optimizer/Index/Comment Hint，Named Parameters，Subquery
Compound primary key，index，constraint
Auto Migration
Customize Logger
Flexible extensible plug-ins API：Database Resolver（Multi-database，Read and write separation）、Prometheus…
Each feature has been tested
Developer friendly

go get -u /gorm
go get -u /driver/sqlite

package main

import (
	"fmt"

	"/driver/mysql"
	"/gorm"
)

//Model Structuretype Student struct {
	Id   int
	Name string
	Age  int
}

type User struct {
	
	Name string `gorm:"type:varchar(20);not null"`
	Telephone string `gorm:"varchar(110;not null;unique"`
	Password string `gorm:"size:255;not null"`
}
func main() {
	// Use dsn to connect to the database, the database pool comes with Grom	//Account: Password@Connection method (ip address: port number)/Database?  Language, time zone (8-hour system is adopted if the time zone is not set)	dsn := "root:mysql@tcp(127.0.0.1:3306)/gotest?charset=utf8mb4&parseTime=True&loc=Local"
	conn, err := ((dsn), &{}) //Use mysq to connect to the database, the second parameter can add more configuration (optional)	if err != nil {
		(err)
	}
	(&Student{}) //Create a table? Determine whether the table structure exists}

//Multi-table creation(&Company{}, &Worker{})

stu := &Student{
		Id:   3,
		Name: "li333",
		Age:  30,
	}
	res := (stu) //Insert data into the database, its return value has only one type, no error type	//Note: If the above is written as stu := Student{...}, then it is written as Create(&stu)
	if  != nil { //Add to determine whether the data is inserted?		()
	}

var student Student
	//Query First query one	(&student)
	(student)
	()
	//Condition query	res := (&student, "name=? and id=?", "yang", 1)
	(res)
 //Query all Find	var stu []Student
	("students").Find(&stu)
	for _, v := range stu {
		()
	}

 // IN
	var students []Student
	("students").Where("name IN ?", []string{"abc", "bili"}).Find(&students)
	(students)

	// LIKE
	("name LIKE ?", "%jin%").Find(&users)

	// AND
	("name = ? AND age >= ?", "jinzhu", "22").Find(&users)

	// Time
	("updated_at > ?", (2022,05,20,0,0,0,0,&{})).Find(&users)

	// BETWEEN
	("created_at BETWEEN ? AND ?", (2022,05,20,0,0,0,0,&{}), ()).Find(&users)

  //Update data	("students").Where("id=?", 1).Update("name", "ttt")
	("students").Where("id=?", 2).Updates(&Student{Name: "bili", Age: 10})
	//Press the primary key to update, pass in the structure object, and update the corresponding content according to the corresponding primary key  ("user").Save(&user1)

("students").Where("id=?", 1).Delete(&Student{})

("select * from students where id=?", 3).Scan(&student)
(student)

("DROP TABLE users")
("UPDATE orders SET shipped_at=? WHERE id IN ?", (), []int64{1,2,3})

package main

import (
	"fmt"

	"/driver/mysql"
	"/gorm"
)

type User struct {
	
	CreditCard CreditCard
	Name       string
}

type CreditCard struct {
	
	Number string
	UserID uint
}

func main() {
	// Use dsn to connect to the database, the database pool comes with Grom	//Account: Password@Connection method (ip address: port number)/Database?  Language, time zone (8-hour system is adopted if the time zone is not set)	dsn := "root:mysql@tcp(127.0.0.1:3306)/crow?charset=utf8mb4&parseTime=True&loc=Local"
	conn, err := ((dsn), &{}) //Use mysq to connect to the database, the second parameter can add more configuration (optional)	if err != nil {
		(err)
	}
	(&User{})
	(&CreditCard{})

	//Create a table? Determine whether the table structure exists	user := &User{
		Name: "Li Si",
	}

	(user)

	card := &CreditCard{
		Number: "123",
		UserID: 1,
	}
	(card)

}

//Polymorphic association//GORM provides polymorphic association support for has one and has many, which saves the table name and primary key value of the owner entity into fields of polymorphic type.
type Cat struct {
  ID    int
  Name  string
  Toy   Toy `gorm:"polymorphic:Owner;"`
}

type Dog struct {
  ID   int
  Name string
  Toy  Toy `gorm:"polymorphic:Owner;"`
}

type Toy struct {
  ID        int
  Name      string
  OwnerID   int
  OwnerType string
}

(&Dog{Name: "dog1", Toy: Toy{Name: "toy1"}})
// INSERT INTO `dogs` (`name`) VALUES ("dog1")
// INSERT INTO `toys` (`name`,`owner_id`,`owner_type`) VALUES ("toy1","1","dogs")

type User struct {
  
  Name      string
  CompanyID int
  Company   Company `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type Company struct {
  ID   int
  Name string
}

// User has multiple CreditCards, UserID is a foreign keytype User struct {
  
  CreditCards []CreditCard
}

type CreditCard struct {
  
  Number string
  UserID uint
}

package main

import (
	"fmt"

	"/driver/mysql"
	"/gorm"
)


type User struct {
	
	MemberNumber string       `gorm:"varchar(110;not null;unique"`
	CreditCards  []CreditCard `gorm:"foreignKey:UserNumber;references:MemberNumber"`
	Name         string
}

type CreditCard struct {
	
	Number     string
	UserNumber string `gorm:"varchar(110;not null;unique"`
}

func main() {
	// Use dsn to connect to the database, the database pool comes with Grom	//Account: Password@Connection method (ip address: port number)/Database?  Language, time zone (8-hour system is adopted if the time zone is not set)	dsn := "root:mysql@tcp(127.0.0.1:3306)/crow?charset=utf8mb4&parseTime=True&loc=Local"
	conn, err := ((dsn), &{}) //Use mysq to connect to the database, the second parameter can add more configuration (optional)	if err != nil {
		(err)
	}
	(&User{}, &CreditCard{})
	user := User{
		Name:         "ttt3",
		MemberNumber: "1003",
	}
	(&user)
	card := CreditCard{
		Number:     "111",
		UserNumber: ,
	}
	(&card)

}

// User owns and belongs to multiple languages, `user_languages` is the connection tabletype User struct {
  
  Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  
  Name string
}

// User owns and belongs to multiple languages, `user_languages` is the connection tabletype User struct {
  
  Languages []*Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  
  Name string
  Users []*User `gorm:"many2many:user_languages;"`
}

type User struct {
  
  Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  
  Name string
}

// Join Table: user_languages
//   foreign key: user_id, reference: 
//   foreign key: language_id, reference: 

type User struct {
    
    Profiles []Profile `gorm:"many2many:user_profiles;foreignKey:Refer;joinForeignKey:UserReferID;References:UserRefer;JoinReferences:UserRefer"`
    Refer    uint
}

type Profile struct {
    
    Name      string
    UserRefer uint
}

// The connection table will be created: user_profiles//   foreign key: user_refer_id, reference: 
//   foreign key: profile_refer, reference: profiles.user_refer

type User struct {
  
    Friends []*User `gorm:"many2many:user_friends"`
}

// The connection table will be created: user_friends//   foreign key: user_id, reference: 
//   foreign key: friend_id, reference: 

type User struct {
  
  Username string
  Orders   []Order
}

type Order struct {
  
  UserID uint
  Price  float64
}

// Preload related Order when searching for user("Orders").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4);

("Orders").Preload("Profile").Preload("Role").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to

("Company").Joins("Manager").Joins("Account").First(&user, 1)
("Company").Joins("Manager").Joins("Account").First(&user, " = ?", "jinzhu")
("Company").Joins("Manager").Joins("Account").Find(&users, " IN ?", []int{1,2,3,4,5})

type User struct {
  
  Name       string
  CompanyID  uint
  Company    Company
  Role       Role
}

().Find(&users)

// Preload Order with conditions("Orders", "state NOT IN (?)", "cancelled").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN ('cancelled');

("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
// SELECT * FROM users WHERE state = 'active';
// SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN ('cancelled');

("Orders", func(db *) * {
  return (" DESC")
}).Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4) order by  DESC;

("").Preload("CreditCard").Find(&users)

// Customize the conditions for preloading `Orders`// In this way, GORM will not load mismatched order records("Orders", "state = ?", "paid").Preload("").Find(&users)