golang gorm 使用分享和 redis使用

头像
锅包肉
     北京
    阅读 9 分钟
    头图
    GORM 官方支持的数据库类型有： MySQL，PostgreSQL，SQlite，SQL Server

    MYSQL

    
import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)
  
func main() {
    // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
    dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}

    PostgreSQL

    
import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)
  
dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
#### SQLite
import (
    "gorm.io/driver/sqlite" // Sqlite driver based on GGO
    // "github.com/glebarez/sqlite" 
    // Pure go SQLite driver, checkout https://github.com/glebarez/sqlite for details
    "gorm.io/gorm"
)
  
// github.com/mattn/go-sqlite3
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{})

    SQL Server

    import (
    "gorm.io/driver/sqlserver"
    "gorm.io/gorm"
)
  
// github.com/denisenkom/go-mssqldb
dsn := "sqlserver://gorm:LoremIpsum86@localhost:9930?database=gorm"
db, err := gorm.Open(sqlserver.Open(dsn), &gorm.Config{})

    连接池

    GORM 使用database/sql维护连接池

sqlDB, err := db.DB()

// SetMaxIdleConns 设置空闲连接池中连接的最大数量
sqlDB.SetMaxIdleConns(10)

// SetMaxOpenConns 设置打开数据库连接的最大数量。
sqlDB.SetMaxOpenConns(100)

// SetConnMaxLifetime 设置了连接可复用的最大时间。
sqlDB.SetConnMaxLifetime(time.Hour)

    Create

    package main

import (
    "database/sql"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
)

type Userinfo struct {
    Id     uint
    Name   string
    Gender string
    Hobby  string
}


type UserTest struct {
    ID           uint
    Name         string
    Email        *string
    Age          uint8
    Birthday     *time.Time
    MemberNumber sql.NullString
    ActivatedAt  sql.NullTime
    CreatedAt    time.Time
    UpdatedAt    time.Time
}



func main() {
    // 连接数据库
    dsn := "root:xixxxxxu@tcp(10.xx.18x.1x:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    ////自动迁移
    //db.AutoMigrate(&Userinfo{})
    //u1 := Userinfo{Id: 1, Name: "张三", Gender: "男", Hobby: "学习"}
    //db.Create(&u1) //创建


    //create table and inster
    db.AutoMigrate(&UserTest{})

    britime := time.Now()
    user := UserTest{Name: "Sean", Age: 17, Birthday: &britime}
    result := db.Create(&user)
    //user.ID             // 返回插入数据的主键
    //result.Error        // 返回 error
    //result.RowsAffected // 返回插入记录的条数
    fmt.Println(user.ID, result.Error, result.RowsAffected)

}

    image.png

    image.png

    Query

    // 获取第一条记录（主键升序）
db.First(&user)
// SELECT * FROM users ORDER BY id LIMIT 1;

// 获取一条记录，没有指定排序字段
db.Take(&user)
// SELECT * FROM users LIMIT 1;

// 获取最后一条记录（主键降序）
db.Last(&user)
// SELECT * FROM users ORDER BY id DESC LIMIT 1;

result := db.First(&user)
result.RowsAffected // 返回找到的记录数
result.Error        // returns error or nil

// 检查 ErrRecordNotFound 错误
errors.Is(result.Error, gorm.ErrRecordNotFound)

    

func main() {
    // 连接数据库
    dsn := "root:xixxxxxu@tcp(1xxxxxxx:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    ////自动迁移
    //db.AutoMigrate(&Userinfo{})
    //u1 := Userinfo{Id: 1, Name: "张三", Gender: "男", Hobby: "学习"}
    //db.Create(&u1) //创建


    ////create table and inster
    //db.AutoMigrate(&UserTest{})
    //
    //britime := time.Now()
    //user := UserTest{Name: "Sean", Age: 17, Birthday: &britime}
    //result := db.Create(&user)
    ////user.ID             // 返回插入数据的主键
    ////result.Error        // 返回 error
    ////result.RowsAffected // 返回插入记录的条数
    //fmt.Println(user.ID, result.Error, result.RowsAffected)


    //Query
    var user_test UserTest
    //var users []UserTest
    result := db.First(&user_test, "id = ?", 1)
    // SELECT * FROM users WHERE id = 1

    db.Model(UserTest{}).First(&user_test)

    fmt.Println(result.RowsAffected, user_test)
}

    image.png

    update

    package main

import (
    "database/sql"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
)

type Userinfo struct {
    Id     uint
    Name   string
    Gender string
    Hobby  string
}


type UserTest struct {
    ID           uint
    Name         string
    Email        *string
    Age          uint8
    Birthday     *time.Time
    MemberNumber sql.NullString
    ActivatedAt  sql.NullTime
    CreatedAt    time.Time
    UpdatedAt    time.Time
}






func main() {
    // 连接数据库
    dsn := "root:xxxxxhu@tcp(10.xxxxxx1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    ////自动迁移
    //db.AutoMigrate(&Userinfo{})
    //u1 := Userinfo{Id: 1, Name: "张三", Gender: "男", Hobby: "学习"}
    //db.Create(&u1) //创建


    ////create table and inster
    //db.AutoMigrate(&UserTest{})
    //
    //britime := time.Now()
    //user := UserTest{Name: "Sean", Age: 17, Birthday: &britime}
    //result := db.Create(&user)
    ////user.ID             // 返回插入数据的主键
    ////result.Error        // 返回 error
    ////result.RowsAffected // 返回插入记录的条数
    //fmt.Println(user.ID, result.Error, result.RowsAffected)


    ////Query
    //var user_test UserTest
    ////var users []UserTest
    //result := db.First(&user_test, "id = ?", 1)
    //// SELECT * FROM users WHERE id = 1
    //db.Model(UserTest{}).First(&user_test)
    //fmt.Println(result.RowsAffected, user_test)

    //Update
    var user UserTest
    db.First(&user)
    user.Name = "Sean56"
    user.Age = 56
    db.Save(&user)
    db.First(&user, "name = ?", "Sean56")
    fmt.Println(user)

}

    image.png
    image.png

    Delete

    image.png

    image.png

    redis

    package main

import (
    "fmt"
    "github.com/go-redis/redis"
)

func ConnRedis() {
    rd := redis.NewClient(&redis.Options{
        Addr: "10.2x.1xx.1xx:6379", // url
        Password: "XixxxxU",
        DB:0,   // 0号数据库
    })
    result, err := rd.Ping().Result()
    if err != nil {
        fmt.Println("ping err :",err)
        return
    }
    fmt.Println(result)
}

var rd  *redis.Client= redis.NewClient(&redis.Options{
    Addr: "10.23.x8.xx:6379", // url
    Password: "XxxxxU",
    DB:7,   // 数据库
})

// string操作
func SetAndGet() {
    // set操作：第三个参数是过期时间，如果是0表示不会过期。
    defer rd.Close()    // 记得关闭连接
    err := rd.Set("prüfung", "hallo kugou",0).Err()

    if err != nil {
        fmt.Println("set err :",err)
        return
    }
    // get操作
    val,err := rd.Get("prüfung").Result()
    if err != nil {
        fmt.Println("get err :",err)
        return
    }
    fmt.Println("k1 ==",val)
}

// 声明一个全局的rdb变量
var rdb *redis.Client

// 初始化连接
func initClient() (err error) {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "10.23.1x.1x:6379",
        Password: "XixxxxxU", // no password set
        DB:       7,  // use default DB
    })

    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

//initClientS 哨兵模式
func initClientS()(err error){
    rdb := redis.NewFailoverClient(&redis.FailoverOptions{
        MasterName:    "master",
        SentinelAddrs: []string{"x.x.x.x:26379", "xx.xx.xx.xx:26379", "xxx.xxx.xxx.xxx:26379"},
    })
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

// cluster
func initClientC()(err error){
    rdb := redis.NewClusterClient(&redis.ClusterOptions{
        Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
    })
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

func redisExample() {
    err := rdb.Set("score", 100, 0).Err()
    if err != nil {
        fmt.Printf("set score failed, err:%v\n", err)
        return
    }

    val, err := rdb.Get("score").Result()
    if err != nil {
        fmt.Printf("get score failed, err:%v\n", err)
        return
    }
    fmt.Println("score", val)

    val2, err := rdb.Get("name").Result()
    if err == redis.Nil {
        fmt.Println("name does not exist")
    } else if err != nil {
        fmt.Printf("get name failed, err:%v\n", err)
        return
    } else {
        fmt.Println("name", val2)
    }
}


func main()  {
    ConnRedis()
    SetAndGet()


}

    image.png

    image.png

    gormgo
    锅包肉
    97 声望17 粉丝

    这个人很懒，没有什么说的。

    « 上一篇
    go v1.20 使用influxdb1.2.4 老版本 查询数据
    下一篇 »
    Mac 部署minikube 使用

    引用和评论

    推荐阅读
    头像
    vue3.2 +vite+echarts简单入门

    锅包肉阅读 1.3k

    头像
    腾讯 tRPC-Go 教学——（5）filter、context 和日志组件

    amc赞 2阅读 2.3k

    头像
    Go slice切片使用教程，一次通关！

    唐青枫赞 1阅读 778

    头像
    gozero限流、熔断、降级如何实现？面试的时候怎么回答？

    王中阳讲编程赞 2阅读 2k

    头像
    腾讯 tRPC-Go 教学——（1）搭建服务

    amc赞 1阅读 2k

    头像
    一文弄懂用Go实现MCP服务

    王中阳讲编程阅读 1.9k

    头像
    如何系统地入门学习stm32？

    良许赞 1阅读 868

    0 条评论
    得票最新