内连接查询联系1

• 查询底薪超过公司平均底薪的员工信息？

# 查询底薪超过公司平均底薪的员工信息？
SELECT e2.empno,e2.ename,e2.sal
FROM t_emp e1 JOIN t_emp e2 WHERE e2.sal>=AVG(e1.sal);

SELECT e.empno,e.ename,e.sal
FROM t_emp e JOIN 
(SELECT AVG(sal) avg FROM t_emp) t
ON e.sal>=t.avg;

• 查询 RESEARCH 部门的 人数、最高底薪、最低底薪、平均底薪、平均工龄？

# 查询 `RESEARCH` 部门的 人数、最高底薪、最低底薪、平均底薪、平均工龄？
SELECT COUNT(*),MAX(e.sal),MIN(e.sal),AVG(e.sal),
AVG(DATEDIFF(NOW(),e.hiredate)/365)
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno
WHERE d.dname="RESEARCH";

SELECT FLOOR(28.9);

# 查询 `RESEARCH` 部门的 人数、最高底薪、最低底薪、平均底薪、平均工龄？
SELECT COUNT(*),MAX(e.sal),MIN(e.sal),AVG(e.sal),
FLOOR(AVG(DATEDIFF(NOW(),e.hiredate)/365))
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno
WHERE d.dname="RESEARCH";

SELECT FLOOR(28.9);
SELECT CEIL(1.1);

内连接查询联系2

• 查询每种职业的 最高工资、最低工资、平均工资、最高工资等级 和 最低工资等级 ？

# 查询每种职业的 `最高工资`、`最低工资`、`平均工资`、`最高工资等级` 和 `最低工资等级` ？

SELECT
e.job,
MAX(e.sal+IFNULL(e.comm,0)),
MIN(e.sal+IFNULL(e.comm,0)),
AVG(e.sal+IFNULL(e.comm,0)),
MAX(s.grade),
MIN(s.grade)
FROM t_emp E JOIN t_salgrade s
on (e.sal+IFNULL(e.comm,0)) BETWEEN s.losal AND s.hisal
GROUP BY e.job

• 查询每个底薪超过部门平均底薪的员工信息

# 查询每个底薪超过部门平均底薪的员工信息
SELECT e.empno,e.ename,e.sal
FROM t_emp e JOIN 
(SELECT deptno,AVG(sal) AS avg FROM t_emp GROUP BY deptno) t
ON e.deptno=t.deptno AND e.sal>=t.avg;

从多张表中提取数据

• 从多张表提取数据，必须指定关联的条件。如果不定义关联条件就会出现无条件连接，两张表的数据会交叉连接，产生 笛卡尔积。

  

• 规定了连接条件的表连接语句，就不会出现笛卡尔积。

  

# 查询每名员工的部门信息
SELECT e.empno,e.ename,d.dname
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno;

表连接的分类

• 表连接分为两种：内连接 和 外连接
• 内连接是结果集中只保留符合连接条件的记录
• 外连接是不管符不符合连接条件，记录都要保留在结果集中

内连接的简介

• 内连接是最常见的一种表连接，用于查询多张关系表符合连接条件的记录。

  

内连接的多种语法形式

SELECT ...... FROM 表1 JOIN 表2 ON 连接条件;

SELECT ...... FROM 表1 JOIN 表2 WHERE 连接条件;

SELECT ...... FROM 表1, 表2 WHERE 连接条件;

# 查询每名员工的部门信息
SELECT e.empno,e.ename,d.dname
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno;

SELECT e.empno,e.ename,d.dname
FROM t_emp e JOIN t_dept d WHERE e.deptno=d.deptno;

SELECT e.empno,e.ename,d.dname
FROM t_emp e , t_dept d WHERE e.deptno=d.deptno;

内连接练习1

• 查询每个员工的 工号、姓名、部门名称、底薪、职位、工资等级？

# 查询每个员工的 工号、姓名、部门名称、底薪、职位、工资等级？
SELECT e.empno,e.ename,d.dname,e.sal,e.job,s.grade
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno
JOIN t_salgrade s ON e.sal BETWEEN s.losal AND s.hisal;

• 内连接的数据表不一定必须有同名字段，只要字段之间符合逻辑关系就可以

内连接练习2

• 查询与 SCOTT 相同部门的员工都有谁？

# 查询与 SCOTT 相同部门的员工都有谁？
SELECT ename
FROM t_emp
WHERE deptno=(SELECT deptno FROM t_emp WHERE ename="SCOTT")
AND ename!="SCOTT";

# 查询与 SCOTT 相同部门的员工都有谁？

SELECT e2.ename
FROM t_emp e1 JOIN t_emp e2 ON e1.deptno=e2.deptno
WHERE e1.ename="SCOTT" AND e2.ename!="SCOTT";

• 相同的数据表也可以做表连接

分组查询遇到的困难？

• 查询部门平均底薪超过2000元的部门编号

错误示范
SELECT deptno FROM t_emp
WHERE AVG(sal) >=2000 -- 错在这里出现了聚合函数
GROUP BY deptno;

引入 HAVING 子句
SELECT deptno
FROM t_emp
GROUP BY deptno HAVING AVG(sal)>=2000;

HAVING 子句的用途

• 查询每个部门中，1982 年以后入职的员工超过 2 个人的部门编号。

SELECT deptno FROM t_emp
WHERE hiredate>="1982-01-01"
GROUP BY deptno HAVING COUNT(*) >= 2
ORDER BY deptno ASC;

# 查询每个部门中，1982年以后入职的员工超过2个人的部门编号
SELECT deptno
FROM t_emp
WHERE hiredate>="1982-01-01"
GROUP BY deptno HAVING COUNT(*)>=2;

# 查询每个部门中，1982年以后入职的员工超过2个人的部门编号
SELECT deptno
FROM t_emp
WHERE hiredate>="1982-01-01"
GROUP BY deptno HAVING COUNT(*)>=2 AND AVG(sal)>=2000;

错误示范
# 查询每个部门中，1982年以后入职的员工超过2个人的部门编号
SELECT deptno
FROM t_emp
WHERE hiredate>="1982-01-01"
GROUP BY deptno HAVING COUNT(*)>=2 AND sal>=AVG(sal);

HAVING 子句的特殊用法

• 按照数字 1 分组，MySQL 会依据 SELECT 子句中的列进行分组，HAVING 子句也可以正常使用

SELECT deptno,COUNT(*) FROM t_emp
GROUP BY 1;

SELECT deptno,COUNT(*) FROM t_emp
GROUP BY 1 HAVING deptno IN(10,20);
-- 不建议这么写，浪费资源

SELECT deptno,COUNT(*) 
FROM t_emp
WHERE deptno IN(10,20)
GROUP BY 1;
-- 推荐这么写

为什么要分组？

• 默认情况下汇总函数是对全表范围内的数据做统计
• GROUP BY 子句的作用是通过一定的规则将一个数据集划分成若干个小的区域，然后针对每个小区域分别进行数据汇总处理

SELECT deptno,AVG(sal) FROM t_emp
GROUP BY deptno;

SELECT deptno,ROUND(AVG(sal)) FROM t_emp
GROUP BY deptno;
-- ROUND 取整

逐级分组

• 数据库支持多列分组条件，执行的时候逐级分组。
• 查询每个部分里，每种职位的人员数量和平均底薪

SELECT deptno,job,COUNT(*),AVG(sal)
FROM t_emp GROUP BY deptno,job
ORDER BY deptno;

SELECT deptno,job,COUNT(*),AVG(sal) 
FROM t_emp
GROUP BY deptno,job
ORDER BY deptno

对 SELECT 子句的要求

• 查询语句中如果含有 GROUP BY 子句，那么 SELECT 子句中的内容就必须要遵守规定：
  • SELECT 子句中可以包含聚合函数，或者 GROUP BY 子句的分组列，其余内容君不可出现在 SELECT 子句中。

SELECT deptno,COUNT(*),AVG(sal)
FROM t_emp GROUP BY deptno;

SELECT dept_no,COUNT(*),AVG(sal),sal
FROM t_emp GROUP BY deptno;
-- XXXXXXXXXXXXXX

查看规则校验

SELECT @@GLOBAL.sql_mode;
SELECT @@SESSION.sql_mode;

对分组结果集再次做汇总计算

SELECT
    deptno,COUNT(*),AVG(sal),MAX(sal),MIN(sal)
FROM t_emp GROUP BY deptno WITH ROLLUP
-- WITH ROLLUP 汇总

SELECT deptno,AVG(sal),SUM(sal),MAX(sal),MIN(sal),count(*)
FROM t_emp
GROUP BY deptno WITH ROLLUP

GROUP_CONCAT 函数

• GROUP_CONCAT 函数可以把分组查询中的某个字段拼接成一个字符串

• 查询每个部门内底薪超过2000元的人数和员工命令

SELECT deptno,GROUP_CONCAT(ename),COUNT(*)
FROM t_emp WHERE sal>=2000
GROUP BY deptno;

SELECT deptno,COUNT(*),GROUP_CONCAT(ename)
FROM t_emp
WHERE sal>=2000
GROUP BY deptno;

各种子句的执行顺序

• 查询语句中，GROUP BY 子句应该被 第几个执行？

FROM -> WHERE -> GROUP BY -> SELECT -> ORDER BY -> LIMIT

什么是聚合函数

• 聚合函数在数据的查询分析中，应用十分广泛。聚合函数可以对 数据求和、求 最大值 和 最小值 、求 平均值 等等。
• 求公司员工的评价月收入是多少？

SELECT AVG(sal+IFNULL(comm,0)) FROM t_emp;

SELECT AVG(sal+IFNULL(comm,0)) AS avg
FROM t_emp;

SUM 函数

• SUM 函数用于求和，只能用户数字类型，字符类型的统计结果为 0 ，日期类型统计结果是毫秒数相加

SELECT SUM(ename) FROM t_emp;

SELECT SUM(sal) FROM t_emp
WHERE deptno IN (10,20);

SELECT SUM(sal)
FROM t_emp WHERE deptno IN(10,20);

MAX 函数

• MAX 函数用于获得非空值的最大值。

SELECT MAX(comm) FROM t_emp;

• 问题1：查询10和20部门中，月收入最高的员工？

SELECT MAX(sal+IFNULL(comm,0)) FROM t_emp
WHERE deptno IN(10,20)

• 问题2：查询员工名字最长的是几个字符？

SELECT MAX(LENGTH(ename)) FROM t_emp;

MIN 函数

• MIN 函数用于获得非空值的最小值。

SELECT MIN(empno) FROM t_emp;
SELECT MIN(hiredate) FROM t_emp;

AVG 函数

• AVG 函数用于获得非空值的平均值，非数字数据统计结果为 0

SELECT AVG(sal+IFNULL(comm,0)) FROM t_emp;

SELECT AVG(ename) FROM t_emp;

COUNT 函数

• COUNT(*) 用于获得包含空值的记录数，COUNT(列名) 用于获得包含非空值的记录数。

SELECT COUNT(*) FROM t_emp;

SELECT COUNT(comm) FROM t_emp;

SELECT 
    COUNT(*), COUNT(comm)
FROM t_emp;

• 查询 10 和 20 部门中，底薪超过 2000 元并且工龄超过 15 年的员工人数？

SELECT COUNT(*) FROM t_emp
WHERE deptno IN(10,20) AND sal>= 2000
AND DATEDIFF(NOW(), hiredate)/365>=15;

• 查询 1985 年以后入职的员工，底薪超过公司平均底薪的员工数量？

SELECT COUNT(*) FROM t_emp
WHERE hiredate>="1985-01-01"
AND sal>AVG(sal); -- XXXXXXXX
-- 聚合函数永远不能出现在 WHERE 子句里面

逻辑运算符

SELECT
    ename,deptno
FROM t_emp
WHERE NOT deptno IN(10,20);
WHERE NOT deptno IN(10,20) XOR sal>=2000;

二进制按位运算

• 二进制位运算的实质是将参与运算的两个操作数，按对应的二进制数逐位进行逻辑运算。

SELECT 3 & 7;

按位运算符

WHERE 子句的注意事项

• WHERE 子句中，条件执行的顺序是从左到右的。所以我们应该把索引条件，或者筛选掉记录最多的条件写在最左侧

• 子句优先级
  • 索引条件最左边，再是筛选最多的，最后是普通条件

各种子句的执行顺序

• 条件查询中，WHERE 子句应该是第几个执行？

​ FROM -> WHERE -> SELECT -> ORDER BY -> LIMIT

条件查询

• 很多时候，用户感兴趣的并不是逻辑表里的全部记录，

  而只是他们当中能够满足某一种或某几种条件的记录。这类条件要用 WHERE 子句来实现数据的筛选

SELECT ...... FROM ..... WHERE 条件 [AND | OR] 条件 ...... ;

SELECT empno,ename,sal
FROM t_emp
WHERE deptno=10 AND sal>=2000;
WHERE (deptno=10 OR deptno=20)AND sal>=2000;

四类运算符

• WHERE 语句中的条件运算会用到以下四种运算符：

算数运算符

查询 10 部门里面 年收入超过 15K 美金，并且工龄超过二十年 的员工信息

SELECT empno,ename,sal,hiredate
FROM t_emp
WHERE deptno=10 AND (sal+IFNULL(comm,0))*12>=15000;
AND DATEDIFF(NOW(),hiredata)/265>=20;

-- 获取当前日期
SELECT NOW()
-- 引入一个新函数 IFNLL 若第一个参数为 NULL 则返回第二个参数
SELECT 10+IFNULL(null,0);

比较运算符（一）

查询 10,20,30 部门里面，在 1985 年以前入职的员工并且不是 saselmen 员工的信息

SELECT 
    empno,ename,sal,deptno,hiredate
FROM t_emp
WHERE deptno IN(10,20,30) AND job!="SALESMAN"
AND hiredate<"1985-01-01";

比较运算符（二）

SELECT 
ename,comm,sal
FROM t_emp WHERE comm IS NOT NULL

SELECT 
    ename,comm,sal
FROM t_emp WHERE comm IS NULL
AND sal BETWEEN 2000 AND 3000;

SELECT 
    ename,comm,sal
FROM t_emp WHERE comm IS NULL
AND sal BETWEEN 2000 AND 3000
AND ename LIKE "%A%";

SELECT 
    ename,comm,sal
FROM t_emp WHERE comm IS NULL
AND sal BETWEEN 2000 AND 3000
AND ename LIKE "_LAKE";
-- _ 运算符

SELECT 
    ename,comm,sal
FROM t_emp WHERE comm IS NOT NULL
AND sal BETWEEN 1000 AND 3000
AND ename REGEXP "^[\\u4e00-\\u9fa5]{2,4}$";
-- 两到四个字符的中文

结果集中的重复记录

• 假如我们要查询员工表有多少种职业，写出来的 SQL 语句如下：

去除重复记录

• 如果我们需要去除重复的数据，可以使用 DISTINCT 关键字来实现

SELECT DISTINCT 字段 FROM ......;

SELECT job FROM t_emp;
SELECT DISTINCT job FROM t_emp;

注意事项

• 使用 DISTINCT 的 SELECT 子句中只能查询一列数据，如果查询多列，去除重复记录就会失效。

• DISTINCT 关键字只能在 SELECT 子句中使用一次

SELECT DISTINCT job FROM t_emp;
SELECT DISTINCT job,ename FROM t_emp;
SELECT DISTINCT job,DISTINCT ename FROM t_emp;
SELECT job,DISTINCT ename FROM t_emp;

• 如果没有设置，查询语句不会对结果集进行排序。也就是说，如果想让结果集按照某种顺序排列，就必须使用 ORDER BY 子句。

SELECT ...... FROM ...... ORDER BY 列名 [ASC | DESC];

SELECT ename,sal FROM t_emp ORDER BY sal;

SELECT empno,ename,sal,deptno FROM t_emp ORDER BY sal DESC;

排序关键字

• ASC 代表升序（默认），DESC 代表降序
• 如果排序列是数字类型，数据库就按照数字大小排序，如果是日期类型就按日期大小排序，如果是字符串就按照字符集序号排序。

SELECT ename,sal FROM t_emp ORDER BY hiredate DESC;

SELECT empno,ename,hiredate,deptno FROM t_emp ORDER BY ename ASC;
SELECT empno,ename,hiredate,deptno FROM t_emp ORDER BY hiredate DESC;

排序字段内容相同的情况

• 默认情况下，如果两条数据排序字段内容相同，那么排序会是什么样子？

• 我们可以使用 ORDER BY 规定首要排序条件和次要排序条件。

  数据库会先按照首要排序条件排序，如果遇到首要排序内容相同的记录，那么就会启用次要排序条件接着排序。

SELECT empno,ename,sal,hiredate FROM t_emp ORDER BY sal DESC,hiredate ASC;

SELECT 
    empno,ename,deptno,sal
FROM t_emp
ORDER BY deptno,sal DESC;

SELECT 
    empno,ename,sal
FROM t_emp ORDER BY sal DESC LIMIT 0,5;

排序 + 分页

• ORDER BY 子句书写的时候放在 LIMIT 子句的前面

  FROM -> SELECT -> ORDER BY -> LIMIT

记录查询

• 最基本的查询语句是由 SELECT 和 FROM 关键字组成的

SELECT * FORM t_emp;
SELECT empnpo, ename, sal FROM t_emp;

• SELECT 语句屏蔽了物理层的操作。用户不必关心数据的真实存储，交由数据库高效的查找数据

USE demo;
SELECT * FROM t_emp;
SELECT empno,ename,sal FROM t_emp;

使用列命名

• 通常情况下，SELECT 子句中使用了表达式，那么这列的名字就默认为表达式，因此需要一种对列名重命名的机制。

SELECT
    empno,
    sal*12 AS "income"
FROM t_emp;

SELECT empno,sal*12 AS "icome" FROM t_emp;

查询语句的子句执行顺序

SELECT
    empno,
    sal*12 AS "income"
FROM t_emp;

1. 语法分析与优化
   • 读取 SQL 语句
2. FORM
   • 选择数据来源
3. SELECT
   • 选择输出内容

数据分页

• 比如我们查看朋友圈，只会加载少量部分信息，不用一次性加载全部朋友圈，那样只会浪费 CPU 时间、内存和网络带宽
• 如果结果集的记录很多，则可以使用 LIMIT 关键字限定结果集数量。

 SELECT ...... FROM ... LIMIT 起始位置, 偏移量;

SELECT empno, ename FROM t_emp LIMIT 10, 5;

数据分页的简写用法

• 如果 LIMIT 子句只有一个参数，它表示的是偏移量，起始值默认为 0

SELECT empno, ename FROM t_emp LIMIT 10;
SELECT empno, ename FROM t_emp LIMIT 0,10;

FROM -> SELECT -> LIMIT

提到监控，大家想到的大概是 UptimeRobot ，个人免费 50 个站点，而且监控页面也很炫酷

但是有个缺点就是似乎定制域名的功能要付费？

试过把站点扒下来，但是好像有 CORS 的跨域问题（（（（

最近几天，朋友那里发现了一款替代品，这页面感觉比 UptimeRobot 还炫酷 *

• https://github.com/louislam/uptime-kuma

成品：Zkeq の 监控云台 (icodeq.com)

见图 👀

后台也十分好看 ~

详情页面

并且还实现了微信推送的功能

实现步骤

搭建部分

项目地址

• https://github.com/louislam/uptime-kuma

>

Replit 推荐部署仓库：https://github.com/valetzx/uptimekumaonreplit

直接跟教程搭建即可，重点讲一下怎么把推送发到 【正常微信】。

内置一个企业微信通道，但是正常人谁用那玩意啊））））

这里用到的一个项目是方糖的开源版（因为我穷，学生嘛，理解一下））

• https://github.com/easychen/wecomchan

  easychen/wecomchan: 通过企业微信向微信推送消息的配置文档、直推函数和可自行搭建的在线服务代码。可以看成Server酱的开源替代方案之一。

其实这个项目里面的 README.md 写的已经很清楚了，甚至连用法都有......

PYTHON版:

def send_to_wecom(text,wecom_cid,wecom_aid,wecom_secret,wecom_touid='@all'):
        return response
    else:
        return False

def send_to_wecom_image(base64_content,wecom_cid,wecom_aid,wecom_secret,wecom_touid='@all'):
        return response
    else:
        return False

def send_to_wecom_markdown(text,wecom_cid,wecom_aid,wecom_secret,wecom_touid='@all'):
        return response
    else:
        return False

使用实例：

ret = send_to_wecom("推送测试\r\n测试换行", "企业ID③", "应用ID①", "应用secret②");
print(ret)
ret = send_to_wecom('<a href="https://www.github.com/">文本中支持超链接</a>', "企业ID③", "应用ID①", "应用secret②");
print(ret)
ret = send_to_wecom_image("此处填写图片Base64", "企业ID③", "应用ID①", "应用secret②");
print(ret)
ret = send_to_wecom_markdown("**Markdown 内容**", "企业ID③", "应用ID①", "应用secret②");
print(ret)

那么感觉也没啥讲的，直接讲怎么搭建实现吧。

首先去按教程

• https://github.com/easychen/wecomchan#企业微信应用消息配置说明

配置好自己的企业微信，那么我们可以拿到这么几个字段

wecom_cid = "wwXXXXXXXXXXXXXXX"
wecom_aid = "1000XXX"
wecom_secret = "XXXXXXXXXXXX-XXXXXXXXXXX-XXXXXXXXXXXXXXXX"

就这三个字段就够了

然后去写一下 FastAPI 的配置

• 这个经过我加工了一下....支持了 redis 缓存，需要 Redis 环境

• loguru 记录日志

• subprocess 用于启动 Redis

• FastAPI 主要框架

• uvicorn Fast API 启动器

• ）不过，我推荐使用 Replit 直接部署，把以下文件直接复制粘贴进去，点 RUN 就行了（）（不行的话来评论区

.\main.py

import base64
import json
import requests
import uvicorn
import redis
import logger as lg
from fastapi import FastAPI, Form
import subprocess
start_redis = "redis-server redis.conf"

r = redis.Redis(host='localhost', port=6379, db=0)


# 如果你用的个人版，请将以下填入环境变量中
# 并取消注释以下代码
# import os
# my_secret = os.environ['wecom_cid']
# wecom_aid = os.environ['wecom_aid']
# wecom_secret = os.environ['wecom_secret']

wecom_cid = "wwXXXXXXXXXXXXXXX"
wecom_aid = "1000XXX"
wecom_secret = "XXXXXXXXXXXX-XXXXXXXXXXX-XXXXXXXXXXXXXXXX"
app = FastAPI()


def get_token():
    global wecom_cid, wecom_aid, wecom_secret
    access_token = r.get('token')
    if not access_token:
        lg.logger_info('Redis access_token is empty, get from wecom')
        get_token_url = f"https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={wecom_cid}&corpsecret={wecom_secret}"
        lg.logger_info('get_token_url: ' + get_token_url)
        response = requests.get(get_token_url).content
        lg.logger_info('response: ' + str(response))
        access_token = json.loads(response).get('access_token')
        lg.logger_success('access_token: ' + str(access_token))
        r.set('token', access_token, ex=7000)
    else:
        access_token = access_token.decode('utf-8')
        lg.logger_success(f"从Redis 中拿到 access_token")
    return access_token


def send_to_wecom(text, wecom_touid='@all'):
    access_token = get_token()
    lg.logger_success("message: " + str(text))
    if access_token and len(access_token) > 0:
        send_msg_url = f'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={access_token}'
        data = {
            "touser": wecom_touid,
            "agentid": wecom_aid,
            "msgtype": "text",
            "text": {
                "content": text
            },
            "duplicate_check_interval": 600
        }
        response = requests.post(send_msg_url, data=json.dumps(data)).content
        lg.logger_info("response: " + str(response))
        return response
    else:
        return False


def send_to_wecom_image(base64_content, wecom_touid='@all'):
    access_token = get_token()
    lg.logger_info('access_token: ' + str(access_token))
    if access_token and len(access_token) > 0:
        upload_url = f'https://qyapi.weixin.qq.com/cgi-bin/media/upload?access_token={access_token}&type=image'
        upload_response = requests.post(upload_url, files={
            "picture": base64.b64decode(base64_content)
        }).json()
        if "media_id" in upload_response:
            media_id = upload_response['media_id']
        else:
            return False

        send_msg_url = f'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={access_token}'
        data = {
            "touser": wecom_touid,
            "agentid": wecom_aid,
            "msgtype": "image",
            "image": {
                "media_id": media_id
            },
            "duplicate_check_interval": 600
        }
        response = requests.post(send_msg_url, data=json.dumps(data)).content
        lg.logger_success("response: " + str(response))
        return response
    else:
        return False


def send_to_wecom_markdown(text, wecom_touid='@all'):
    access_token = get_token()
    if access_token and len(access_token) > 0:
        send_msg_url = f'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={access_token}'
        data = {
            "touser": wecom_touid,
            "agentid": wecom_aid,
            "msgtype": "markdown",
            "markdown": {
                "content": text
            },
            "duplicate_check_interval": 600
        }
        lg.logger_success("message: " + str(text))
        response = requests.post(send_msg_url, data=json.dumps(data)).content
        lg.logger_success("response: " + str(response))
        return response
    else:
        return False


@app.post("/")
def main(type: str = Form(...), title: str = Form(...), body: str = Form(...), wecom_touid: str = Form(...)):
    if type == 'note':
        lg.logger_info(f'收到笔记消息：{title}')
        data = send_to_wecom(title + '\n' + body, wecom_touid)
    elif type == 'image':
        lg.logger_info(f'收到图片消息：{title}')
        data = send_to_wecom_image(body, wecom_touid)
    elif type == 'markdown':
        lg.logger_info(f'收到markdown消息：{title}')
        data = send_to_wecom_markdown(title + '\n' + body, wecom_touid)
    else:
        data = send_to_wecom(title + '\n' + body, wecom_touid)
    return data

@app.get("/")
def get():
    return {"msg": "好耶，部署成功了！但是值得注意的是请不要将此地址告诉别人（（防止微信消息被刷爆"}

@app.head("/")
def head():
    return {"msg": "好耶，部署成功了！但是值得注意的是请不要将此地址告诉别人（（防止微信消息被刷爆"}


if __name__ == "__main__":
    print("start redis")
    subprocess.Popen(start_redis, shell=True)
    uvicorn.run("main:app", host="0.0.0.0", port=8080, log_level="info")

日志功能

.\logger.py

# coding:utf-8
from loguru import logger

logger.add("./log/file_{time}.log", rotation="20 MB")


def logger_error(msg):
    logger.error(msg)


def logger_warning(msg):
    logger.warning(msg)


def logger_debug(msg):
    logger.debug(msg)


def logger_exception(msg):
    logger.exception(msg)


def logger_critical(msg):
    logger.critical(msg)


def logger_success(msg):
    logger.success(msg)


def logger_info(msg):
    logger.info(msg)


def logger_trace(msg):
    logger.trace(msg)

.\redis.conf

bind 127.0.0.1 -::1
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 16
always-show-logo no
set-proc-title yes
proc-title-template "{title} {listen-addr} {server-mode}"
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
rdb-del-sync-files no
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-diskless-load disabled
repl-disable-tcp-nodelay no
replica-priority 100
acllog-max-len 128
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
lazyfree-lazy-user-del no
lazyfree-lazy-user-flush no
oom-score-adj no
oom-score-adj-values 0 200 800
disable-thp yes
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
jemalloc-bg-thread yes

.\replit.nix （若 使用的 Replit）

{ pkgs }: {
  deps = [
    pkgs.python38Full
    pkgs.redis
  ];
  env = {
    PYTHON_LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [
      # Neded for pandas / numpy
      pkgs.stdenv.cc.cc.lib
      pkgs.zlib
      # Needed for pygame
      pkgs.glib
      # Needed for matplotlib
      pkgs.xorg.libX11
    ];
    PYTHONBIN = "${pkgs.python38Full}/bin/python3.8";
    LANG = "en_US.UTF-8";
  };
}

.\.replit

# The command that runs the program.
run = ["python3", "main.py"]
# The primary language of the repl. There can be others, though!
language = "python3"
# The main file, which will be shown by default in the editor.
entrypoint = "main.py"
# A list of globs that specify which files and directories should
# be hidden in the workspace.
hidden = ["venv", ".config", "**/__pycache__", "**/.mypy_cache", "**/*.pyc"]

# Specifies which nix channel to use when building the environment.
[nix]
channel = "stable-21_11"

# Per-language configuration: python3
[languages.python3]
# Treats all files that end with `.py` as Python.
pattern = "**/*.py"
# Tells the workspace editor to syntax-highlight these files as
# Python.
syntax = "python"

  # The command needed to start the Language Server Protocol. For
  # linting and formatting.
  [languages.python3.languageServer]
  start = ["pyls"]

# The command to start the interpreter.
[interpreter]
  [interpreter.command]
  args = [
    "stderred",
    "--",
    "prybar-python3",
    "-q",
    "--ps1",
    "\u0001\u001b[33m\u0002\u0001\u001b[00m\u0002 ",
    "-i",
  ]
  env = { LD_LIBRARY_PATH = "$PYTHON_LD_LIBRARY_PATH" }

# The environment variables needed to correctly start Python and use the
# package proxy.
[env]
VIRTUAL_ENV = "/home/runner/${REPL_SLUG}/venv"
PATH = "${VIRTUAL_ENV}/bin"
PYTHONPATH="${VIRTUAL_ENV}/lib/python3.8/site-packages"
REPLIT_POETRY_PYPI_REPOSITORY="https://package-proxy.replit.com/pypi/"
MPLBACKEND="TkAgg"

# Enable unit tests. This is only supported for a few languages.
[unitTest]
language = "python3"

# Add a debugger!
[debugger]
support = true

  # How to start the debugger.
  [debugger.interactive]
  transport = "localhost:0"
  startCommand = ["dap-python", "main.py"]

    # How to communicate with the debugger.
    [debugger.interactive.integratedAdapter]
    dapTcpAddress = "localhost:0"

    # How to tell the debugger to start a debugging session.
    [debugger.interactive.initializeMessage]
    command = "initialize"
    type = "request"

      [debugger.interactive.initializeMessage.arguments]
      adapterID = "debugpy"
      clientID = "replit"
      clientName = "replit.com"
      columnsStartAt1 = true
      linesStartAt1 = true
      locale = "en-us"
      pathFormat = "path"
      supportsInvalidatedEvent = true
      supportsProgressReporting = true
      supportsRunInTerminalRequest = true
      supportsVariablePaging = true
      supportsVariableType = true

    # How to tell the debugger to start the debuggee application.
    [debugger.interactive.launchMessage]
    command = "attach"
    type = "request"

      [debugger.interactive.launchMessage.arguments]
      logging = {}

# Configures the packager.
[packager]
# Search packages in PyPI.
language = "python3"
# Never attempt to install `unit_tests`. If there are packages that are being
# guessed wrongly, add them here.
ignoredPackages = ["unit_tests"]

  [packager.features]
  enabledForHosting = false
  # Enable searching packages from the sidebar.
  packageSearch = true
  # Enable guessing what packages are needed from the code.
  guessImports = true

OK，跑起来之后，就实现了自动刷新缓存 token 推送微信的功能

Try Post 发送请求至部署的地址

POST Method
Body X-WWW-form-urlencoded 表单
"type": "Note",
"title": "Test title",
"body": "Test body",
"wecom_touid": "@all"

应该可以收到消息了，那么这么一个推送端我们就搭好了

只需要对接 Uptime 就 OK 了，我选择的是改造 pushbullet.js 这个推送源（里面的推送网址改成你的）

.\server\notification-providers\pushbullet.js

const NotificationProvider = require("./notification-provider");
const axios = require("axios");
var qs = require('qs');

const { DOWN, UP } = require("../../src/util");

class Pushbullet extends NotificationProvider {

    name = "pushbullet";

    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
        let okMsg = "Sent Successfully.";
        try {
            let pushbulletUrl = "https://xxxxx.xxxxxxxxxxxxxx.xxxx.xx";
            let config = {
                headers: {
                    "Content-Type": "application/json"
                }
            };
            if (heartbeatJSON == null) {
                let testdata = {
                    "type": "note",
                    "title": "Uptime Kuma Alert",
                    "body": "Testing Successful.",
                    "wecom_touid": notification.pushbulletAccessToken
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(testdata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            } else if (heartbeatJSON["status"] == DOWN) {
                let downdata = {
                    "type": "note",
                    "title": "UptimeKuma Alert: " + monitorJSON["name"],
                    "body": "[🔴 Down] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
                    "wecom_touid": notification.pushbulletAccessToken
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(downdata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            } else if (heartbeatJSON["status"] == UP) {
                let updata = {
                    "type": "note",
                    "title": "UptimeKuma Alert: " + monitorJSON["name"],
                    "body": "[✅ Up] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
                    "wecom_touid": notification.pushbulletAccessToken
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(updata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            }
            return okMsg;
        } catch (error) {
            this.throwGeneralAxiosError(error)
        }
    }
}

module.exports = Pushbullet;

因为我技术菜，所以这里多引入了一个库 qs ，需要引入一下

package.json

"dependencies": {
+        "qs": "6.10.3",
},

ok，这样部署好了，但是我们还缺少一个参数

• wecom_touid ：到底要发给谁呢？
• 你可以选这两种方式 ： @all 推送给所有关注服务的人，也可以填用户 ID

用户ID在这里看

• Server酱·Turbo版 (ftqq.com)

里面的

这个就是 用户 ID ，成功将监控项目跑起来之后

添加通知项，选择 pushbullet 里面的 Access Token 填

• 要通知的 用户 ID

• 或 @all

点击测试，能收到消息即搭建成功

顺便提一嘴

方糖的 PushDeer 也对接成功了

还是那个文件

.\server\notification-providers\pushbullet.js

const NotificationProvider = require("./notification-provider");
const axios = require("axios");
var qs = require('qs');

const { DOWN, UP } = require("../../src/util");

class Pushbullet extends NotificationProvider {

    name = "pushbullet";

    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
        let okMsg = "Sent Successfully.";

        try {
            let pushbulletUrl = "https://sc.ftqq.com/" + notification.pushbulletAccessToken + ".send";
            let config = {
                headers: {
                    "Content-Type": "application/json"
                }
            };
            if (heartbeatJSON == null) {
                let testdata = {
                    "title": "Uptime Kuma Alert",
                    "desp": "Testing Successful."
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(testdata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            } else if (heartbeatJSON["status"] == DOWN) {
                let downdata = {
                    "title": "UptimeKuma Alert: " + monitorJSON["name"],
                    "desp": "[🔴 Down] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(downdata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            } else if (heartbeatJSON["status"] == UP) {
                let updata = {
                    "title": "UptimeKuma Alert: " + monitorJSON["name"],
                    "desp": "[✅ Up] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
                }
                // 提交 构造from表单
                var access_token_data = qs.stringify(updata);
                var _config = {
                  method: 'post',
                  url: pushbulletUrl,
                  headers: { 
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  data : access_token_data
                };
                await axios(_config)
            }
            return okMsg;
        } catch (error) {
            this.throwGeneralAxiosError(error)
        }
    }
}

module.exports = Pushbullet;

这个针对方糖的订阅用户（（

还是那个 pushbullet 通道，Access Token 填成你的就行

类似于

• SCT888888XXXXXXXXXXXXXXXXXXXXXXX

这种的，填上测试一下，如果收到消息即对接成功（老规矩要先加上那个 qs 的库）

有问题评论区联系（

The Python Runtime is used by Vercel to compile Python Serverless Functions, that defines a singular HTTP handler variable, inheritting from the BaseHTTPRequestHandler class, from a .py file within an /api directory at your project's root.

Python 平台被用作 vercel 的 Python 云函数编译器，它定义了一个单一的 HTTP handler 变量，继承自 BaseHTTPRequestHandler 类，并且来自于 /api 目录下以 .py 结尾的文件

For example, define an index.py file inside a /api directory as follows:

示例：这是一个 /api 目录下以 .py 结尾的文件

from http.server import BaseHTTPRequestHandler
from cowpy import cow

class handler(BaseHTTPRequestHandler):

    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/plain')
        self.end_headers()
        message = cow.Cowacter().milk('Hello from Python from a Serverless Function!')
        self.wfile.write(message.encode())
        return

An example index.py file inside an /api directory.

Inside requirements.txt define:

在 requirements.txt 中这样定义

cowpy==1.0.3

An example requirements.txt file that defines cowpy as a dependency.

requirements.txt 定义了需要 cowpy 这个依赖项

For advanced usage, such as using WSGI or ASGI for your Python projects, see the Advanced Python Usage section.

有关高级用法，例如在 Python 项目中使用 WSGI 或 ASGI，请参阅 高级 Python 用法部分。（本文的后半部分）

Python Version

Python projects deployed with Vercel use Python version 3.9.

使用 Vercel 部署的 Python 项目使用 Python 3.9 版。

You can specify the version of Python by defining python_version in Pipfile, like so:

您可以通过在 Pipfile 中定义 python_version 来指定 Python 的版本，如下所示：

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
flask = "*"

[requires]
python_version = "3.9"

An example Pipfile generated withpipenv install flask.

Currently, the following Python versions are available:

目前，有如下版本可用

• 3.9 (default since November 23rd 2021)
• 3.6 (being deprecated)

Note: The python_version must exactly match one of the options above or it will be ignored.

注意：python_version 必须与上述选项之一 完全匹配 ，否则将被忽略。

Python Dependencies

Python 的依赖项

You can install dependencies for your Python projects by defining them in requirements.txt or a Pipfile with corresponding Pipfile.lock.

您可以通过在 requirements.txt 或具有相应 Pipfile.lock 的 Pipfile 中定义 Python 项目的依赖项来安装依赖项。

Advanced Python Usage

高级 Python 用法

In order to use this Runtime, no configuration is needed. You only need to create a file inside the api directory.

要使用这个云函数，您不需要过多配置。只需要创建在 api 目录下创建一个文件。

The entry point of this Runtime is a glob matching .py source files with one of the following variables defined:

这个运行的入口函数要以 .py 结尾，并且具备以下两种特征中的一种。

• handler that inherits from the BaseHTTPRequestHandler class.

  有 handler class 属性并且继承于 BaseHTTPRequestHandler

• app that exposes a WSGI or ASGI Application.

  WSGI 或者 ASGI 应用并且有 app 的入口。

Reading Relative Files in Python

在 Python 中读取相关文件

Python uses the current working directory when a relative file is passed to open().

当一个文件被由 open() 打开时。

The current working directory is the base of your project, not the api/ directory.

工作目录是以根目录为基础的，而不是 api/

For example, the following directory structure:

例如，若有如下目录结构

├── README.md
├── api
|  ├── user.py
├── data
|  └── file.txt
└── requirements.txt

With the above directory structure, your function in api/user.py can read the contents of data/file.txt in a couple different ways.

有了上面的结构， api/user.py 中的函数可以通过几种不同的方式读取 data/file.txt 的内容。

You can use the path relative to the project's base directory.

您可以使用 绝对路径

# api/user.py
from http.server import BaseHTTPRequestHandler
from os.path import join

class handler(BaseHTTPRequestHandler):

    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/plain')
        self.end_headers()
        with open(join('data', 'file.txt'), 'r') as file:
          for line in file:
            self.wfile.write(line.encode())
        return

Or you can use the path relative to the current file's directory.

或者使用相对路径

# api/user.py
from http.server import BaseHTTPRequestHandler
from os.path import dirname, abspath, join
dir = dirname(abspath(__file__))

class handler(BaseHTTPRequestHandler):

    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/plain')
        self.end_headers()
        with open(join(dir, '..', 'data', 'file.txt'), 'r') as file:
          for line in file:
            self.wfile.write(line.encode())
        return

Web Server Gateway Interface

Web服务器网关接口

The Web Server Gateway Interface (WSGI) is a calling convention for web servers to forward requests to web applications written in Python. You can use WSGI with frameworks such as Flask or Django.

Web 服务器网关接口 (WSGI) 是 Web 服务器将请求转发到用 Python 编写的 Web 应用程序的调用约定。 您可以将 WSGI 与 Flask 或 Django 等框架一起使用。

Instead of defining a handler, define an app variable in your Python file, when using vercel.json config. For example, define a index.py file inside your project as follows:

使用 vercel.json 配置时，不要定义 handler，而是在 Python 文件中定义 app 变量。 例如，在您的项目中定义一个 index.py 文件，如下所示：

from flask import Flask, Response
app = Flask(__name__)

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def catch_all(path):
    return Response("<h1>Flask</h1><p>You visited: /%s</p>" % (path), mimetype="text/html")

An example index.py file, using Flask for a WSGI application.

一个示例 index.py 文件，将 Flask 用于 WSGI 应用程序。

Inside requirements.txt define:

在 requirements.txt 中定义：

flask==1.0.2

An example requirements.txt file, listing flask as a dependency.

一个示例 requirements.txt 文件，将 flask 列为依赖项。

Asynchronous Server Gateway Interface

异步服务器网关接口

The Asynchronous Server Gateway Interface (ASGI) is a calling convention for web servers to forward requests to asynchronous web applications written in Python. You can use ASGI with frameworks such as Sanic.

异步服务器网关接口 (ASGI) 是 Web 服务器将请求转发到用 Python 编写的异步 Web 应用程序的调用约定。 您可以将 ASGI 与 Sanic 等框架一起使用。

Instead of defining a handler, define an app variable in your Python file.

不要定义一个 handler，而是在你的 Python 文件中定义一个 app 变量。

For example, define a index.py file inside a folder as follows:

例如，在文件夹中定义一个 index.py 文件，如下所示：

from sanic import Sanic
from sanic.response import json
app = Sanic()


@app.route('/')
@app.route('/<path:path>')
async def index(request, path=""):
    return json({'hello': path})

An example index.py file, using Sanic for a ASGI application.

一个示例 index.py 文件，将 Sanic 用于 ASGI 应用程序。

Inside requirements.txt define:

在 requirements.txt 中定义：

sanic==19.6.0

An example requirements.txt file, listing sanic as a dependency.

一个示例 requirements.txt 文件，将 sanic 列为依赖项。

• 一旦数据排序之后，查找的速度就会翻倍，现实世界跟程序世界都是如此

如何创建索引

CREATE TABLE t_message(
    id INT UNSIGNED PRIMARY KEY,
    content VARCHAR(200) NOT NULL,
    type ENUM("公告", "通报", "个人通知") NOT NULL,
    create_time TIMESTAMP NOT NULL,
    INDEX idx_type (type)
)

如何添加与删除索引

DROP INDEX idx_type ON t_message;
CREATE INDEX idx_type ON t_message(type);
SHOW INDEX FROM t_message;
ALTER TABLE t_message ADD INDEX idx_type(type);

索引的使用原则

• 数据库很大，而且经常被查询的数据表可以设置索引
• 索引只添加在经常被用作索引条件的字段上面
• 不要在大字段上创建索引

CREATE TABLE t_message(
    id INT UNSIGNED PRIMARY KEY,
    content VARCHAR(200) NOT NULL,
    type ENUM("公告", "通报", "个人通知") NOT NULL,
    create_time TIMESTAMP NOT NULL,
    INDEX idx_type (type)
);

DROP INDEX idx_type ON t_message;
CREATE INDEX idx_type ON t_message(type);
SHOW INDEX FROM t_message;
ALTER TABLE t_message ADD INDEX idx_type(type);

数据库的范式

• 构造数据库必须遵循一定的规则，这种规则就是范式
• 目前关系数据库有 6 种范式，一般情况下，只满足第三范式即可

第一范式：原子性

• 第一范式是数据库的基本要求，不满足这一点就不是关系数据库
• 数据表的每一列都是不可分割的基本数据项，同一列中不能有多个值，也不能存在重复的属性。

第二范式：唯一性

• 数据表中的每条记录必须是唯一的。为了实现区分，通常要为表上加一个列用来存储唯一标识，这个唯一属性列被称作主键列

第三范式：关联性

• 每列都与主键有直接关系，不存在传递依赖

• 依照第三范式，数据可以拆分保存到不同的数据表，依次保持关联

字段约束

• MySQL 中的字段约束共有四种：

• 外键约束是唯一不推荐使用的约束

主键约束

• 主键约束要求字段的值在全表必须唯一，而且不能为 NULL 值
• 建议主键一定要使用数据类型，因为数字的检索速度会非常快
• 如果主键是数字类型，还可以设置自动增长

CREATE TABLE t_teacher(
    id INT PRIMARY KEY AUTO_INCREMENT,
    ... ...
);

非空约束

• 非空约束要求字段的值不能为 NULL 值
• NULL 值为没有值，而不是 "" 空字符串

CREATE TABLE t_teacher(
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(200) NOT NULL,
    married BOOLEAN NOT NULL DEFAULT FALSE
);

• BOOLEAN 实际为TINYINT 数据类型

唯一约束

• 唯一约束要求字段值如果不为 NULL，那么在全表必须唯一

CREATE TABLE t_teacher(
    ......
    tel CHAR(11) NOT NULL UNIQUE
);

以上三种的练习

CREATE TABLE t_teacher(
    id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20) NOT NULL,
    tel CHAR(11) NOT NULL UNIQUE,
    married BOOLEAN NOT NULL DEFAULT FALSE
);

外键约束（放弃）

• 外键约束用来保证关联数据的逻辑关系

• 外键约束的定义是写在字表上的

创建父表

CREATE TABLE t_dept(
    deptno INT UNSIGNED PRIMARY KEY,
    dname VARCHAR(20) NOT NULL UNIQUE,
    tel CHAR(4) UNIQUE
);

创建子表

CREATE TABLE t_emp(
    empno INT UNSIGNED PRIMARY KEY,
    ename VARCHAR(20) NOT NULL,
    sex ENUM("男", "女") NOT NULL, # 枚举的数据类型，挑选一个
    deptno INT UNSIGNED,
    biredate DATA NOT NULL,
    FOREIGN KEY (deptno) REFERENCES t_dept(deptno)
);

可执行代码

CREATE TABLE t_dept(
    deptno INT UNSIGNED PRIMARY KEY,
    dname VARCHAR(20) NOT NULL UNIQUE,
    tel CHAR(4) UNIQUE
);

CREATE TABLE t_emp(
    empno INT UNSIGNED PRIMARY KEY,
    ename VARCHAR(20) NOT NULL,
    sex ENUM("男", "女") NOT NULL,
    deptno INT UNSIGNED NOT NULL,
    hiredate DATE NOT NULL,
    FOREIGN KEY (deptno) REFERENCES t_dept(deptno)
)

外键约束的闭环问题

• 如果形成外键闭环，我们将无法删除任何一张表的记录

添加字段

ALTER TABLE student
ADD address VARCHAR(200) NOT NULL,
ADD home_tel char(11) NOT NULL;

修改字段类型和约束

ALTER TABLE student
MODIFY home_tel VARCHAR(20) NOT NULL;

DESC student;

修改字段名称

DESC student;

ALTER TABLE student
CHANGE address home_address VARCHAR(200) NOT NULL;

删除字段

DESC student;

ALTER TABLE student
DROP home_address,
DROP home_tel;

总结语句

ALTER TABLE student # DDL 语句 没有操作数据类型
ADD address VARCHAR(200) NOT NULL,
ADD home_tel char(11) NOT NULL;

ALTER TABLE student # DDL 语句 没有操作数据类型
MODIFY home_tel VARCHAR(20) NOT NULL;

DESC student;

ALTER TABLE student # DDL 语句 没有操作数据类型
CHANGE address home_address VARCHAR(200) NOT NULL;

ALTER TABLE student # DDL 语句 没有操作数据类型
DROP home_address,
DROP home_tel;

数据类型：数字

1^ : (-2^7 --- +2^7-1)

不精确的浮点数

• 十进制的浮点数无法在计算机中用二进制精确表达

CREATE TABLE temp(
    id INT UNSIGNED PRIMARY KEY,
    num FLOAT(20,10)
)
0.2 ----> 0.2000000030

DROP TABLE temp
CREATE TABLE temp(
    id INT UNSIGNED PRIMARY KEY,
    num DECIMAL(20,10)
)
0.2 ----> 0.2000000000

数据类型：字符串

数据类型：日期类型

• SQL 是用于访问和处理数据的标准的计算机语言
  • 不能通用的叫 方言

SQL 语句注意事项

• SQL 语句不区分大小写，但是 字符串 区分大小写。
  • SELECT "HelloWorld" ;
  • 关键字 非关键词
  • 推荐 关键字大写，这样写出来的才错落有致
• SQL 语句必须以分号结尾。
• SQL 语句中的空白和换行没有限制，但是不能破坏语法。

SQL 语句的注释

• SQL 语句的注释有两种，分别如下：
  1. # 这是一段注释 （适合单行）
  2. /* 这是另一端注释 */ （适合多行）

创建逻辑库

创建数据表

USE test;
CREATE TABLE student(
    id INT UNSIGNED PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    sex CHAR(1) NOT NULL,
    brithday DATE NOT NULL,
    tel CHAR(11) NOT NULL,
    remark VARCHAR(200)
) ;

INSERT INTO student VALUES(1, "李强", "男", "1995-05-15", "13312345678", NULL);

数据库的其他操作

SHOW TABLES;
DESC student;
SHOW CREATE TABLE student;
DROP TABLE student;

代码

import pymysql.cursors

# Connect to the database
connection = pymysql.connect(host='localhost',
                             user='py',
                             password='MsXMAFiaaSKRei6j',
                             database='py',
                             cursorclass=pymysql.cursors.DictCursor)

with connection:
    # Create a new cursor
    # 这个游标的意思，应该是跟鼠标差不多？
    with connection.cursor() as cursor:
        sql_create = """
                    CREATE TABLE `users` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `email` varchar(255) COLLATE utf8_bin NOT NULL,
                    `password` varchar(255) COLLATE utf8_bin NOT NULL,
                    PRIMARY KEY (`id`)
                    ) 
                    ENGINE=InnoDB 
                    DEFAULT 
                    CHARSET=utf8mb4 
                    COLLATE=utf8mb4_bin
                    AUTO_INCREMENT=1 ;
                    """
        # 首先建表
        cursor.execute(sql_create)
        # 只需要建表一次哦
        # Create a new record
        # 再执行语句
        sql = "INSERT INTO `users` (`email`, `password`) VALUES (%s, %s)"
        cursor.execute(sql, ('webmaster@python.org', 'very-secret'))
        # 执行完毕之后就关闭这个连接
    # connection is not autocommit by default. So you must commit to save
    # your changes.
    # 想要保存数据，就要提交？
    connection.commit()

    with connection.cursor() as cursor:
        # Read a single record
        sql = "SELECT `id`, `password` FROM `users` WHERE `email`=%s"
        cursor.execute(sql, ('webmaster@python.org',))
        result = cursor.fetchone()
        print(result)

自建 不蒜子 API

• https://busuanzi.icodeq.com

前言：

1. 不蒜子是一款很好用的前端计数工具，但是因为流量日渐变多，经常会出现 502 的情况
2. 故尝试对其后端进行了仿造，达到了相同的效果，并且在首次添加域名时，会自动从 busuanzi 官网同步数据
3. 本项目使用 Redis 做数据库，若您的网站一个月内没有访问量，数据会自动清除。
4. 即下一次再使用本工具时将再次从 Busuanzi 官网 同步数据
5. 本项目托管于 replit.com ，开源地址： zkeq/Busuanzi_backend_self [ MIT License ]

使用：

1. 将官网的 //busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js 文件改为
2. https://busuanzi.icodeq.com/busuanzi.pure.mini.js （本项目暂不支持 http 协议的网站）
3. 即可使用，首次加载网站会较慢（后台同步不蒜子的 Site_uv 和 Site_pv ）
4. 之后会保持在 360ms 左右加载出数据 (服务器处理数据仅用时 5ms)

用法：

<script async src="https://busuanzi.icodeq.com/busuanzi.pure.mini.js"></script>

本文总阅读量 <span id="busuanzi_value_page_pv"></span> 次

本站总访问量 <span id="busuanzi_value_site_pv"></span> 次

本站总访客数 <span id="busuanzi_value_site_uv"></span> 人

不蒜子自建后端 API 🗺️

• https://github.com/zkeq/Busuanzi_backend_self

安装

个人版

• 点击一键部署：

  本项目使用 Redis 做数据库， 空转占用内存大概 200M，请按需规划。

• 成功导入后点击 🏃 RUN 按钮，即可完成安装！

教育版 or 专业版

【资源额度更高，但好像无法一键导入】

1. 创建新项目

2. 复制本项目的文件到上一步创建的项目中

3. 点击 🏃 RUN 按钮，即可完成安装！

出现下图表示安装成功！~（首次会同步 busuanzi 的数据，多次尝试属于正常状态）~ :

使用

1. 在 white_list.json 中添加你的域名白名单

2. 将 不蒜子 官网提供的 js 代码里面的网址，改成你的 即可

//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js

var bszCaller,bszTag;!function(){var c,d,e,a=!1,b=[];ready=function(c){return a||"interactive"===document.readyState||"complete"===document.readyState?c.call(document):b.push(function(){return c.call(this)}),this},d=function(){for(var a=0,c=b.length;c>a;a++)b[a].apply(document);b=[]},e=function(){a||(a=!0,d.call(window),document.removeEventListener?document.removeEventListener("DOMContentLoaded",e,!1):document.attachEvent&&(document.detachEvent("onreadystatechange",e),window==window.top&&(clearInterval(c),c=null)))},document.addEventListener?document.addEventListener("DOMContentLoaded",e,!1):document.attachEvent&&(document.attachEvent("onreadystatechange",function(){/loaded|complete/.test(document.readyState)&&e()}),window==window.top&&(c=setInterval(function(){try{a||document.documentElement.doScroll("left")}catch(b){return}e()},5)))}(),bszCaller={fetch:function(a,b){var c="BusuanziCallback_"+Math.floor(1099511627776*Math.random());window[c]=this.evalCall(b),a=a.replace("=BusuanziCallback","="+c),scriptTag=document.createElement("SCRIPT"),scriptTag.type="text/javascript",scriptTag.defer=!0,scriptTag.src=a,scriptTag.referrerPolicy="no-referrer-when-downgrade",document.getElementsByTagName("HEAD")[0].appendChild(scriptTag)},evalCall:function(a){return function(b){ready(function(){try{a(b),scriptTag.parentElement.removeChild(scriptTag)}catch(c){bszTag.hides()}})}}},bszCaller.fetch("//busuanzi.ibruce.info/busuanzi?jsonpCallback=BusuanziCallback",function(a){bszTag.texts(a),bszTag.shows()}),bszTag={bszs:["site_pv","page_pv","site_uv"],texts:function(a){this.bszs.map(function(b){var c=document.getElementById("busuanzi_value_"+b);c&&(c.innerHTML=a[b])})},hides:function(){this.bszs.map(function(a){var b=document.getElementById("busuanzi_container_"+a);b&&(b.style.display="none")})},shows:function(){this.bszs.map(function(a){var b=document.getElementById("busuanzi_container_"+a);b&&(b.style.display="inline")})}};

把里面的这个链接
//busuanzi.ibruce.info/busuanzi?jsonpCallback=BusuanziCallback
改成
你的域名，例如：
https://counter.busuanzi.icodeq.com/?jsonpCallback=BusuanziCallback

1. 把你网站引入的 busuanzi.pure.mini.js 地址替换为上一步改好的即可 ✨

首先看效果（新人练手项目，代码很烂，重在思路）

视频仅提供示例，随便下的一个视频

本文不提供相关接口，仅做技术复现！

前期准备

需要首先安装 ffmpeg 并配置到环境变量（使用命令行输入 ffmpeg 可以正常打开的那种） https://www.gyan.dev/ffmpeg/builds/ 或 https://github.com/BtbN/FFmpeg-Builds/releases

目录结构

项目分为以下几部分

1. 对 mp4 文件进行格式转换，转成单个 ts 文件
2. 对 单个 ts 文件进行转换，转成 m3u8 文件和 ts 切片文件
3. 对 ts 切片文件进行重构，使其具有 PNG 文件格式的文件头
4. 上传图床并根据返回的结果重写之前 m3u8 文件。

一、文件转换部分

mp4 转 单个 ts

def video_to_ts(video_path):
    ts_all = ".//ts_single//ts_single.ts"
    cmd_str = f'ffmpeg -y -i {video_path} -vcodec copy -acodec copy -vbsf h264_mp4toannexb {ts_all}'
    subprocess.run(cmd_str, encoding="utf-8", shell=True)
    print(f'从 {video_path} 转换到 {cmd_str} 成功！')

二、生成 m3u8 文件

单个 ts 转 m3u8

def ts_to_m3u8(ts_single, singlg_time):
    cmd_str = f'ffmpeg -i {ts_single} -c copy -map 0 -f segment -segment_list temp_playlist.m3u8 -segment_time {singlg_time} ./ts_all/%03d.ts'
    subprocess.run(cmd_str, encoding="utf-8", shell=True)
    print(f'从 {ts_single} 转换到 temp_playlist.m3u8 成功！')

三、ts 文件格式处理部分

首先重命名为 PNG 后缀

def rename_ts_to_png():
    file_list = os.listdir("./ts_all")
    for i in file_list:
        if i.endswith(".ts"):
            new_name = i.replace(".ts", ".png")
            os.rename("./ts_all/" + i, "./ts_all/" + new_name)
    print("rename_ts_to_png")

重写覆写 ts文件头，使其拥有 PNG 文件头

def rewrite_ts_to_png():
    file_list = os.listdir("./ts_all")
    for i in file_list:
        copyfile("PNG", "./ts_rewrite/" + i)
    print("rewrite_ts_to_png")
    file_list = os.listdir("./ts_rewrite")
    for i in file_list:
        if i.endswith(".png"):
            bin_file = open("./ts_all/" + i, 'rb')  # 打开二进制文件
            # 合并文件
            with open("./ts_rewrite/" + i, 'ab') as f:
                f.write(bin_file.read())
            bin_file.close()
    return None

PNG 文件头 16 进制数据如下（放在项目目录命名为 PNG ）

89504E470D0A1A0A0000000D4948445200000320000003200803000000ECAEF65A0000001974455874536F6674776172650041646F626520496D616765526561647971C9653C00000006504C5445000000000000A567B9CF0000000174524E530040E6D866000002864944415478DAECC1010D000000C2A0F74F6D0E37A0

四、文件上传以及重写 M3U8 文件

文件上传

# 上传图片
def updateImage(filepath):
    _upload_url = "******************************/api/content/file/upload"
    files = {'media': open(filepath, 'rb')}
    upload_res = requests.post(_upload_url, files=files)
    print('正在上传：', filepath)
    return upload_res.json()

提取返回的 url

def upload_list(_upload_url):
    _file_dict = {}
    file_list = os.listdir(_upload_url)
    for i in file_list:
        data_json = updateImage(_upload_url + i)
        _file_dict[i] = data_json["***"]["*pic*"] + "\n"
    return _file_dict

重写 m3u8 文件

def rewrite_m3u8(m3u8_file, file_dict):
    print(file_dict)
    with open(m3u8_file, 'r') as f:
        lines = f.readlines()
        for i in lines:
            rename = i.replace("ts", "png").replace("\n", "")
            if rename in file_dict.keys():
                lines[lines.index(i)] = file_dict[rename]
                print("正在替换：", i)
    with open(m3u8_file, 'w') as f:
        f.writelines(lines)
    print("rewrite_m3u8")

五、串联以上代码的入口函数

if __name__ == '__main__':
    video_to_ts("video.mp4")
    ts_to_m3u8("./ts_single/ts_single.ts", "5")
    rename_ts_to_png()
    rewrite_ts_to_png()
    upload_url = "./ts_rewrite/"
    file_dict = upload_list(upload_url)
    rewrite_m3u8("./temp_playlist.m3u8", file_dict)
    print("main")

需要自行创建文件夹及准备文件

• ./ts_single/
• ./ts_all/
• ./ts_rewrite/
• ./video.mp4
• ./PNG

完整代码 (无上传接口版本)

# coding:utf-8

import subprocess
import requests
from shutil import copyfile
import os


def video_to_ts(video_path):
    ts_all = ".//ts_single//ts_single.ts"
    cmd_str = f'ffmpeg -y -i {video_path} -vcodec copy -acodec copy -vbsf h264_mp4toannexb {ts_all}'
    subprocess.run(cmd_str, encoding="utf-8", shell=True)
    print(f'从 {video_path} 转换到 {cmd_str} 成功！')


def ts_to_m3u8(ts_single, singlg_time):
    cmd_str = f'ffmpeg -i {ts_single} -c copy -map 0 -f segment -segment_list temp_playlist.m3u8 -segment_time {singlg_time} ./ts_all/%03d.ts'
    subprocess.run(cmd_str, encoding="utf-8", shell=True)
    print(f'从 {ts_single} 转换到 temp_playlist.m3u8 成功！')


def rename_ts_to_png():
    file_list = os.listdir("./ts_all")
    for i in file_list:
        if i.endswith(".ts"):
            new_name = i.replace(".ts", ".png")
            os.rename("./ts_all/" + i, "./ts_all/" + new_name)
    print("rename_ts_to_png")


def rewrite_ts_to_png():
    file_list = os.listdir("./ts_all")
    for i in file_list:
        copyfile("PNG", "./ts_rewrite/" + i)
    print("rewrite_ts_to_png")
    file_list = os.listdir("./ts_rewrite")
    for i in file_list:
        if i.endswith(".png"):
            bin_file = open("./ts_all/" + i, 'rb')  # 打开二进制文件
            # 合并文件
            with open("./ts_rewrite/" + i, 'ab') as f:
                f.write(bin_file.read())
            bin_file.close()
    return None


# 上传图片
def updateImage(filepath):
    _upload_url = "*************************************************"
    files = {'media': open(filepath, 'rb')}
    upload_res = requests.post(_upload_url, files=files)
    print('正在上传：', filepath)
    return upload_res.json()


def upload_list(_upload_url):
    _file_dict = {}
    file_list = os.listdir(_upload_url)
    for i in file_list:
        data_json = updateImage(_upload_url + i)
        _file_dict[i] = data_json["****"]["******"] + "\n"
    return _file_dict


def rewrite_m3u8(m3u8_file, file_dict):
    print(file_dict)
    with open(m3u8_file, 'r') as f:
        lines = f.readlines()
        for i in lines:
            rename = i.replace("ts", "png").replace("\n", "")
            if rename in file_dict.keys():
                lines[lines.index(i)] = file_dict[rename]
                print("正在替换：", i)
    with open(m3u8_file, 'w') as f:
        f.writelines(lines)
    print("rewrite_m3u8")


if __name__ == '__main__':
    video_to_ts("video.mp4")
    ts_to_m3u8("./ts_single/ts_single.ts", "5")
    rename_ts_to_png()
    rewrite_ts_to_png()
    upload_url = "./ts_rewrite/"
    file_dict = upload_list(upload_url)
    rewrite_m3u8("./temp_playlist.m3u8", file_dict)
    print("main")