报错如下
```go
 sql: Scan error on column index 0, name "created_at": unsupported Scan, storing driver.Value type []uint8 into type *time.Time
```



解决方法
在mysql dsn加上
```
parseTime=true
```
解决


一.gorm连接mysql数据库

gorm支持多种数据库，这里主要介绍mysql,连接mysql主要有两个步骤:

配置DSN (Data Source Name)

使用gorm.Open连接数据库


1. 配置DSN (Data Source Name)


gorm库使用dsn作为连接数据库的参数，dsn翻译过来就叫数据源名称，用来描述数据库连接信息。一般都包含数据库连接地址，账号，密码之类的信息。

DSN格式：
```
[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]
```
mysql连接dsn例子：

```go
//mysql dsn格式
//涉及参数:
//username   数据库账号
//password   数据库密码
//host       数据库连接地址，可以是Ip或者域名
//port       数据库端口
//Dbname     数据库名
username:password@tcp(host:port)/Dbname?charset=utf8&parseTime=True&loc=Local

//填上参数后的例子
//username = root
//password = 123456
//host     = localhost
//port     = 3306
//Dbname   = tizi365
//后面K/V键值对参数含义为：
//  charset=utf8 客户端字符集为utf8
//  parseTime=true 支持把数据库datetime和date类型转换为golang的time.Time类型
//  loc=Local 使用系统本地时区
root:123456@tcp(localhost:3306)/tizi365?charset=utf8&parseTime=True&loc=Local

//gorm 设置mysql连接超时参数
//开发的时候经常需要设置数据库连接超时参数，gorm是通过dsn的timeout参数配置
//例如，设置10秒后连接超时，timeout=10s
//下面是完成的例子
root:123456@tcp(localhost:3306)/tizi365?charset=utf8&parseTime=True&loc=Local&timeout=10s

//设置读写超时时间
// readTimeout - 读超时时间，0代表不限制
// writeTimeout - 写超时时间，0代表不限制
root:123456@tcp(localhost:3306)/tizi365?charset=utf8&parseTime=True&loc=Local&timeout=10s&readTimeout=30s&writeTimeout=60s

```
2. 使用gorm.Open连接数据库
有了上面配置的dsn参数，就可以使用gorm连接数据库，下面是连接数据库的例子
```go
package main

import (
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)

func main()  {
    //配置MySQL连接参数
	username := "root"  //账号
	password := "123456" //密码
	host := "127.0.0.1" //数据库地址，可以是Ip或者域名
	port := 3306 //数据库端口
	Dbname := "tizi365" //数据库名
	timeout := "10s" //连接超时，10秒
	
	//拼接下dsn参数, dsn格式可以参考上面的语法，这里使用Sprintf动态拼接dsn参数，因为一般数据库连接参数，我们都是保存在配置文件里面，需要从配置文件加载参数，然后拼接dsn。
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local&timeout=%s", username, password, host, port, Dbname, timeout)
	//连接MYSQL, 获得DB类型实例，用于后面的数据库读写操作。
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	//延时关闭数据库连接
	defer db.Close()
}

```
3. gorm调试模式
为了方便调试，了解gorm操作到底执行了怎么样的sql语句，开发的时候需要打开调试日志，这样gorm会打印出执行的每一条sql语句。

使用Debug函数执行查询即可
例子：
```go
result := db.Debug().Where("username = ?", "tizi365").First(&u)
```
二.gorm连接池
在高并发实践中，为了提高数据库连接的使用率，避免重复建立数据库连接带来的性能消耗，会经常使用数据库连接池技术来维护数据库连接。
gorm自带了数据库连接池使用非常简单只要设置下数据库连接池参数即可。

数据库连接池使用例子：
定义tools包，负责数据库初始化工作
```go
//定义一个工具包，用来管理gorm数据库连接池的初始化工作。
package tools

//定义全局的db对象，我们执行数据库操作主要通过他实现。
var _db *gorm.DB

//包初始化函数，golang特性，每个包初始化的时候会自动执行init函数，这里用来初始化gorm。
func init() {
    ...忽略dsn配置，请参考上面例子...
    
    // 声明err变量，下面不能使用:=赋值运算符，否则_db变量会当成局部变量，导致外部无法访问_db变量
    var err error
    //连接MYSQL, 获得DB类型实例，用于后面的数据库读写操作。
    _db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
     
    sqlDB, _ := db.DB()

    //设置数据库连接池参数
    sqlDB.SetMaxOpenConns(100)   //设置数据库连接池最大连接数
    sqlDB.SetMaxIdleConns(20)   //连接池最大允许的空闲连接数，如果没有sql任务需要执行的连接数大于20，超过的连接会被连接池关闭。
}

//获取gorm db对象，其他包需要执行数据库查询的时候，只要通过tools.getDB()获取db对象即可。
//不用担心协程并发使用同样的db对象会共用同一个连接，db对象在调用他的方法的时候会从数据库连接池中获取新的连接
func GetDB() *gorm.DB {
	return _db
}
```
使用例子：
```go
package main
//导入tools包
import tools

func main() {
    //获取DB
    db := tools.GetDB()
    
    //执行数据库查询操作
    u := User{}
	//自动生成sql： SELECT * FROM `users`  WHERE (username = 'tizi365') LIMIT 1
	db.Where("username = ?", "tizi365").First(&u)
}
```
注意：使用连接池技术后，千万不要使用完db后调用db.Close关闭数据库连接，这样会导致整个数据库连接池关闭，导致连接池没有可用的连接。

更多使用  

```go
package main

import (
    
    "fmt"

    //_ "github.com/go-sql-driver/mysql"
    //"github.com/jinzhu/gorm"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type Students struct {
    gorm.Model
    Username string `gorm:"type:varchar(20);not null " `
    Password string `gorm:"type:varchar(500);not null" `
    Age      int    `gorm:"type:int;DEFAULT:18" `
}

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

    if err != nil {
        fmt.Println("连接数据库出错：", err)
    }


    db.AutoMigrate(&Students{})
    user := Students{Username: "Jinzhu", Age: 18, Password: "123456"}

    result := db.First(&user)
    fmt.Println(result)
    db.Take(&user)


    //result := db.Create(&user) // 通过数据的指针来创建
    //fmt.Println(result)


}
```

Gorm报错[]uint8不能转换为time.*Time

ImServer架构图

在 GORM 中，可以使用标签（tag）来定义和应用约束，这些约束将在模型与数据库表之间进行映射。下面是 GORM 中常用的约束及其用法的详细解释：



1. 主键约束（Primary Key Constraint）：使用 `primaryKey` 标签将字段标记为主键。

```go
type User struct {
    ID   uint `gorm:"primaryKey"`
    Name string
    Age  int
}
```

2. 自动增长约束（Auto Increment Constraint）：使用 `autoIncrement` 标签将字段标记为自动增长。

```go
type User struct {
    ID   uint `gorm:"primaryKey;autoIncrement"`
    Name string
    Age  int
}
```

3. 唯一约束（Unique Constraint）：使用 `unique` 标签将字段标记为唯一约束。

```go
type User struct {
    ID   uint   `gorm:"primaryKey"`
    Name string `gorm:"unique"`
    Age  int
}
```

4. 非空约束（Not Null Constraint）：使用 `not null` 标签将字段标记为非空约束。

```go
type User struct {
    ID   uint   `gorm:"primaryKey"`
    Name string `gorm:"not null"`
    Age  int
}
```

5. 默认值约束（Default Value Constraint）：使用 `default` 标签指定字段的默认值。

```go
type User struct {
    ID   uint   `gorm:"primaryKey"`
    Name string `gorm:"default:'John'"`
    Age  int    `gorm:"default:18"`
}
```

6. 外键约束（Foreign Key Constraint）：使用 `foreignKey` 标签定义外键关系。外键约束需要在相关联的模型之间建立关联，并使用 `references` 标签指定外键关联的字段。

```go
type User struct {
    ID       uint `gorm:"primaryKey"`
    RoleID   uint
    Role     Role `gorm:"foreignKey:RoleID"`
}

type Role struct {
    ID   uint `gorm:"primaryKey"`
    Name string
}
```

7. 索引约束（Index Constraint）：使用 `index` 标签在字段上创建索引。

```go
type User struct {
    ID   uint   `gorm:"primaryKey"`
    Name string `gorm:"index"`
    Age  int
}
```

这些约束标签可以组合使用，以适应更复杂的需求。在定义完模型结构体后，可以使用 `AutoMigrate()` 函数将约束应用于数据库表。

请注意，约束的具体语法和用法可能会因数据库类型而有所不同，因此在使用特定数据库时，建议

gorm定义约束

![image.png](/static/img/03a1a832e777a294d48725beedaf4b69.image.webp)

kuberbetes架构

![image.png](/static/img/7a99436a5113247b14103836a3dbf52e.image.webp)

![image.png](/static/img/bfe486f4cc8e86027487c9339647c752.image.webp)

![image.png](/static/img/893b40f91cc29c0a71e592e3b8adff08.image.webp)

```sql
create table Employee(
       id int primary key,
       salary int
);

insert into Employee values (4,400),(5,500),(6,600);


select * from Employee;


select (select distinct salary
        from Employee order by
        salary desc limit 1 offset 2)
        as SecondHighestSalary;

select max(salary) from Employee
where salary < (select max(salary)
from Employee);


select ifnull((select distinct salary
        from Employee order by
        salary desc limit 1 offset 1),null)
        as SecondHighestSalary;


create function getNthHighestSalary(n int) returns int
    DETERMINISTIC
begin
declare m int;
    set m = n-1;
    return(
        select distinct salary
        from Employee order by
        salary desc limit 1 offset m
);
end;

drop function getNthHighestSalary;

select getNthHighestSalary(4);
```
## 总结一

![image.png](/static/img/85673c9b2253a657fc2ae348f5318417.image.webp)

![image.png](/static/img/09afb12d4ed5516cbbaeab84c7d297e4.image.webp)




![image.png](/static/img/578ff7a04facc4e62d61bc2dc4eeb3ee.image.webp)

![image.png](/static/img/937d87d3c1934d6505b6d6fc59c2e58b.image.webp)
```sql


create table Scores(
    id int primary key ,
    score int
);



insert into Scores values (1,50),(2,55),(3,69),(4,50),(5,43),(6,55);
select * from Scores;



select s1.score, (select count(distinct s2.score)
from Scores s2 where s2.score >= s1.score) 
as 'rank' from Scores as s1 order by s1.score desc ;



select s1.score, (select count(distinct s2.score)
from Scores s2 where s2.score >= s1.score) as 'rank'
from Scores as s1;



SELECT
    S.score,
    dense_rank() OVER (ORDER BY S.score DESC) AS `rank`

FROM Scores AS S;
```
MySQL 8.0版本引入了窗口函数（Window Function），它是一种强大的查询工具，能够对数据集进行分组、排序和聚合操作，并且可以在结果集中的每一行上进行计算。下面详细介绍MySQL中的所有窗口函数。

1. `ROW_NUMBER()`: 为结果集中的每一行分配一个唯一的整数值，表示行的序号。

2. `RANK()`: 对结果集中的行进行排序，并为每一行分配一个排名值。如果有相同的值，则排名相同，下一个排名将被跳过。

3. `DENSE_RANK()`: 类似于`RANK()`函数，但是如果有相同的值，则排名相同，下一个排名不会被跳过。

4. `NTILE(n)`: 将结果集划分为指定数量的桶（bucket），并为每一行分配一个桶号。比如，`NTILE(4)`将结果集划分为4个桶，每个桶中包含相同数量的行。

5. `LEAD(expression, offset, default)`: 返回当前行之后指定偏移量的行的值。如果偏移量超出结果集的范围，则返回默认值。默认偏移量为1。

6. `LAG(expression, offset, default)`: 返回当前行之前指定偏移量的行的值。如果偏移量超出结果集的范围，则返回默认值。默认偏移量为1。

7. `FIRST_VALUE(expression)`: 返回结果集中第一行的指定表达式的值。

8. `LAST_VALUE(expression)`: 返回结果集中最后一行的指定表达式的值。

9. `NTH_VALUE(expression, n)`: 返回结果集中指定位置（n）的行的指定表达式的值。

这些窗口函数可以与`OVER`子句一起使用，用于定义窗口范围（Window Frame），以确定窗口函数计算的行的范围。常见的窗口范围包括`ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`（从开始到当前行）、`ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`（从开始到结束）等。

窗口函数的语法示例：
```sql
SELECT 
    column1,
    column2,
    ROW_NUMBER() OVER (ORDER BY column1) AS row_number,
    RANK() OVER (ORDER BY column2) AS rank,
    DENSE_RANK() OVER (ORDER BY column2) AS dense_rank,
    NTILE(4) OVER (ORDER BY column1) AS ntile,
    LEAD(column1) OVER (ORDER BY column1) AS lead_value,
    LAG(column1) OVER (ORDER BY column1) AS lag_value,
    FIRST_VALUE(column1) OVER (ORDER BY column1) AS first_value,
    LAST_VALUE(column1) OVER (ORDER BY column1) AS last_value,
    NTH_VALUE(column1, 3) OVER (ORDER BY column1) AS nth_value
FROM your_table;
```

这个示例展示了如何在查询中使用窗口函数。你需要将`your_table`替换为你的实际表名，并根据需要选择和调整窗口函数及其参数。