GORM常用方法

最新推荐文章于 2024-07-16 17:09:05 发布
最新推荐文章于 2024-07-16 17:09:05 发布
阅读量2.3k 收藏 7
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Edu_enth/article/details/104892745
版权 
gorm
{
	// 获取通用 sql.DB 并使用其方法
db.DB()

// Ping
db.DB().Ping()
// SetMaxIdleCons 设置连接池中的最大闲置连接数。
db.DB().SetMaxIdleConns(10)

// SetMaxOpenCons 设置数据库的最大连接数量。
db.DB().SetMaxOpenConns(100)

// SetConnMaxLifetiment 设置连接的最大可复用时间。
db.DB().SetConnMaxLifetime(time.Hour)
// 启用Logger，显示详细日志
db.LogMode(true)

// 禁用日志记录器，不显示任何日志
db.LogMode(false)
// 调试单个操作，显示此操作的详细日志
db.Debug().Where("name = ?", "jinzhu").First(&User{})

type User struct {
  gorm.Model
  Name         string
  Age          sql.NullInt64
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`
  Role         string  `gorm:"size:255"` // 设置字段大小为255
  MemberNumber *string `gorm:"unique;not null"` // 设置会员号（member number）唯一并且不为空
  Num          int     `gorm:"AUTO_INCREMENT"` // 设置 num 为自增类型
  Address      string  `gorm:"index:addr"` // 给address字段创建名为addr的索引
  IgnoreMe     int     `gorm:"-"` // 忽略本字段
}

GORM 默认会使用名为ID的字段作为表的主键。
表名默认就是结构体名称的复数
列名由字段名称进行下划线分割来生成


1.修改表名
{
	type User struct {} // 默认表名是 `users`
	// 将 User 的表名设置为 `profiles`
	func (User) TableName() string {
	  return "profiles"
	}
	func (u User) TableName() string {
	  if u.Role == "admin" {
		return "admin_users"
	  } else {
		return "users"
	  }
	}
	// 禁用默认表名的复数形式，如果置为 true，则 `User` 的默认表名是 `user`
	db.SingularTable(true)	
	
}

2.指定表明操作
{
// 使用User结构体创建名为`deleted_users`的表
db.Table("deleted_users").CreateTable(&User{})
var deleted_users []User
db.Table("deleted_users").Find(&deleted_users)
 SELECT * FROM deleted_users;
db.Table("deleted_users").Where("name = ?", "jinzhu").Delete()
 DELETE FROM deleted_users WHERE name = 'jinzhu';
}

3.修改字段名
type User struct {
  ID        uint      // column name is `id`
  Name      string    // column name is `name`
  Birthday  time.Time // column name is `birthday`
  CreatedAt time.Time // column name is `created_at`
  AnimalId    int64     `gorm:"column:beast_id"`         // set column name to `beast_id`
  Birthday    time.Time `gorm:"column:day_of_the_beast"` // set column name to `day_of_the_beast`
  Age         int64     `gorm:"column:age_of_the_beast"` // set column name to `age_of_the_beast`
}

4.CreatedAt
db.Create(&user) // `CreatedAt`将会是当前时间
// 可以使用`Update`方法来改变`CreateAt`的值
db.Model(&user).Update("CreatedAt", time.Now())

5.UpdateAt
db.Save(&user) // `UpdatedAt`将会是当前时间
db.Model(&user).Update("name", "jinzhu") // `UpdatedAt`将会是当前时间

6.
想要能正确的处理 time.Time，你需要添加 parseTime 参数。
想要完全的支持 UTF-8 编码，你需要修改charset=utf8 为 charset=utf8mb4。
import (
  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
)
func main() {
  db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
  defer db.Close()
}

7.创建
user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}
db.NewRecord(user) // => 主键为空返回`true`
db.Create(&user)
db.NewRecord(user) // => 创建`user`后返回`false`
//默认值
Name string `gorm:"default:'galeone'"`
//生成的 SQL 语句会排除没有值或值为 零值 的字段。 将记录插入到数据库后，Gorm会从数据库加载那些字段的值。
//create会导致先插入后读取。
var animal = Animal{Age: 99, Name: ""}
db.Create(&animal)
// INSERT INTO animals("age") values('99');
// SELECT name from animals WHERE ID=111; // 返回主键为 111
// animal.Name => 'galeone'


8.查询
// 查询指定的某条记录(仅当主键为整型时可用)
db.First(&user, 10)
 SELECT * FROM users WHERE id = 10;

当通过结构体进行查询时，GORM将会只通过非零值字段查询，这意味着如果你的字段值为0，''， false 或者其他 零值时，将不会被用于构建查询条
{
// Get first matched record
db.Where("name = ?", "jinzhu").First(&user)
 SELECT * FROM users WHERE name = 'jinzhu' limit 1;

// Get all matched records
db.Where("name = ?", "jinzhu").Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu';

// <>
db.Where("name <> ?", "jinzhu").Find(&users)
 SELECT * FROM users WHERE name <> 'jinzhu';

// IN
db.Where("name IN (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name in ('jinzhu','jinzhu 2');

// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)
 SELECT * FROM users WHERE name LIKE '%jin%';

// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;

// Time
db.Where("updated_at > ?", lastWeek).Find(&users)
 SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';

// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
 SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
 SELECT * FROM users WHERE name = "jinzhu" AND age = 20 LIMIT 1;

// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
 SELECT * FROM users WHERE name = "jinzhu" AND age = 20;

// 主键的切片
db.Where([]int64{20, 21, 22}).Find(&users)
 SELECT * FROM users WHERE id IN (20, 21, 22);

db.Not("name", "jinzhu").First(&user)
 SELECT * FROM users WHERE name <> "jinzhu" LIMIT 1;

// Not In
db.Not("name", []string{"jinzhu", "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");

// Not In slice of primary keys
db.Not([]int64{1,2,3}).First(&user)
 SELECT * FROM users WHERE id NOT IN (1,2,3);

db.Not([]int64{}).First(&user)
 SELECT * FROM users;

// Plain SQL
db.Not("name = ?", "jinzhu").First(&user)
 SELECT * FROM users WHERE NOT(name = "jinzhu");

// Struct
db.Not(User{Name: "jinzhu"}).First(&user)
 SELECT * FROM users WHERE name <> "jinzhu";

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
 SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';

// Struct
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

}

select
{
db.Select("name, age").Find(&users)
 SELECT name, age FROM users;

db.Select([]string{"name", "age"}).Find(&users)
 SELECT name, age FROM users;

db.Table("users").Select("COALESCE(age,?)", 42).Rows()
 SELECT COALESCE(age,'42') FROM users;	


db.Order("age desc, name").Find(&users)
 SELECT * FROM users ORDER BY age desc, name;

// 多字段排序
db.Order("age desc").Order("name").Find(&users)
 SELECT * FROM users ORDER BY age desc, name;

// 覆盖排序
db.Order("age desc").Find(&users1).Order("age", true).Find(&users2)
 SELECT * FROM users ORDER BY age desc; (users1)
 SELECT * FROM users ORDER BY age; (users2)


db.Limit(3).Find(&users)
 SELECT * FROM users LIMIT 3;

// -1 取消 Limit 条件
db.Limit(10).Find(&users1).Limit(-1).Find(&users2)
 SELECT * FROM users LIMIT 10; (users1)
 SELECT * FROM users; (users2)

db.Offset(3).Find(&users)
 SELECT * FROM users OFFSET 3;

// -1 取消 Offset 条件
db.Offset(10).Find(&users1).Offset(-1).Find(&users2)
 SELECT * FROM users OFFSET 10; (users1)
 SELECT * FROM users; (users2)

db.Where("name = ?", "jinzhu").Or("name = ?", "jinzhu 2").Find(&users).Count(&count)
 SELECT * from USERS WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (users)
 SELECT count(*) FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (count)

db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count)
 SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)

db.Table("deleted_users").Count(&count)
 SELECT count(*) FROM deleted_users;

db.Table("deleted_users").Select("count(distinct(name))").Count(&count)
 SELECT count( distinct(name) ) FROM deleted_users; (count)

}

9.更新
Save会更新所有字段，即使你没有赋值
如果你只希望更新指定字段，可以使用Update或者Updates
使用 map 更新多个属性，只会更新其中有变化的属性
使用 struct 更新多个属性，只会更新其中有变化且为非零值的字段
如果你想更新或忽略某些字段，你可以使用 Select，Omit

{
// 更新单个属性，如果它有变化
db.Model(&user).Update("name", "hello")
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;

// 根据给定的条件更新单个属性
db.Model(&user).Where("active = ?", true).Update("name", "hello")
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;

// 使用 map 更新多个属性，只会更新其中有变化的属性
db.Model(&user).Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
 UPDATE users SET name='hello', age=18, actived=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

// 使用 struct 更新多个属性，只会更新其中有变化且为非零值的字段
db.Model(&user).Updates(User{Name: "hello", Age: 18})
 UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;

// 警告：当使用 struct 更新时，GORM只会更新那些非零值的字段
// 对于下面的操作，不会发生任何更新，"", 0, false 都是其类型的零值
db.Model(&user).Updates(User{Name: "", Age: 0, Actived: false})
db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;

db.Model(&user).Omit("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
 UPDATE users SET age=18, actived=false, updated_at='2013-11-17 21:34:10' WHERE id=111;
}


10.删除
删除记录时，请确保主键字段有值，GORM 会通过主键去删除记录，如果主键为空，GORM 会删除该 model 的所有记录。
如果一个 model 有 DeletedAt 字段，他将自动获得软删除的功能！ 当调用 Delete 方法时， 记录不会真正的从数据库中被删除， 只会将DeletedAt 字段的值会被设置为当前时间
{
db.Where("email LIKE ?", "%jinzhu%").Delete(Email{})
 DELETE from emails where email LIKE "%jinzhu%";

db.Delete(Email{}, "email LIKE ?", "%jinzhu%")
 DELETE from emails where email LIKE "%jinzhu%";

// Unscoped 方法可以物理删除记录
db.Unscoped().Delete(&order)
 DELETE FROM orders WHERE id=10;

// Unscoped 方法可以查询被软删除的记录
db.Unscoped().Where("age = 20").Find(&users)
 SELECT * FROM users WHERE age = 20;
}


11.链式操作 重要
所有链式方法都会创建并克隆一个新的 DB 对象 (共享一个连接池)，GORM 在多 goroutine 中是并发安全的。
立即执行方法：Create, First, Find, Take, Save, UpdateXXX, Delete, Scan, Row, Rows…
//在调用立即执行方法前不会生成 Query 语句，有时候这会很有用。
//比如你可以抽取一个函数来处理一些通用逻辑。
// 创建一个查询
tx := db.Where("name = ?", "jinzhu")
// 添加更多条件

tx = tx.Where("age = ?", 20)

//立即执行方法
tx.Find(&user)

Scope 是建立在链式操作的基础之上的。
//基于它，你可以抽取一些通用逻辑，写出更多可重用的函数库。
{
func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
  return db.Where("amount > ?", 1000)
}

func PaidWithCreditCard(db *gorm.DB) *gorm.DB {
  return db.Where("pay_mode_sign = ?", "C")
}

func PaidWithCod(db *gorm.DB) *gorm.DB {
  return db.Where("pay_mode_sign = ?", "C")
}

func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
  return func (db *gorm.DB) *gorm.DB {
    return db.Scopes(AmountGreaterThan1000).Where("status IN (?)", status)
  }
}

db.Scopes(AmountGreaterThan1000, PaidWithCreditCard).Find(&orders)
// 查找所有金额大于 1000 的信用卡订单

db.Scopes(AmountGreaterThan1000, PaidWithCod).Find(&orders)
// 查找所有金额大于 1000 的 COD 订单

db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
// 查找所有金额大于 1000 且已付款或者已发货的订单	
	
}

多个立即执行
// GORM 中使用多个立即执行方法时，后一个立即执行方法会复用前一个 立即执行方法的条件 (不包括内联条件) 。


12.错误检测
如果发生任何错误，GORM将设置* gorm.DB的错误字段
if err := db.Where("name = ?", "jinzhu").First(&user).Error; err != nil {
  // error 处理...
}
或者
if result := db.Where("name = ?", "jinzhu").First(&user); result.Error != nil {
  // error 处理...
}

多个错误时切片返回
// 如果发生了一个以上的错误， `GetErrors` 以`[]error`形式返回他们
errors := db.First(&user).Limit(10).Find(&users).GetErrors()
fmt.Println(len(errors))
for _, err := range errors {
  fmt.Println(err)
}

RecordNotFound，GORM提供了处理 RecordNotFound 错误的快捷方式。
// 检查是否为 RecordNotFound 错误
db.Where("name = ?", "hello world").First(&user).RecordNotFound()

if db.Model(&user).Related(&credit_card).RecordNotFound() {
  // 未找到记录
}

if err := db.Where("name = ?", "jinzhu").First(&user).Error; gorm.IsRecordNotFoundError(err) {
  // 未找到记录
}


13.钩子
在执行操作之前或者之后进行操作
{
创建对象时的钩子
// 开始事务
BeforeSave
BeforeCreate
// 在关联前保存
// 更新时间戳 `CreatedAt`, `UpdatedAt`
// save self
// 重新加载具有默认值的字段，其值为空
// 在关联后保存
AfterCreate
AfterSave
// 提交或回滚事务
func (u *User) BeforeSave() (err error) {
  if !u.IsValid() {
    err = errors.New("can't save invalid data")
  }
  return
}

func (u *User) AfterCreate(scope *gorm.Scope) (err error) {
  if u.ID == 1 {
    scope.DB().Model(u).Update("role", "admin")
  }
  return
}

//在 GORM 中 Save/Delete 操作默认是基于事务完成， 所以相关更改在提交事务之前是不可见的。 如果你想在你的 hooks 中看到这些变化，你可以在你的 hooks 中接收当前事务的参数
func (u *User) AfterCreate(tx *gorm.DB) (err error) {
  tx.Model(u).Update("role", "admin")
  return
}



更新对象时
// begin transaction 开始事物
BeforeSave
BeforeUpdate
// save before associations 保存前关联
// update timestamp `UpdatedAt` 更新 `UpdatedAt` 时间戳
// save self 保存自己
// save after associations 保存后关联
AfterUpdate
AfterSave
// commit or rollback transaction 提交或回滚事务
func (u *User) BeforeUpdate() (err error) {
  if u.readonly() {
    err = errors.New("read only user")
  }
  return
}

// 在一个事务中更新数据
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("verfied", true)
  }
  return
}

删除对象时
// begin transaction 开始事务
BeforeDelete
// delete self 删除自己
AfterDelete
// commit or rollback transaction 提交或回滚事务
// 在一个事务中更新数据
func (u *User) AfterDelete(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("invalid", false)
  }
  return
}

查询对象时
// load data from database 从数据库加载数据
// Preloading (eager loading) 预加载（加载）
AfterFind
func (u *User) AfterFind() (err error) {
  if u.MemberShip == "" {
    u.MemberShip = "user"
  }
  return
}



	
}

14.事务
GORM 默认会将单个的 create, update, delete操作封装在事务内进行处理，以确保数据的完整性。

如果你想把多个 create, update, delete 操作作为一个原子操作，Transaction 就是用来完成这个的。
{
func CreateAnimals(db *gorm.DB) error {
  return db.Transaction(func(tx *gorm.DB) error {
    // 在事务中做一些数据库操作 (这里应该使用 'tx' ，而不是 'db')
    if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
      // 返回任意 err ，整个事务都会 rollback
      return err
    }

    if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
      return err
    }

    // 返回 nil 提交事务
    return nil
  })
}

手动控制
// 开启事务
tx := db.Begin()

// 在事务中做一些数据库操作 (这里应该使用 'tx' ，而不是 'db')
tx.Create(...)

// ...

// 有错误时，手动调用事务的 Rollback()
tx.Rollback()

// 无错误时，手动调用事务的 Commit()
tx.Commit()

func CreateAnimals(db *gorm.DB) error {
  // 请注意，事务一旦开始，你就应该使用 tx 作为数据库句柄
  tx := db.Begin()
  defer func() {
    if r := recover(); r != nil {
      tx.Rollback()
    }
  }()

  if err := tx.Error; err != nil {
    return err
  }

  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  return tx.Commit().Error
}
	
}

15.迁移
{
自动迁移
db.AutoMigrate(&User{})

db.AutoMigrate(&User{}, &Product{}, &Order{})

// 创建表时添加表后缀
db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})

// 检查模型 User 的表是否存在
db.HasTable(&User{})

// 检查表 users 是否存在
db.HasTable("users")
// 为模型 `User` 创建表
db.CreateTable(&User{})

// 创建表时会追加 “ENGINE=InnoDB” 到 SQL 语句中。
db.Set("gorm:table_options", "ENGINE=InnoDB").CreateTable(&User{})
// 删除模型 `User` 的表
db.DropTable(&User{})

// 删除表 `users`
db.DropTable("users")

// 删除模型 `User` 的表和表 `products`
db.DropTableIfExists(&User{}, "products")
// 修改模型 `User` 的 description 列的类型为 `text` 
db.Model(&User{}).ModifyColumn("description", "text")
// 删除模型 `User` 的 description 列
db.Model(&User{}).DropColumn("description")
// 为 `name` 列添加名为 `idx_user_name` 的普通索引
db.Model(&User{}).AddIndex("idx_user_name", "name")

// 为 `name` 和 `age` 两列添加名为 `idx_user_name_age` 的普通索引
db.Model(&User{}).AddIndex("idx_user_name_age", "name", "age")

// 添加唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name", "name")

// 为多列添加唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name_age", "name", "age")
// 删除索引
db.Model(&User{}).RemoveIndex("idx_user_name")
// 添加外键
// 第一个参数： 外键字段
// 第二个参数：目标表名(字段)
// 第三个参数：删除时
// 第四个参数： 更新时
db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")
db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")

}


16.原生SQL
执行原生 SQL 时，不支持与其它方法的链式操作
{
db.Exec("DROP TABLE users;")
db.Exec("UPDATE orders SET shipped_at=? WHERE id IN (?)", time.Now(), []int64{11,22,33})

// Scan
type Result struct {
  Name string
  Age  int
}

var result Result
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

//通过 *sql.Row 或 *sql.Rows 获取查询结果

row := db.Table("users").Where("name = ?", "jinzhu").Select("name, age").Row() // (*sql.Row)
row.Scan(&name, &age)

rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Select("name, age, email").Rows() // (*sql.Rows, error)
defer rows.Close()
for rows.Next() {
  ...
  rows.Scan(&name, &age, &email)
  ...
}

// 原生 SQL
rows, err := db.Raw("select name, age, email from users where name = ?", "jinzhu").Rows() // (*sql.Rows, error)
defer rows.Close()
for rows.Next() {
  ...
  rows.Scan(&name, &age, &email)
  ...
}

//将 sql.Rows 扫描至 model
rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Select("name, age, email").Rows() // (*sql.Rows, error)
defer rows.Close()

for rows.Next() {
  var user User
  // ScanRows 扫描一行记录到 user
  db.ScanRows(rows, &user)

  // do something
}
}


}



errors
{

https://github.com/pkg/errors

_, err := ioutil.ReadAll(r)
if err != nil {
    return errors.Wrap(err, "read failed")
}
switch err := errors.Cause(err).(type) {
case *MyError:
        // handle specifically
default:
        // unknown error
}
	
}

redis

{
https://github.com/go-redis/redis
set, err := client.SetNX("key", "value", 10*time.Second).Result()
// custom command
res, err := client.Do("set", "key", "value").Result()
.Text()
字符串
{
client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})
	err := client.Set("key", "value", 0).Err()
	if err != nil {
		panic(err)
	}

	val, err := client.Get("key").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("key", val)

	val2, err := client.Get("key2").Result()
	if err == redis.Nil {
		fmt.Println("key2 does not exist")
	} else if err != nil {
		panic(err)
	} else {
		fmt.Println("key2", val2)
	}	
}
哈希

列表
// SORT list LIMIT 0 2 ASC
vals, err := client.Sort("list", &redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()
集合

有序列表
// ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
vals, err := client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
	Min: "-inf",
	Max: "+inf",
	Offset: 0,
	Count: 2,
}).Result()
// ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
vals, err := client.ZInterStore("out", redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2").Result()

// EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
vals, err := client.Eval("return {KEYS[1],ARGV[1]}", []string{"key"}, "hello").Result()

{

client := redis.NewClient(&redis.Options{
	Addr:     "localhost:6379",
	Password: "", // no password set
	DB:       0,  // use default DB
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
// Output: PONG <nil>



	
}
	



}
InterestingFigure
关注
专栏目录
Golang 侧数据库连接池原理和参数调优
每一个不曾起舞的日子，都是对人生的辜负。
01-13 5422
Golang 侧数据库连接池原理和参数调优 文章目录Golang 侧数据库连接池原理和参数调优数据库连接池数据库连接池的设计Go 的数据库连接池Go 数据库连接池的设计建立连接释放连接清理连接配置 sql.DB 以获得更好的性能maxOpenmaxIdlemaxLifeTime在实践和压测中配置 Go 数据库连接池附录一：超出连接设置附录二：如何配置一个高性能的数据库连接池 池化技术 (Pool...
Gorm之gorm.Config结构体字段详解
weixin_52690231的博客
05-02 2291
Gorm之gorm.Config结构体字段详解
GORM介绍及入门指南
最新发布
MPY_3的博客
07-16 1747
GORM 是一个适用于 Go 语言的 ORM（对象关系映射）库。ORM 的目的是让开发者能够通过面向对象的方式与数据库交互，而不是直接编写 SQL 语句。GORM 使得操作数据库更加高效和便捷，同时保留了 Go 语言的简洁性和灵活性。模型是使用普通结构体定义的。这些结构体可以包含具有基本Go类型、指针或这些类型的别名，甚至是自定义类型（只需要实现 database/sql 包中的Scanner和Valuer接口）。
Golang gorm 常用新增方法
qq_29744347的博客
08-15 1372
数据库连接&结构体定义//禁止创建外键 DisableForeignKeyConstraintWhenMigrating : true , }) if err!= nil {
Gorm笔记
寻找到底哪里有蓝天
02-13 66
转载于：https://www.mszlu.com/go/gorm/01/01.html#_1-入门 一、快速入门 gorm地址：https://github.com/go-gorm/gorm 对开发者友好的gorm库，目前使用最广的go orm库之一 1. 入门 数据库以目前使用最多的mysql为例。 //安装MySQL驱动 go get -u gorm.io/driver/mysql /...
go语言mysql的gorm基本用法
nbv12589的博客
01-10 605
参考GORM的默认记录器如何自定义它。
gorm的一些使用技巧和遇到的一个坑
热门推荐
吴景慈跑得快的博客
03-17 2万+
gorm是国内开发者所做的开源golang orm框架，做的比较成熟。 获取方式： go get -u github.com/jinzhu/gorm 使用方法查看文档即可，还是比较符合sql语句的写法和设计方式的，当然也支持Raw语句，自己拼出语句去执行。 一个小技巧： 查看执行的sql语句，拼了大段的where，find以后想看事实执行的sql是什么，毕竟是开源框架，打出来看看避免自己...
从“gorm建立mysql数据库连接，偶现tcp: i/o timeout问题”简单看gorm.DB源码
MoeYang
12-08 4246
昨天被同事问到一个问题： go服务，gorm建立mysql数据库连接，偶现tcp: i/o timeout问题是怎么回事？ 说实话，我平时没怎么用过gorm，也只是简单了解它的用法。 考虑到问题是连接mysql偶现tcp: i/o timeout， 第一反应是怀疑mysql的负载太高，比如连接数太高导致排队。 于是看了下代码对gorm的调用代码： 使用gorm建立连接的场景 这里看起来没什么问题，连接池的参数也都有配上。 // NewDB 连接db func NewDB(dbKey st.
golang常用库之操作数据库的orm框架-gorm基本使用详解
12-16
golang常用库：操作数据库的orm框架-gorm基本使用 一：字段映射-模型定义 gorm中通常用struct来映射字段. gorm教程中叫模型定义 比如我们定义一个模型Model： type User struct { gorm.Model UserId int64 `gorm:...
gorm学习
日之朝矣的博客
04-30 1545
从belongs to 后面学的就有点不清不楚了，所以直接复制粘贴了TAT 安装 go get -u gorm.io/gorm go get -u gorm.io/driver/mysql 声明模型 模型为标准的struct，由Go的基本数据类型，实现了Scanner和Value接口的自定义类型及其指针或别名组成 type User struct{ ID uint Name string Email *string Age uint8 Birthday *time.
使用GORM操作数据库
weixin_44627989的博客
05-10 3480
依赖 github.com/jinzhu/gorm 定义实体类 可以通过定义嵌套gorm.Model这个结构体的类型来定义实体类，gorm.Model中定义了数据库表的一些常用基本字段 type Model struct { ID uint `gorm:"primary_key"` CreatedAt time.Time UpdatedAt time.Time DeletedAt *time.Time } 比如我们定义User实体 type User struct{ gorm.Mo
零基础上手更安全更友好GORM原作者操刀的GORM GEN
qqxhb 资源共享
11-29 8394
GORM/GEN，持续更新欢迎吐槽Star！！！ 基于 GORM, 更安全更友好的ORM工具。 自动生成CRUD和DIY方法 自动根据表结构生成model 完全兼容GORM 更安全、更友好 多种生成代码模式
gorm基本使用介绍
abcnull 的博客
08-24 3793
文章目录简介安装定义结构体结构体表名创建/更新时间连接数据库连接数据库数据库连接池create 建表建表检测表存在表更改insert 插入插入举例select 查询查询举例常见函数update 更新更新举例常见函数更新表达式delete 删除表连接查询belongs to(1v1)has one(1v1)has many(1v多)预加载事务操作自动事务手动事务错误处理错误处理举例错误类型Debug 调试直接执行查询 简介 是当今比较热门的 golang 的 orm 操作数据库的工具，使用上主要是把 stru
GORM gorm.DB 对象剖析
Dablelv 的博客专栏。
12-01 1683
GORM 是一个流行的 Golang ORM 库。类似于 Java 生态里大家听到过的 Mybatis、Hibernate、SpringData 等。GORM 由国人开发，中文文档齐全，对开发者友好，支持主流关系型数据库。MySQLSQL ServerPostgreSQLSQLite关联 (拥有一个，拥有多个，属于，多对多，多态，单表继承)钩子（before/after create/save/update/delete/find）支持 Preload、Joins 的预加载。
golang数据库连接池参数设置
HONG的个人博客
09-20 2955
可用查看mysql服务器上的连接信息，Command表示连接的当前状态，Command为Sleep时表示休眠、空闲状态，Time表示此状态的已持续时长；当连接持续空闲时长达到maxIdleTime后，该连接就会被关闭并从连接池移除，哪怕当前空闲连接数已经小于SetMaxIdleConns(maxIdleConns)设置的值。maxLifeTime必须要比mysql服务器设置的wait_timeout小，否则会导致golang侧连接池依然保留已被mysql服务器关闭了的连接。连接池里面的连接最大空闲时长。
GORM查询操作,全覆盖
weixin_44178366的博客
06-29 8375
GORM查询操作 一.一般查询 //根据主键获取第一条记录 var user User db.Debug().First(&user) //根据主键(必须存在,并且为数字类型)排序查询第一条记录,并将数据封装到user之中 //SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL ORDER BY `users`.`id` ASC LIMIT 1 //根据主键获取最后一条记录 var user User db.Debug().L
gorm v2.0简单使用总结
fan_nlnl的博客
08-15 1986
数据库连接 import ( "gorm.io/driver/mysql" "gorm.io/gorm" "testing" ) ​ // 测试连接mysql func TestConnectMysql(t *testing.T) { dsn := "root:1234@(127.0.0.1:3306)/SimpleGorm?charset=utf8mb4&parseTime=True&loc=Local" db, err := gorm.Open(my...
关于Golang中database/sql包的学习
weixin_30887919的博客
04-08 201
go-sql-driver 请求一个连接的函数有好几种，执行完毕处理连接的方式稍有差别，大致如下： db.Ping() 调用完毕后会马上把连接返回给连接池。 db.Exec() 调用完毕后会马上把连接返回给连接池，但是它返回的Result对象还保留这连接的引用，当后面的代码需要处理结果集的时候连接将会被重用。 db.Query() 调用完毕后会将连接传递给sql.R...
Golang 连接数据库 Gorm 使用笔记
anchen1991的博客
06-24 2343
中文文档地址：https://jasperxu.github.io/gorm-zh/ 英文Doc:https://gorm.io/docs/ (逐步更新) 1. 基本操作 　　1）连接数据库 连接后可以设置最大连接数等参数　　　　 db, err := gorm.Open("mysql", "user:password@/dbname?chars...
gorm delete
08-17
您可以使用 GORM 库来执行删除操作。下面是一个示例代码： ```go import "gorm.io/gorm" // 定义模型结构 type User struct { gorm.Model Name string Email string } // 删除记录 func deleteUser(db *gorm.DB, userID uint) error { // 查找记录 var user User result := db.First(&user, userID) if result.Error != nil { return result.Error } // 删除记录 result = db.Delete(&user) if result.Error != nil { return result.Error } return nil } ``` 在上面的示例中，我们定义了一个名为 `User` 的模型结构，包含 `Name` 和 `Email` 字段。`gorm.Model` 是 GORM 提供的一个内置模型，包含一些常用字段，例如 `ID`、`CreatedAt`、`UpdatedAt` 和 `DeletedAt`。然后，我们定义了一个函数 `deleteUser`，它接受一个 `db *gorm.DB` 对象和一个 `userID uint` 参数，用于删除指定 ID 的用户记录。 您可以通过调用 `db.Delete(&user)` 方法来执行删除操作。注意，这里使用了 `&user` 作为参数，表示删除指定的用户记录。 请根据您的实际需求进行修改和适配。希望能对您有所帮助！如果您有任何其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

InterestingFigure

迈克 Let's Go

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值