您的位置：首页 > 文旅 > 美景 > 00后没学历最吃香的职业_聚名网登录_廊坊seo_推广赚佣金的平台

00后没学历最吃香的职业_聚名网登录_廊坊seo_推广赚佣金的平台

2024/10/8 1:29:51 来源：https://blog.csdn.net/weixin_44575660/article/details/142718074  浏览:  次  关键词：00后没学历最吃香的职业_聚名网登录_廊坊seo_推广赚佣金的平台
00后没学历最吃香的职业_聚名网登录_廊坊seo_推广赚佣金的平台

ORM

ORM(Object Relational Mapping对象关系映射)，其主要作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来。举例来说就是，我定义一个对象，那就对应着一张表，这个对象的实例，就对应着表中的一条记录。对于数据来说，最重要最常用的是表：表中有列， orm就是将一张表映射成一个类，表中的列映射成类中的一个类。java 、python，但是针对go语言而言，struct，就是列如何映射，是因为列可以映射成struct中的类型，int->int,但是有另一个问题？ 就是数据库中的列具备很好的描述性，但是struct有tag。执行sql， 需要我们有足够的sql语句基础、需要我们懂得不同的数据的sql。
常见的orm：
gorm
facebook开发的ent
sqlx

orm的优缺点

优点：
1提高了开发效率。
2屏蔽sql细节。可以自动对实体Entity对象与数据库中的Table进行字段与属性的映射；不用直接SQL编码
3屏蔽各种数据库之间的差异

缺点：

1orm会牺牲程序的执行效率和会固定思维模式
2太过依赖orm会导致sql理解不够
3对于固定的orm依赖过重，导致切换到其他的orm代价高

如何正确看待orm和sql之间的关系

1sql为主，orm为辅
2orm主要目的是为了增加代码可维护性和开发效率

连接
import ("gorm.io/driver/mysql""gorm.io/gorm"
)func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}
通过迁移生成表结构
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type Product struct {gorm.ModelCode  stringPrice uint
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&Product{})
}
简单的增删查改
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type Product struct {gorm.ModelCode  stringPrice uint
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second,   // 慢速 SQL 阈值LogLevel:                  logger.Silent, // 日志级别IgnoreRecordNotFoundError: true,          // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,          // 不要在 SQL 日志中包含参数Colorful:                  true,          // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&Product{})//createdb.Create(&Product{Code: "D42", Price: 100})//readvar product Productdb.First(&product, 1) //根据整形主键查找// fmt.Println(product)db.First(&product, "code=?", "D42") //查找code=D42的记录//UPDATEdb.Model(&product).Update("price", 200)//update多个字短db.Model(&product).Updates(Product{Price: 2000, Code: "F42"}) //仅更新非零值字段db.Model(&product).Updates(map[string]interface{}{"price": 2000, "code": "DD42"})fmt.Println(product)//Deletedb.Delete(&product, 1)
}
通过NullString解决不能更新零值的问题

当updates函数传递的是结构体时，gorm只更新非零，在更新过程中可以通过传递仅包含个别字段的结构更新字段，就造成了不能直接通过设置各字段的默认值更新内容。解决仅更新非零值有两个解决方法：第一种指针形式，第二种sql.NulXXX

package mainimport ("database/sql""fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type Product struct {gorm.ModelCode  sql.NullStringPrice uint
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second,   // 慢速 SQL 阈值LogLevel:                  logger.Silent, // 日志级别IgnoreRecordNotFoundError: true,          // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,          // 不要在 SQL 日志中包含参数Colorful:                  true,          // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&Product{})//createdb.Create(&Product{Code: sql.NullString{"D42", true}, Price: 100})//readvar product Productdb.First(&product, 1) //根据整形主键查找// fmt.Println(product)db.First(&product, "code=?", "D42") //查找code=D42的记录//UPDATEdb.Model(&product).Update("price", 200)//update多个字短db.Model(&product).Updates(Product{Price: 2000, Code: sql.NullString{"", true}}) //仅更新非零值字段// db.Model(&product).Updates(map[string]interface{}{"price": 2000, "code": "DD42"})fmt.Println(product)//Deletedb.Delete(&product, 1)
}
表结构细节设计
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type User struct {UserID uint   `gorm:"primarykey"`Name   string `gorm:"column:user_name;type:varchar(50);index:idx_user_name;unique;default:'bobby'"`// Code   sql.NullString// Price  uint
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second,   // 慢速 SQL 阈值LogLevel:                  logger.Silent, // 日志级别IgnoreRecordNotFoundError: true,          // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,          // 不要在 SQL 日志中包含参数Colorful:                  true,          // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&User{})db.Create(&User{})
}
create
package mainimport ("database/sql""fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type User struct {ID           uint           // Standard field for the primary keyName         string         // A regular string fieldEmail        *string        // A pointer to a string, allowing for null valuesAge          uint8          // An unsigned 8-bit integerBirthday     *time.Time     // A pointer to time.Time, can be nullMemberNumber sql.NullString // Uses sql.NullString to handle nullable stringsActivatedAt  sql.NullTime   // Uses sql.NullTime for nullable time fieldsCreatedAt    time.Time      // Automatically managed by GORM for creation timeUpdatedAt    time.Time      // Automatically managed by GORM for update time
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&User{})user := User{Name: "Bobby2",}result := db.Create(&user)fmt.Println(user.ID)fmt.Println(result.Error)fmt.Println(result.RowsAffected)//db.Model(&User{ID: 1}).Update("name", "")
}
批量插入
package mainimport ("database/sql""fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type User struct {ID           uint           // Standard field for the primary keyName         string         // A regular string fieldEmail        *string        // A pointer to a string, allowing for null valuesAge          uint8          // An unsigned 8-bit integerBirthday     *time.Time     // A pointer to time.Time, can be nullMemberNumber sql.NullString // Uses sql.NullString to handle nullable stringsActivatedAt  sql.NullTime   // Uses sql.NullTime for nullable time fieldsCreatedAt    time.Time      // Automatically managed by GORM for creation timeUpdatedAt    time.Time      // Automatically managed by GORM for update time
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&User{})var users = []User{{Name: "jinzhu1"},{Name: "jinzhu2"},{Name: "jinzhu3"},}//单一的sql语句// db.Create(&users)//为什么不一次性提交所有的？//sql语句有长度限制，需要分批提交db.CreateInBatches(users, 2)//for简单插入for _, user := range users {fmt.Println(user.ID)}// batch insert from `[]map[string]interface{}{}`db.Model(&User{}).Create([]map[string]interface{}{{"Name": "jinzhu_1", "Age": 18},{"Name": "jinzhu_2", "Age": 20},})
}
select
package mainimport ("database/sql""fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type User struct {ID           uint           // Standard field for the primary keyName         string         // A regular string fieldEmail        *string        // A pointer to a string, allowing for null valuesAge          uint8          // An unsigned 8-bit integerBirthday     *time.Time     // A pointer to time.Time, can be nullMemberNumber sql.NullString // Uses sql.NullString to handle nullable stringsActivatedAt  sql.NullTime   // Uses sql.NullTime for nullable time fieldsCreatedAt    time.Time      // Automatically managed by GORM for creation timeUpdatedAt    time.Time      // Automatically managed by GORM for update time
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&User{})//通过first查询单个数据(升序排序)// var user User// db.First(&user)// fmt.Println(user.ID)// 通过first查询单个数据(降序排序)// db.Last(&user)// fmt.Println(user)//通过主键查询// result := db.First(&user, 10)// if errors.Is(result.Error, gorm.ErrRecordNotFound) {// 	fmt.Println("未找到")// }// fmt.Println(user.ID)//通过主键查询// result := db.First(&user, "10")// if errors.Is(result.Error, gorm.ErrRecordNotFound) {// 	fmt.Println("未找到")// }// fmt.Println(user.ID)// //通过主键查询// result := db.First(&user, "abc")// if errors.Is(result.Error, gorm.ErrRecordNotFound) {// 	fmt.Println("未找到")// }// fmt.Println(user.ID)//通过主键查询// result := db.First(&user, []int{1, 3, 5, 13})// if errors.Is(result.Error, gorm.ErrRecordNotFound) {// 	fmt.Println("未找到")// }// fmt.Println(user.ID)//检索全部对象var users []Userresult := db.Find(&users)fmt.Println("总共影响了", result.RowsAffected)for _, user := range users {fmt.Println(user.ID)}
}
where条件查询
package main// import (
// 	"database/sql"
// 	"fmt"
// 	"log"
// 	"os"
// 	"time"// 	"gorm.io/driver/mysql"
// 	"gorm.io/gorm"
// 	"gorm.io/gorm/logger"
// )// type User struct {
// 	ID           uint           // Standard field for the primary key
// 	Name         string         // A regular string field
// 	Email        *string        // A pointer to a string, allowing for null values
// 	Age          uint8          // An unsigned 8-bit integer
// 	Birthday     *time.Time     // A pointer to time.Time, can be null
// 	MemberNumber sql.NullString // Uses sql.NullString to handle nullable strings
// 	ActivatedAt  sql.NullTime   // Uses sql.NullTime for nullable time fields
// 	CreatedAt    time.Time      // Automatically managed by GORM for creation time
// 	UpdatedAt    time.Time      // Automatically managed by GORM for update time
// }// func main() {
// 	// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for details
// 	dsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"// 	//日志配置
// 	//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sql
// 	newLogger := logger.New(
// 		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
// 		logger.Config{
// 			SlowThreshold:             time.Second, // 慢速 SQL 阈值
// 			LogLevel:                  logger.Info, // 日志级别
// 			IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误
// 			ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数
// 			Colorful:                  true,        // 禁用颜色
// 		},
// 	)// 	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
// 		Logger: newLogger,
// 	})
// 	if err != nil {
// 		fmt.Println(err)
// 	}// 	//定义表结构
// 	//迁移 schema
// 	_ = db.AutoMigrate(&User{})// 	var user User
// 	var users []User
// 	// db.Where("name=?", "jinzhu1").Find(&user)
// 	db.Where(&User{Name: "jinzhu1"}).Find(&user)
// 	db.Where(&User{Name: "jinzhu1"}).Find(&users)
// 	fmt.Println(user)
// 	fmt.Println(users)
// 	//string(拼sql)更灵活 最后
// 	//struct屏蔽变量名和表的字段的对应关系 最优先
// 	//map不灵活，但是可以解决strct屏蔽零值的问题 优先// }
delete
package mainimport ("database/sql""fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type NewUser struct {ID           uint           // Standard field for the primary keyName         string         // A regular string fieldEmail        *string        // A pointer to a string, allowing for null valuesAge          uint8          // An unsigned 8-bit integerBirthday     *time.Time     // A pointer to time.Time, can be nullMemberNumber sql.NullString // Uses sql.NullString to handle nullable stringsActivatedAt  sql.NullTime   // Uses sql.NullTime for nullable time fieldsCreatedAt    time.Time      // Automatically managed by GORM for creation timeUpdatedAt    time.Time      // Automatically managed by GORM for update timeDeleted      gorm.DeletedAt
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema_ = db.AutoMigrate(&NewUser{})// var users = []NewUser{// 	{Name: "jinzhu1"},// 	{Name: "jinzhu2"},// 	{Name: "jinzhu3"},// }// db.Create(&users)// for _, user := range users {// 	fmt.Println(user.ID)// }//gorm软删除// db.Delete(&NewUser{}, 2)// var users []NewUser// result := db.Find(&users)// for _, user := range users {// 	fmt.Println(user.ID)// }// fmt.Println(result.RowsAffected)// fmt.Println(result.Error)//gorm硬删除db.Unscoped().Delete(&NewUser{}, 2)var users []NewUserresult := db.Find(&users)for _, user := range users {fmt.Println(user.ID)}fmt.Println(result.RowsAffected)fmt.Println(result.Error)
}
关联表插入
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)// `User` belongs to `Company`, `CompanyID` is the foreign key
type User struct {gorm.ModelName      stringCompanyID intCompany   Company
}type Company struct {ID   intName string
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}//定义表结构//迁移 schema// _ = db.AutoMigrate(&User{})// db.Create(&User{// 	Name: "bobby",// 	Company: Company{// 		Name: "dslkjf",// 	},// })var user User// db.First(&user)// fmt.Println(user)//先查company_id，后查找user// db.Preload("Company").First(&user)//通过join语句查询db.Joins("Company").First(&user)fmt.Println(user)
}
hasmany关系
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)// User has many CreditCards, UserID is the foreign key
type User struct {gorm.ModelCreditCards []CreditCard
}type CreditCard struct {gorm.ModelNumber stringUserID uint
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}// 定义表结构// 迁移 schema// _ = db.AutoMigrate(&CreditCard{})// _ = db.AutoMigrate(&User{})//在大型系统和高并发系统一般不使用外键约束，自己在业务层面保证数据的一致性，外键约束影响性能//外间约束可以保证数据的完整性user := User{}// db.Create(&user)// db.Create(&CreditCard{// 	Number: "12",// 	UserID: user.ID,// })// db.Create(&CreditCard{// 	Number: "34",// 	UserID: user.ID,// })db.Preload("CreditCards").First(&user)for _, card := range user.CreditCards {fmt.Println(card)}
}
manytomay
package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)// User has and belongs to many languages, `user_languages` is the join table
type User struct {gorm.ModelLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName string
}func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}// 定义表结构// 迁移 schema// _ = db.AutoMigrate(&User{})// languages := []Language{}// languages = append(languages, Language{Name: "go"})// languages = append(languages, Language{Name: "java"})// user := User{// 	Languages: languages,// }// db.Create(&user)// var user User// db.Preload("Languages").First(&user)// for _, language := range user.Languages {// 	fmt.Println(language.Name)// }//关联模式var user Userdb.First(&user)var languages []Language//join查询db.Model(&user).Association("Languages").Find(&languages)fmt.Println(user.ID)fmt.Println(languages)
}
自定义表名

用于定义表名和统一的给所有的表名加一个前缀
定义表名（为结构体定义TableName方法）

package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger"
)type Language struct {gorm.ModelName string
}// 在gorm中可以通过给某一个结构体添加TableName实现自定义表名
func (Language) TableName() string {return "my_language"
}
func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{Logger: newLogger,})if err != nil {fmt.Println(err)}// 定义表结构// 迁移 schema_ = db.AutoMigrate(&Language{})}

添加统一的前缀（通过NamingStrategy添加表的前缀，不能与TableName同时存在，否在以TableName为准）

package mainimport ("fmt""log""os""time""gorm.io/driver/mysql""gorm.io/gorm""gorm.io/gorm/logger""gorm.io/gorm/schema"
)type Language struct {gorm.ModelName string
}// // 在gorm中可以通过给某一个结构体添加TableName实现自定义表名
//
//	func (Language) TableName() string {
//		return "my_language"
//	}
func main() {// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for detailsdsn := "root:root123456@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"//日志配置//设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sqlnewLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), // io writerlogger.Config{SlowThreshold:             time.Second, // 慢速 SQL 阈值LogLevel:                  logger.Info, // 日志级别IgnoreRecordNotFoundError: true,        // 忽略记录器的 ErrRecordNotFound 错误ParameterizedQueries:      true,        // 不要在 SQL 日志中包含参数Colorful:                  true,        // 禁用颜色},)db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{//添加前缀NamingStrategy: schema.NamingStrategy{TablePrefix: "maxshop_",},Logger: newLogger,})if err != nil {fmt.Println(err)}// 定义表结构// 迁移 schema_ = db.AutoMigrate(&Language{})}

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

最新新闻

热搜词

基于LORA的一主多从监测系统_前言 搜狐的本色和张朝阳的本分 04-PS人像磨皮方法 Studying-多线程学习Part4 - 异步并发——async future、packaged_task、promise 网站建设常用网站系统推荐之PageAdmin CMS 充电桩行业的“中国式尴尬” 你怎么看？

声明：本站所有新闻及新闻图片来源于其他网站，如有侵权，请及时联系我们！

客户服务 | 关于我们 | 版权声明

版权所有：

Copyright 2024 尧图网 All Rights Reserved.QQ:809451989