GORM常用方法

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>



	
}
	



}
mysql中的回表查詢與索引覆蓋

Uber的Go語言指南

Go語言Interface作爲struct field，談談結構體中的匿名接口

全球公認最健康的作息時間表！全是知識點

面試必問：Golang高階-Golang協程實現原理

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結
