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



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

```sql

-- 建表语句
CREATE TABLE Employee (
  id INT PRIMARY KEY,
  name VARCHAR(50),
  department VARCHAR(50),
  managerId INT
);

-- 插入语句
-- 学习
INSERT INTO Employee (id, name, department, managerId) VALUES
  (101, 'John', 'A', NULL),
  (102, 'Dan', 'A', 101),
  (103, 'James', 'A', 101),
  (104, 'Amy', 'A', 101),
  (105, 'Anne', 'A', 101),
  (106, 'Ron', 'B', 101);



select e1.name from Employee as e1,
(select managerId from Employee group by managerId
having count(*)>=5)
as e2 where  e1.id=e2.managerId;

select managerId as id from Employee group by
managerId having count(*)>=5;

```

自连接



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

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

```sql

-- 建表语句
CREATE TABLE Insurance (
  pid INT PRIMARY KEY,
  tiv_2015 FLOAT,
  tiv_2016 FLOAT,
  lat FLOAT,
  lon FLOAT
);

-- 插入语句
INSERT INTO Insurance (pid, tiv_2015, tiv_2016, lat, lon) VALUES
  (1, 10.0, 5.0, 10.0, 10.0),
  (2, 20.0, 20.0, 20.0, 20.0),
  (3, 10.0, 30.0, 20.0, 20.0),
  (4, 10.0, 40.0, 40.0, 40.0);


select * from Insurance;

SELECT ROUND(SUM(tiv_2016), 2) AS tiv_2016
FROM Insurance
WHERE tiv_2015 IN (
    SELECT tiv_2015
    FROM Insurance
    GROUP BY tiv_2015
    HAVING COUNT(*) > 1
)
AND (lat, lon) NOT IN (
    SELECT lat, lon
    FROM Insurance
    GROUP BY lat, lon
    HAVING COUNT(*) > 1
);

SELECT ROUND(SUM(i1.tiv_2016), 2) AS tiv_2016
FROM Insurance i1
JOIN (
    SELECT tiv_2015
    FROM Insurance
    GROUP BY tiv_2015
    HAVING COUNT(*) > 1
) i2 ON i1.tiv_2015 = i2.tiv_2015
LEFT JOIN (
    SELECT lat, lon
    FROM Insurance
    GROUP BY lat, lon
    HAVING COUNT(*) > 1
) i3 ON i1.lat = i3.lat AND i1.lon = i3.lon
WHERE i3.lat IS NULL;

```
简洁的答案。


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


![image.png](/static/img/23c04dd0642994c4f1066e849cec3e6e.image.webp)
```sql
-- 建表语句
CREATE TABLE Activities (
  sell_date DATE,
  product VARCHAR(255)
);

-- 插入语句
INSERT INTO Activities (sell_date, product) VALUES
  ('2020-05-30', 'Headphone'),
  ('2020-06-01', 'Pencil'),
  ('2020-06-02', 'Mask'),
  ('2020-05-30', 'Basketball'),
  ('2020-06-01', 'Bible'),
  ('2020-06-02', 'Mask'),
  ('2020-05-30', 'T-Shirt');


SELECT sell_date, COUNT(DISTINCT product) AS num_sold, GROUP_CONCAT(DISTINCT product ORDER BY product) AS products
FROM Activities
GROUP BY sell_date
ORDER BY sell_date;
```
这个查询使用了 GROUP BY 子句按 sell_date 对数据进行分组。COUNT(DISTINCT product) 计算每个日期销售的不同产品的数量。GROUP_CONCAT(DISTINCT product ORDER BY product) 将每个日期销售的不同产品按词典序排序，并用逗号分隔连接起来。

最后，通过 ORDER BY 子句按 sell_date 对结果进行排序。

执行查询后，将返回按 sell_date 排序的结果表，包含 sell_date、num_sold 和 products 列。

## 总结
GROUP_CONCAT 函数用于将一组值连接成一个字符串，并可以选择性地添加分隔符。下面是 GROUP_CONCAT 函数的使用示例：

假设有一个名为 "Products" 的表，包含以下数据：

```
+----+---------+-------+
| ID | Product | Price |
+----+---------+-------+
| 1  | Apple   | 2.5   |
| 2  | Orange  | 1.8   |
| 3  | Banana  | 0.9   |
| 4  | Mango   | 3.2   |
+----+---------+-------+
```

1. 基本用法：

```sql
SELECT GROUP_CONCAT(Product) AS ProductList
FROM Products;
```

输出结果：

```
+-----------------------------+
| ProductList                 |
+-----------------------------+
| Apple,Orange,Banana,Mango   |
+-----------------------------+
```

上述查询将 "Product" 列中的所有值连接成一个字符串，并使用逗号作为默认的分隔符。

2. 指定分隔符：

```sql
SELECT GROUP_CONCAT(Product SEPARATOR '; ') AS ProductList
FROM Products;
```

输出结果：

```
+---------------------------------+
| ProductList                     |
+---------------------------------+
| Apple; Orange; Banana; Mango    |
+---------------------------------+
```

在上述查询中，我们使用 `SEPARATOR` 关键字指定分隔符为分号和空格。

3. 排序和去重：

```sql
SELECT GROUP_CONCAT(DISTINCT Product ORDER BY Product DESC) AS ProductList
FROM Products;
```

输出结果：

```
+-----------------------------+
| ProductList                 |
+-----------------------------+
| Orange, Mango, Banana, Apple |
+-----------------------------+
```

在上述查询中，我们使用 `DISTINCT` 关键字去除重复值，并使用 `ORDER BY` 子句按照降序对值进行排序。

4. 设置最大连接长度：

```sql
SET SESSION group_concat_max_len = 10000;
```

上述语句设置 `group_concat_max_len` 变量的值为 10000，以增加 GROUP_CONCAT 函数连接的最大长度。默认情况下，该变量的值为 1024。

注意：GROUP_CONCAT 函数的结果字符串长度受到 `group_concat_max_len` 变量和服务器的 SQL 模式限制。

SQL查询训练(10)

今天重装服务器系统重装docker,遇到以下问题，之前很多次都有这个问题，不过过段时间忘记解
决方法了，这里记录下



```
ubuntu@VM-8-16-ubuntu:~$ docker ps
Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/json": dial unix /var/run/docker.sock: connect: permission denied

```
表示当前用户没有权限读写`/var/run/docker.sock`文件，Docker守护进程利用这个文件和容器通信，没有权限给他权限就是
```
sudo chmod 666 /var/run/docker.sock
```
在 Linux 中，权限由三个数字表示，每个数字范围从 0 到 7，分别代表不同的权限级别。每个数字表示文件所有者、所属组和其他用户的权限。

数字权限表示如下：

- 0：没有权限（没有读、写和执行权限）
- 1：执行权限
- 2：写权限
- 3：写和执行权限
- 4：读权限
- 5：读和执行权限
- 6：读和写权限
- 7：读、写和执行权限
- 在上述数字中，每个数字对应的权限是相加的。例如，权限为 666 表示：
- 
所有者具有读和写权限（6）
所属组具有读和写权限（6）
其他用户具有读和写权限（6）
换句话说，对于文件的所有者、所属组和其他用户，都具有读和写的权限，没有执行权限。

转念一想，666这个权限是不是太那啥了，所有用户都能读写修改，当然，但是对于个人学习没问题，接下来是正确做法，我们应当赋予660权限，限制用户，只要我们把当前用户加入docker用户组就可以操作如下
```
ubuntu@VM-8-16-ubuntu:~$ sudo chmod 660 /var/run/docker.sock
ubuntu@VM-8-16-ubuntu:~$ sudo groupadd docker
ubuntu@VM-8-16-ubuntu:~$ sudo usermod -aG docker $USER
ubuntu@VM-8-16-ubuntu:~$ newgrp docker

```

执行完后重启生效，reboot。

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

Docker读写权限问题

Is a minor in computer science hard?
Honestly, while it’s going to depend on you, the biggest single factor I have seen in success vs. failure in CS minors is do you enjoy programming? A typical CS minor is 4–7 courses, and that will almost always include an intro programming course and a course on data structures. Figure half of the coursework will be focused on learning programming.



I think every college student should try an intro CS class, and if you look at institutions like Harvard and Stanford, they and their students agree (it’s not everyone, but it’s most, to the best of my knowledge). You might love it, you might hate it. If you don’t want to major in CS, wait until you’ve had some challenging courses and grown a bit. Then take an intro CS (programming) class. If you think, “wow, this is fun, even when it’s frustrating as hell”, go for the minor. If you think, “I’d rather write an analysis of patterns of drying paint”, then don’t try.


:::info{title="中文翻译"}
辅修计算机科学难吗？
 老实说，虽然这取决于你，但我所看到的计算机未成年人成功与失败的最大单一因素是你喜欢编程吗？ 典型的计算机辅修课程是 4-7 门课程，其中几乎总是包括入门编程课程和数据结构课程。 图一半的课程作业将集中于学习编程。

 我认为每个大学生都应该尝试一门计算机入门课程，如果你看看哈佛和斯坦福这样的机构，他们和他们的学生都同意这一点（据我所知，不是每个人，但这是大多数人）。 你可能喜欢它，也可能讨厌它。 如果你不想主修计算机科学，请等到你完成了一些具有挑战性的课程并成长了一些。 然后参加 CS（编程）入门课程。 如果你想，“哇，这很有趣，即使它令人沮丧”，那就选择未成年人吧。 如果您认为“我宁愿写一篇关于干燥油漆模式的分析”，那么就不要尝试。
:::

1. **Is:** 是
2. **a:** 一个
3. **minor:** 辅修
4. **in:** 在
5. **computer:** 计算机
6. **science:** 科学
7. **hard:** 难的
8. **Honestly:** 说实话
9. **while:** 虽然
10. **it’s:** 它是
11. **going:** 进行
12. **to:** 到
13. **depend:** 取决
14. **on:** 在
15. **you:** 你
16. **the:** 这
17. **biggest:** 最大的
18. **single:** 单一的
19. **factor:** 因素
20. **have:** 有
21. **seen:** 看到
22. **in:** 在
23. **success:** 成功
24. **vs.:** 对比
25. **failure:** 失败
26. **CS:** 计算机科学
27. **minors:** 辅修生
28. **is:** 是
29. **do:** 做
30. **you:** 你
31. **enjoy:** 喜欢
32. **programming:** 编程
33. **A:** 一个
34. **typical:** 典型的
35. **CS:** 计算机科学
36. **minor:** 辅修
37. **is:** 是
38. **4–7:** 4至7
39. **courses:** 课程
40. **and:** 和
41. **that:** 那
42. **will:** 将
43. **almost:** 几乎
44. **always:** 总是
45. **include:** 包括
46. **an:** 一个
47. **intro:** 入门
48. **programming:** 编程
49. **course:** 课程
50. **and:** 和
51. **a:** 一个
52. **course:** 课程
53. **on:** 在
54. **data:** 数据
55. **structures:** 结构
56. **Figure:** 想象
57. **half:** 一半
58. **of:** 的
59. **the:** 这
60. **coursework:** 课程
61. **will:** 将
62. **be:** 是
63. **focused:** 着重
64. **on:** 在
65. **learning:** 学习
66. **programming:** 编程
67. **I:** 我
68. **think:** 认为
69. **every:** 每个
70. **college:** 大学
71. **student:** 学生
72. **should:** 应该
73. **try:** 尝试
74. **an:** 一个
75. **intro:** 入门
76. **CS:** 计算机科学
77. **class:** 班级
78. **and:** 和
79. **if:** 如果
80. **you:** 你
81. **look:** 看
82. **at:** 在
83. **institutions:** 机构
84. **like:** 喜欢
85. **Harvard:** 哈佛
86. **and:** 和
87. **Stanford:** 斯坦福
88. **they:** 他们
89. **and:** 和
90. **their:** 他们的
91. **students:** 学生
92. **agree:** 同意
93. **it’s:** 它是
94. **not:** 不是
95. **everyone:** 每个人
96. **but:** 但
97. **it’s:** 它是
98. **most:** 大多数
99. **to:** 到
100. **the:** 这
101. **best:** 最好
102. **of:** 的
103. **my:** 我的
104. **knowledge:** 知识
105. **You:** 你
106. **might:** 可能
107. **love:** 爱
108. **it:** 它
109. **you:** 你
110. **might:** 可能
111. **hate:** 恨
112. **it:** 它
113. **If:** 如果
114. **you:** 你
115. **don’t:** 不
116. **want:** 想要
117. **to:** 到
118. **major:** 主修
119. **in:** 在
120. **CS:** 计算机科学
121. **wait:** 等待
122. **until:** 直到
123. **you’ve:** 你有
124. **had:** 有
125. **some:** 一些
126. **challenging:** 具有挑战性的
127. **courses:** 课程
128. **and:** 和
129. **grown:** 成长
130. **a:** 一个
131. **bit:** 位
132. **Then:** 然后
133. **take:** 拿
134. **an:** 一个
135. **intro:** 入门
136. **CS:** 计算机科学
137. **(programming):** （编程）
138. **class:** 班级
139. **If:** 如果
140. **you:** 你
141. **think:** 认为
142. **“wow:** “哇
143. **this:** 这
144. **is:** 是
145. **fun:** 有趣
146. **even:** 甚至
147. **when:** 当
148. **it’s:** 它是
149. **frustrating:** 令人沮丧
150. **as:** 如同
151. **hell”:** 地狱
152. **go:** 去
153. **for:** 对于
154. **the:** 这
155. **minor:** 辅修
156. **If:** 如果
157. **you:** 你
158. **think:** 认为
159. **“I’d:** “我宁愿
160. **rather:** 更愿意
161. **write:** 写
162. **an:** 一个
163. **analysis:** 分析
164. **of:** 的
165. **patterns:** 模式
166. **of:** 的
167. **drying:** 干燥
168. **paint”:** 油漆
169. **then:** 然后
170. **don’t:** 
171. **try:** 尝试

英语翻译14(Quora问题)

Gorm-README

报错如下
```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)


}
```

Go-MySQL-Driver