从 Spring Boot 2.4 开始，spring.config.import 方式是官方推荐的配置加载方式，它比 bootstrap.yaml 更加灵活，也更容易理解。在不同的应用场景下，我们可以选择合适的方式来管理 Spring Boot 配置。
]]><p>在 Spring Boot 应用开发中，合理管理和加载配置是非常重要的。以往，我们通常使用 <code>bootstrap.yaml/properties</code> 方式来提前导入外部配置。但在 Spring Boot 2.4 及以上版本中，引入了基于Redis分布式锁实现分布式定时任务调度https://www.wotemo.com/posts/42850.html2025-03-03T13:21:21.000Z2025-03-03T13:21:21.000Z前情提要
]]><blockquote>
<p>搞了老长时间，MongoDB真的我哭死🥹</p>
</blockquote>
<h3 id="前言"><a href="#前言" class="headerlink"音乐专赏 - Let Her Gohttps://www.wotemo.com/posts/17449.html2024-06-11T14:15:55.000Z2024-06-11T15:45:45.000Z
Let Her Go - Passenger
单曲「Let Her Go」
MV | Youtube
Well you only need the light when it's burning low 只有在朦胧黯淡时才念及灯火光亮
Only miss the sun when it starts to snow 只有在冰天雪地时才怀念阳光温暖
Only know you love her when you let her go 只有在已然放手后才始知那是真爱
Only know you've been high when you're feeling low 只有在身处低谷时才遥想过去峥嵘
Only hate the road when you're missing home 只有在乡愁涌动时才痛恨旅途遥远
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
And you let her go 你却让她走了
Staring at the bottom of your glass 酒杯已空，醉然凝视。
Hoping one day you'll make a dream last 希望有一天，你能让梦持续。
But dreams come slow and they go so fast 但是梦想来的太慢，走得太快。
You see her when you close your eyes 闭上双眼，整个脑海都是她。
Maybe one day you'll understand why 也许有一天，你会明白，
Everything you touch surely dies 自己是如何亲手毁掉了一段爱情
But you only need the light when it's burning low 但是你只需要朦胧暗淡时的光亮。
Only miss the sun when it starts to snow 只有在冰天雪地时才怀念阳光温暖
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
Only know you've been high when you're feeling low 只有在身处低谷时才遥想过去峥嵘
Only hate the road when you're missing home 只有在乡愁涌动时才痛恨旅途遥远
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
Staring at the ceiling in the dark 黑夜中你痴痴地望着天花板
Same old empty feeling in your heart 又是熟悉的空虚寂寞侵袭着你的心
Cause love comes slow and it goes so fast 爱情来的太慢，走得太快
Well you see her when you fall asleep 如今你只得在梦里与她相见
But never to touch and never to keep 可这梦脆弱的经不起触碰 经不起长久'
Cause you loved her too much and you dive too deep 你爱她越深 你亦而陷的越深
Well you only need the light when it's burning low 只有在朦胧黯淡时才念及灯火光亮
Only miss the sun when it starts to snow 只有在冰天雪地时才怀念阳光温暖
Only know you love her when you let her go 只有在已然放手后才始知那是真爱
Only know you've been high when you're feeling low 只有在身处低谷时才遥想过去峥嵘
Only hate the road when you're missing home 只有在乡愁涌动时才痛恨旅途遥远
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
And you let her go 你却让她走了
And you let her go 你却让她走了
Well you let her go 你却让她走了
Cause you only need the light when it's burning low 因为你只需要在燃烧时的光
Only miss the sun when it starts to snow 只有在冰天雪地时才怀念阳光温暖
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
Only know you've been high when you're feeling low 只有在身处低谷时才遥想过去峥嵘
Only hate the road when you're missing home 只有在乡愁涌动时才痛恨旅途遥远
Only know you love her when you let her go 只有在让她走之后才始知那是真爱
And you let her go 你却让她走了
]]>Passenger - Let Her Go (Feat. Ed Sheeran - Anniversary Edition) [Official Video]数据结构作业3https://www.wotemo.com/posts/7809.html2024-06-09T06:16:16.000Z2024-06-09T06:16:16.000Z
intmain(){ string s; while (getline(cin, s)) { int ans=0; for (int i = 0; i < s.length(); ++i) { int j=i,k=i; while (j>=0 && k<s.length()) { if (s[j]==s[k]) ++ans; elsebreak; --j; ++k; } } for (int i = 0; i < s.length()-1; ++i) { int j=i,k=i+1; while (j>=0 && k<s.length()) { if (s[j]==s[k]) ++ans; elsebreak; --j; ++k; } } cout << ans << endl; s.clear(); if (cin.peek() == '\n') break; } return0; }
intmain(){ int n; cin >> n; int num[n]; int score[n]; for (int i = 0; i < n; ++i) { cin >> num[i] >> score[i]; } int find_num; cin >> find_num; for (int i = 0; i < n; ++i) { if (num[i] == find_num) { cout << score[i]; return0; } } return0; }
voidinsert(node* head, int index, int data){ for (int i = 1; i < index; ++i) { head = head->next; } node* tmp = getNewNode(data); tmp->next = head->next; head->next = tmp; }
voidfind_idx(vector<node*> &v, node* head, int index){ for (int i = 0; i < index; ++i) { head = head->next; } v.push_back(head); }
voidv_insert(node* pos, node* head, int data){ node* p = head; head = head->next; while (head!=pos) { head = head->next; p = p->next; } head = getNewNode(data); head->next = p->next; p->next = head; }
intmain(){ int n; cin >> n; node* head = getNewNode(0), *tail = head; int num; for (int i = 1; i <= n; ++i) { cin >> num; tail->next = getNewNode(num); tail = tail->next; } cin >> n; int index; vector<node*> v; vector<int> nums; for (int i = 0; i < n; ++i) { cin >> index >> num; nums.push_back(num); find_idx(v, head, index); } for (int i = 0; i < n; ++i) { v_insert(v[i], head, nums[i]); } while (head->next!=nullptr) { head = head->next; cout << head->data << " "; } return0; }
intmain(){ vector<int> v1, v2; char chs[10000] = {0}; cin.getline(chs, 10000); int i = 0; while (chs[i]!=0) { int j = i, num = 0; while (chs[j] != ' ' && chs[j] != 0) { num = num*10+chs[j++]-'0'; } v1.push_back(num); i = j+1; } char chs2[10000]; cin.getline(chs2, 10000); i = 0; while (chs2[i]!=0) { int j = i, num = 0; while (chs2[j] != ' ' && chs2[j] != 0) { num = num*10+chs2[j++]-'0'; } v2.push_back(num); i = j+1; }
intmain(){ string str; getline(cin, str); int i = 0; node* head = getNewNode(0), *tail = head; while (i<str.size()) { int j = i, num = 0; while (str[j] != ' ' && str[j] != 0) { num = num*10+str[j++]-'0'; } node* p = getNewNode(num); tail->next = p; tail = tail->next; i = j+1; }
int count = 0; int max_num = tail->data; while (head->next != nullptr) { head = head->next; if (head->data > max_num) { max_num = head->data; count = 0; } if (head->data == max_num) { ++count; } } cout << count; return0; }
intmain(){ int n, m; cin >> n >> m; node* p = getNewNode(1), *q = p; for (int i = 2; i <= n; ++i) { q->next = getNewNode(i); q = q->next; } q->next = p;
while (p->next!=p) { m %= n; for (int i = 2; i <= m; ++i) { p = p->next; } cout << p->data << " "; p->data = p->next->data; p->next = p->next->next;
publicThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
publicfinalclassUnsafe { // Unsafe类中的getAndAddInt方法 publicfinalintgetAndAddInt(Object o, long offset, int delta) { int v; // do...while就是自旋操作,当CAS成功以后，循环结束 do { // 获取AtomicInteger类中所封装的int类型的值，就相当于旧的预期值A v = getIntVolatile(o, offset); // 调用本类的weakCompareAndSetInt方法实现比较在交换； o: AtomicInteger对象, v: 相当于旧的预期值A, v + delta：新值B } while (!weakCompareAndSetInt(o, offset, v, v + delta)); return v; } // Unsafe类中的weakCompareAndSetInt方法 publicfinalbooleanweakCompareAndSetInt(Object o, long offset, int expected, int x) { return compareAndSetInt(o, offset, expected, x); }
// 本地方法，调用CPU指令实现CAS publicfinalnativebooleancompareAndSetInt(Object o, long offset, int expected, int x); }
-- 年龄等于30 select * from employee where age = 30; -- 年龄小于30 select * from employee where age < 30; -- 小于等于 select * from employee where age <= 30; -- 没有身份证 select * from employee where idcard is null or idcard = ''; -- 有身份证 select * from employee where idcard; select * from employee where idcard is not null; -- 不等于 select * from employee where age != 30; -- 年龄在20到30之间 select * from employee where age between 20 and 30; select * from employee where age >= 20 and age <= 30; -- 下面语句不报错，但查不到任何信息 select * from employee where age between 30 and 20; -- 性别为女且年龄小于30 select * from employee where age < 30 and gender = '女'; -- 年龄等于25或30或35 select * from employee where age = 25 or age = 30 or age = 35; select * from employee where age in (25, 30, 35); -- 姓名为两个字 select * from employee where name like '__'; -- 身份证最后为X select * from employee where idcard like '%X';
聚合查询（聚合函数）
常见聚合函数：
函数
功能
count
统计数量
max
最大值
min
最小值
avg
平均值
sum
求和
语法： SELECT 聚合函数(字段列表) FROM 表名; 例： SELECT count(id) from employee where workaddress = "广东省";
分组查询
语法： SELECT 字段列表 FROM 表名 [ WHERE 条件 ] GROUP BY 分组字段名 [ HAVING 分组后的过滤条件 ];
-- 根据性别分组，统计男性和女性数量（只显示分组数量，不显示哪个是男哪个是女） select count(*) from employee group by gender; -- 根据性别分组，统计男性和女性数量 select gender, count(*) from employee group by gender; -- 根据性别分组，统计男性和女性的平均年龄 select gender, avg(age) from employee group by gender; -- 年龄小于45，并根据工作地址分组 select workaddress, count(*) from employee where age < 45 group by workaddress; -- 年龄小于45，并根据工作地址分组，获取员工数量大于等于3的工作地址 select workaddress, count(*) address_count from employee where age < 45 group by workaddress having address_count >= 3;
注意事项
执行顺序：where > 聚合函数 > having
分组之后，查询的字段一般为聚合函数和分组字段，查询其他字段无任何意义
排序查询
语法： SELECT 字段列表 FROM 表名 ORDER BY 字段1 排序方式1, 字段2 排序方式2;
排序方式：
ASC: 升序（默认）
DESC: 降序
例子：
1 2 3 4 5
-- 根据年龄升序排序 SELECT * FROM employee ORDER BY age ASC; SELECT * FROM employee ORDER BY age; -- 两字段排序，根据年龄升序排序，入职时间降序排序 SELECT * FROM employee ORDER BY age ASC, entrydate DESC;
注意事项
如果是多字段排序，当第一个字段值相同时，才会根据第二个字段进行排序
分页查询
语法： SELECT 字段列表 FROM 表名 LIMIT 起始索引, 查询记录数;
例子：
1 2 3 4
-- 查询第一页数据，展示10条 SELECT * FROM employee LIMIT 0, 10; -- 查询第二页 SELECT * FROM employee LIMIT 10, 10;
注意事项
起始索引从0开始，起始索引 = （查询页码 - 1） * 每页显示记录数
分页查询是数据库的方言，不同数据库有不同实现，MySQL是LIMIT
如果查询的是第一页数据，起始索引可以省略，直接简写 LIMIT 10
DQL执行顺序
FROM -> WHERE -> GROUP BY -> SELECT -> ORDER BY -> LIMIT
DCL
管理用户
查询用户：
1 2
USE mysql; SELECT * FROM user;
创建用户: CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
修改用户密码： ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';
删除用户： DROP USER '用户名'@'主机名';
例子：
1 2 3 4 5 6 7 8 9
-- 创建用户test，只能在当前主机localhost访问 create user 'test'@'localhost' identified by '123456'; -- 创建用户test，能在任意主机访问 create user 'test'@'%' identified by '123456'; create user 'test' identified by '123456'; -- 修改密码 alter user 'test'@'localhost' identified with mysql_native_password by '1234'; -- 删除用户 drop user 'test'@'localhost';
CASE WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END
如果val1为true，返回res1，… 否则返回default默认值
CASE [ expr ] WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END
如果expr的值等于val1，返回res1，… 否则返回default默认值
例子：
1 2 3 4 5 6 7 8
select name, (case when age > 30 then '中年' else '青年' end) from employee; select name, (case workaddress when '北京市' then '一线城市' when '上海市' then '一线城市' else '二线城市' end) as '工作地址' from employee;
约束
分类：
约束
描述
关键字
非空约束
限制该字段的数据不能为null
NOT NULL
唯一约束
保证该字段的所有数据都是唯一、不重复的
UNIQUE
主键约束
主键是一行数据的唯一标识，要求非空且唯一
PRIMARY KEY
默认约束
保存数据时，如果未指定该字段的值，则采用默认值
DEFAULT
检查约束（8.0.1版本后）
保证字段值满足某一个条件
CHECK
外键约束
用来让两张图的数据之间建立连接，保证数据的一致性和完整性
FOREIGN KEY
约束是作用于表中字段上的，可以再创建表/修改表的时候添加约束。
常用约束
约束条件
关键字
主键
PRIMARY KEY
自动增长
AUTO_INCREMENT
不为空
NOT NULL
唯一
UNIQUE
逻辑条件
CHECK
默认值
DEFAULT
例子：
1 2 3 4 5 6 7
create table user( id int primary key auto_increment, name varchar(10) not null unique, age int check(age > 0 and age < 120), status char(1) default '1', gender char(1) );
合并查询（笛卡尔积，会展示所有组合结果）： select * from employee, dept;
笛卡尔积：两个集合A集合和B集合的所有组合情况（在多表查询时，需要消除无效的笛卡尔积）
消除无效笛卡尔积： select * from employee, dept where employee.dept = dept.id;
内连接查询
内连接查询的是两张表交集的部分
隐式内连接： SELECT 字段列表 FROM 表1, 表2 WHERE 条件 ...;
显式内连接： SELECT 字段列表 FROM 表1 [ INNER ] JOIN 表2 ON 连接条件 ...;
显式性能比隐式高
例子：
1 2 3 4 5
-- 查询员工姓名，及关联的部门的名称 -- 隐式 select e.name, d.name from employee as e, dept as d where e.dept = d.id; -- 显式 select e.name, d.name from employee as e inner join dept as d on e.dept = d.id;
外连接查询
左外连接： 查询左表所有数据，以及两张表交集部分数据 SELECT 字段列表 FROM 表1 LEFT [ OUTER ] JOIN 表2 ON 条件 ...; 相当于查询表1的所有数据，包含表1和表2交集部分数据
右外连接： 查询右表所有数据，以及两张表交集部分数据 SELECT 字段列表 FROM 表1 RIGHT [ OUTER ] JOIN 表2 ON 条件 ...;
例子：
1 2 3 4 5
-- 左 select e.*, d.name from employee as e left outer join dept as d on e.dept = d.id; select d.name, e.* from dept d left outer join emp e on e.dept = d.id; -- 这条语句与下面的语句效果一样 -- 右 select d.name, e.* from employee as e right outer join dept as d on e.dept = d.id;
左连接可以查询到没有dept的employee，右连接可以查询到没有employee的dept
自连接查询
当前表与自身的连接查询，自连接必须使用表别名
语法： SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件 ...;
自连接查询，可以是内连接查询，也可以是外连接查询
例子：
1 2 3 4
-- 查询员工及其所属领导的名字 select a.name, b.name from employee a, employee b where a.manager = b.id; -- 没有领导的也查询出来 select a.name, b.name from employee a left join employee b on a.manager = b.id;
联合查询 union, union all
把多次查询的结果合并，形成一个新的查询集
语法：
1 2 3
SELECT 字段列表 FROM 表A ... UNION [ALL] SELECT 字段列表 FROM 表B ...
注意事项
UNION ALL 会有重复结果，UNION 不会
联合查询比使用or效率高，不会使索引失效
子查询
SQL语句中嵌套SELECT语句，称谓嵌套查询，又称子查询。 SELECT * FROM t1 WHERE column1 = ( SELECT column1 FROM t2); 子查询外部的语句可以是 INSERT / UPDATE / DELETE / SELECT 的任何一个
根据子查询结果可以分为：
标量子查询（子查询结果为单个值）
列子查询（子查询结果为一列）
行子查询（子查询结果为一行）
表子查询（子查询结果为多行多列）
根据子查询位置可分为：
WHERE 之后
FROM 之后
SELECT 之后
标量子查询
子查询返回的结果是单个值（数字、字符串、日期等）。 常用操作符：- < > > >= < <=
例子：
1 2 3 4 5 6 7 8 9
-- 查询销售部所有员工 select id from dept where name = '销售部'; -- 根据销售部部门ID，查询员工信息 select * from employee where dept = 4; -- 合并（子查询） select * from employee where dept = (select id from dept where name = '销售部');
-- 查询xxx入职之后的员工信息 select * from employee where entrydate > (select entrydate from employee where name = 'xxx');
列子查询
返回的结果是一列（可以是多行）。
常用操作符：
操作符
描述
IN
在指定的集合范围内，多选一
NOT IN
不在指定的集合范围内
ANY
子查询返回列表中，有任意一个满足即可
SOME
与ANY等同，使用SOME的地方都可以使用ANY
ALL
子查询返回列表的所有值都必须满足
例子：
1 2 3 4 5 6
-- 查询销售部和市场部的所有员工信息 select * from employee where dept in (select id from dept where name = '销售部' or name = '市场部'); -- 查询比财务部所有人工资都高的员工信息 select * from employee where salary > all(select salary from employee where dept = (select id from dept where name = '财务部')); -- 查询比研发部任意一人工资高的员工信息 select * from employee where salary > any (select salary from employee where dept = (select id from dept where name = '研发部'));
行子查询
返回的结果是一行（可以是多列）。 常用操作符：=, <, >, IN, NOT IN
例子：
1 2 3
-- 查询与xxx的薪资及直属领导相同的员工信息 select * from employee where (salary, manager) = (12500, 1); select * from employee where (salary, manager) = (select salary, manager from employee where name = 'xxx');
表子查询
返回的结果是多行多列 常用操作符：IN
例子：
1 2 3 4
-- 查询与xxx1，xxx2的职位和薪资相同的员工 select * from employee where (job, salary) in (select job, salary from employee where name = 'xxx1' or name = 'xxx2'); -- 查询入职日期是2006-01-01之后的员工，及其部门信息 select e.*, d.* from (select * from employee where entrydate > '2006-01-01') as e left join dept as d on e.dept = d.id;
-- 1. 查询张三账户余额 select * from account where name = '张三'; -- 2. 将张三账户余额-1000 update account set money = money - 1000 where name = '张三'; -- 此语句出错后张三钱减少但是李四钱没有增加 模拟sql语句错误 -- 3. 将李四账户余额+1000 update account set money = money + 1000 where name = '李四';
-- 设置手动提交后上面代码改为： select * from account where name = '张三'; update account set money = money - 1000 where name = '张三'; update account set money = money + 1000 where name = '李四'; commit;
操作方式二：
开启事务： START TRANSACTION 或 BEGIN TRANSACTION; 提交事务： COMMIT; 回滚事务： ROLLBACK;
操作实例：
1 2 3 4 5
start transaction; select * from account where name = '张三'; update account set money = money - 1000 where name = '张三'; update account set money = money + 1000 where name = '李四'; commit;
查看当前数据库的 INSERT, UPDATE, DELETE, SELECT 访问频次： SHOW GLOBAL STATUS LIKE 'Com_______'; 或者 SHOW SESSION STATUS LIKE 'Com_______'; 例：show global status like 'Com_______'
查看慢查询日志开关状态： show variables like 'slow_query_log';
profile
show profile 能在做SQL优化时帮我们了解时间都耗费在哪里。通过 have_profiling 参数，能看到当前 MySQL 是否支持 profile 操作： SELECT @@have_profiling; profiling 默认关闭，可以通过set语句在session/global级别开启 profiling： SET profiling = 1; 查看所有语句的耗时： show profiles; 查看指定query_id的SQL语句各个阶段的耗时： show profile for query query_id; 查看指定query_id的SQL语句CPU的使用情况 show profile cpu for query query_id;
创建索引： CREATE [ UNIQUE | FULLTEXT ] INDEX index_name ON table_name (index_col_name, ...); 如果不加 CREATE 后面不加索引类型参数，则创建的是常规索引
查看索引： SHOW INDEX FROM table_name;
删除索引： DROP INDEX index_name ON table_name;
案例：
1 2 3 4 5 6 7 8 9 10 11
-- name字段为姓名字段，该字段的值可能会重复，为该字段创建索引 create index idx_user_name on tb_user(name); -- phone手机号字段的值非空，且唯一，为该字段创建唯一索引 create unique index idx_user_phone on tb_user (phone); -- 为profession, age, status创建联合索引 create index idx_user_pro_age_stat on tb_user(profession, age, status); -- 为email建立合适的索引来提升查询效率 create index idx_user_email on tb_user(email);
在索引列上进行运算操作，索引将失效。如：explain select * from tb_user where substring(phone, 10, 2) = '15';
字符串类型字段使用时，不加引号，索引将失效。如：explain select * from tb_user where phone = 17799990015;，此处phone的值没有加引号
模糊查询中，如果仅仅是尾部模糊匹配，索引不会是失效；如果是头部模糊匹配，索引失效。如：explain select * from tb_user where profession like '%工程';，前后都有 % 也会失效。
用 or 分割开的条件，如果 or 其中一个条件的列没有索引，那么涉及的索引都不会被用到。
如果 MySQL 评估使用索引比全表更慢，则不使用索引。
SQL 提示
是优化数据库的一个重要手段，简单来说，就是在SQL语句中加入一些人为的提示来达到优化操作的目的。
例如，使用索引： explain select * from tb_user use index(idx_user_pro) where profession="软件工程"; 不使用哪个索引： explain select * from tb_user ignore index(idx_user_pro) where profession="软件工程"; 必须使用哪个索引： explain select * from tb_user force index(idx_user_pro) where profession="软件工程";
use 是建议，实际使用哪个索引 MySQL 还会自己权衡运行速度去更改，force就是无论如何都强制使用该索引。
explain 中 extra 字段含义： using index condition：查找使用了索引，但是需要回表查询数据 using where; using index;：查找使用了索引，但是需要的数据都在索引列中能找到，所以不需要回表查询
如果在聚集索引中直接能找到对应的行，则直接返回行数据，只需要一次查询，哪怕是select *；如果在辅助索引中找聚集索引，如select id, name from xxx where name='xxx';，也只需要通过辅助索引(name)查找到对应的id，返回name和name索引对应的id即可，只需要一次查询；如果是通过辅助索引查找其他字段，则需要回表查询，如select id, name, gender from xxx where name='xxx';
所以尽量不要用select *，容易出现回表查询，降低效率，除非有联合索引包含了所有字段
面试题：一张表，有四个字段（id, username, password, status），由于数据量大，需要对以下SQL语句进行优化，该如何进行才是最优方案： select id, username, password from tb_user where username='itcast';
语法：create index idx_xxxx on table_name(columnn(n)); 前缀长度：可以根据索引的选择性来决定，而选择性是指不重复的索引值（基数）和数据表的记录总数的比值，索引选择性越高则查询效率越高，唯一索引的选择性是1，这是最好的索引选择性，性能也是最好的。 求选择性公式：
1 2
select count(distinct email) / count(*) from tb_user; select count(distinct substring(email, 1, 5)) / count(*) from tb_user;
# 客户端连接服务端时，加上参数 --local-infile（这一行在bash/cmd界面输入） mysql --local-infile -u root -p # 设置全局参数local_infile为1，开启从本地加载文件导入数据的开关 set global local_infile = 1; select @@local_infile; # 执行load指令将准备好的数据，加载到表结构中 load data local infile '/root/sql1.log' into table 'tb_user' fields terminated by ',' lines terminated by '\n';
Using filesort：通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区 sort buffer 中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫 FileSort 排序
Using index：通过有序索引顺序扫描直接返回有序数据，这种情况即为 using index，不需要额外排序，操作效率高
如果order by字段全部使用升序排序或者降序排序，则都会走索引，但是如果一个字段升序排序，另一个字段降序排序，则不会走索引，explain的extra信息显示的是Using index, Using filesort，如果要优化掉Using filesort，则需要另外再创建一个索引，如：create index idx_user_age_phone_ad on tb_user(age asc, phone desc);，此时使用select id, age, phone from tb_user order by age asc, phone desc;会全部走索引
如索引为idx_user_pro_age_stat，则句式可以是select ... where profession order by age，这样也符合最左前缀法则
limit优化
常见的问题如limit 2000000, 10，此时需要 MySQL 排序前2000000条记录，但仅仅返回2000000 - 2000010的记录，其他记录丢弃，查询排序的代价非常大。 优化方案：一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化
例如：
1 2 3 4 5 6 7 8
-- 此语句耗时很长 select * from tb_sku limit 9000000, 10; -- 通过覆盖索引加快速度，直接通过主键索引进行排序及查询 select id from tb_sku order by id limit 9000000, 10; -- 下面的语句是错误的，因为 MySQL 不支持 in 里面使用 limit -- select * from tb_sku where id in (select id from tb_sku order by id limit 9000000, 10); -- 通过连表查询即可实现第一句的效果，并且能达到第二句的速度 select * from tb_sku as s, (select id from tb_sku order by id limit 9000000, 10) as a where s.id = a.id;
如以下两条语句： update student set no = '123' where id = 1;，这句由于id有主键索引，所以只会锁这一行； update student set no = '123' where name = 'test';，这句由于name没有索引，所以会把整张表都锁住进行数据更新，解决方法是给name字段添加索引
# Written by Tai-Hsuan Ho# Created on 2016/11/25, and developed on Python 3.4## Call: InputBox(rect, **args) to create a input bar editor in region defined by rect.## Keyword arguments include:# font: font of the input text.# text: text initially in the input bar when it is created.# bk_image: background image of the text input bar.# bk_color: background color of the text input bar, ignored when bk_image is specified.# bd_color: border color, no border if this keyword is missing or None.# text_color: color of the input text. White color if this keyword is missing.## Return value:# Return (input text, flag), where flag can be True, False, or None when pressing ENTER, # ESC, or receiving QUIT event.## Comments: # The input bar is transparent if both bk_image and bk_color are not specified or None.# There is a game loop inside this function, and all events will be ignore except for # the key events and QUIT, which will be put back to the event queue and exit the game # loop. #import pygamefrom pygame.locals import *COLOR_WHITE = (255, 255, 255)TEXT_MARGIN = 16FPS = 20ALPHABETS = 'abcdefghijklmnopqrstuvwxyz'OTHER_KEYS = '`1234567890-=[]\;\',./'SHIFT_KEYS = '~!@#$%^&*()_+{}|:"<>?'PRINTABLE = ' ' + ALPHABETS + OTHER_KEYS + SHIFT_KEYSdef _caps_lock(ch): # Convert the input char when Caps Lock is turned on. if ch in ALPHABETS: return chr(ord(ch) - ord('a') + ord('A')) else: return chdef _shift_hold(ch, caps_lock): # Convert the input char when SHIFT key is hold. if ch in OTHER_KEYS: return SHIFT_KEYS[OTHER_KEYS.index(ch)] elif ch in ALPHABETS and not caps_lock: return chr(ord(ch) - ord('a') + ord('A')) else: return chdef _draw_box(surface, bk_image, bk_color, display_backup, bd_color): # Draw background image or fill color to the base surface, and draw the border. (width, height) = surface.get_size() if bk_image: surface.blit(bk_image, (0, 0)) elif bk_color: surface.fill(bk_color) else: surface.blit(display_backup, (0, 0)) if bd_color: pygame.draw.rect(surface, bd_color, surface.get_rect(), 1)def _draw_text(surface, input_chars, font, color, start_index, cursor_index, show_cursor): # Draw the input text, making sure the char at cursor index is shown on the screen. x = 0 pos = [x] for i in range(len(input_chars)): x += font.size(input_chars[i])[0] pos.append(x) # Find the start index, so that the cursor can be seen in the input editor. if start_index >= cursor_index: start_index = max(0, cursor_index - 5) while pos[cursor_index] - pos[start_index] > (surface.get_width() - 2 * TEXT_MARGIN): start_index += 1 # Draw text in the editor. h = font.size('a')[1] y = (surface.get_height() - h) // 2 for i in range(start_index, len(input_chars)): img = font.render(input_chars[i], True, color) x = TEXT_MARGIN + pos[i] - pos[start_index] surface.blit(img, (x, y)) if x + img.get_width() + TEXT_MARGIN > surface.get_width(): break # Draw cursor and return the start index. if show_cursor: x = TEXT_MARGIN + pos[cursor_index] - pos[start_index] pygame.draw.line(surface, color, (x, y), (x, y + h)) return start_indexdef InputBox(rect, **args): # Draw a box for text input. Return (text, True) when ENTER is pressed, (text, False) when ESC pressed, and (text, None) when QUIT # event is received. When both bk_image and bk_color are not specified, the input editor is transparent. try: font = args['font'] except: font = pygame.font.Font(None, 32) try: input_chars = list(args['text']) except: input_chars = [] try: bk_image = args['bk_image'] except: bk_image = None try:bd_color = args['bd_color'] except:bd_color = None try:bk_color = args['bk_color'] except:bk_color = None try:text_color = args['text_color'] except:text_color = COLOR_WHITE # Set repeat key event. pygame.key.set_repeat(500, 50) # Get display background in region of the input box. display = pygame.display.get_surface() display_backup = display.subsurface(rect).copy() # Create surface. surface = pygame.Surface(rect.size) # Get input event and update the input box. n = 0 start_index = 0 cursor_index = len(input_chars) bNeedUpdate = True myClock = pygame.time.Clock() while True: for event in pygame.event.get(): if event.type == QUIT: display.blit(display_backup, rect) pygame.display.update(rect) pygame.event.post(pygame.event.Event(QUIT, {})) return (''.join(input_chars), None) # For key up event, check if enter or escape keys are pressed. elif event.type == KEYUP: if event.key in (K_ESCAPE, K_RETURN): display.blit(display_backup, rect) pygame.display.update(rect) return (''.join(input_chars), event.key is K_RETURN) # For key down event, process backspace, delete, left, right, home, end, and normal key inputs. elif event.type == KEYDOWN: bNeedUpdate = True # Backspace key, deleting the previous char and moving the cursor left. if event.key == K_BACKSPACE: if cursor_index >= 1: del input_chars[cursor_index - 1] cursor_index -= 1 # Delete key, deleting the current char. elif event.key == K_DELETE: if cursor_index < len(input_chars): del input_chars[cursor_index] # Left arrow key, moving cursor index to the previous char. elif event.key == K_LEFT: if cursor_index >= 1: cursor_index -= 1 # Right arrow key, moving cursor index to the next char. elif event.key == K_RIGHT: if cursor_index < len(input_chars): cursor_index += 1 # HOME key, moving cursor index to start of the input chars. elif event.key == K_HOME: cursor_index = 0 # END key, moving cursor index to end of the input chars. elif event.key == K_END: cursor_index = len(input_chars) # Otherwise, add printable key to the input char list. else: try: ch = chr(event.key) if ch in PRINTABLE: shift_hold = (event.mod & KMOD_SHIFT) caps_lock = (event.mod & KMOD_CAPS) if shift_hold: ch = _shift_hold(ch, caps_lock) elif caps_lock: ch = _caps_lock(ch) input_chars.insert(cursor_index, ch) cursor_index += 1 except: pass # Update the display for every 0.5 second or when key down event is received. if bNeedUpdate or (n == 0) or (n == FPS // 2): _draw_box(surface, bk_image, bk_color, display_backup, bd_color) show_cursor = bNeedUpdate or (n == 0) start_index = _draw_text(surface, input_chars, font, text_color, start_index, cursor_index, show_cursor) display.blit(surface, rect) pygame.display.update(rect) bNeedUpdate = False n = (n + 1) % FPS myClock.tick(FPS)# Test codes.def main(): rect = pygame.Rect(200, 250, 200, 40) name_input = InputBox(rect, text = '', bd_color = (66, 133, 244), bk_color = (229, 231, 206), text_color = (0, 0, 0)) print(f'你好：{name_input}') return name_input
]]><h1 id="SnakeGame"><a href="#SnakeGame" class="headerlink" title="SnakeGame"></a>SnakeGame</h1><p>一个Python & Pygame开发的贪吃蛇小游戏</p>
<p>由<a一款完备的Python用户注册与登录系统（含验证码及哈希加密）https://www.wotemo.com/posts/4547.html2022-05-01T07:33:45.000Z2023-08-24T07:33:45.000Z滴滴滴，沃特陌与您汇报情况
withopen(filename, 'r') as file: names = file.read().splitlines() names = [name for name in names] while active == 0: usernameinput = input('请输入你的用户名：') userpasswordinput = input('请输入你的密码：') if (len(usernameinput.strip()) == 0) or (len(userpasswordinput.strip()) == 0): print('用户名或密码不为空,请重试！！！\n') continue for name_one in names: name_one = eval(name_one) username.append(name_one['username']) if usernameinput in username: for name_two in names: name_two = eval(name_two) if usernameinput == name_two['username']: pws = name_two['salt'] + userpasswordinput after_hash_password = hashlib.sha256(pws.encode("utf-8")).hexdigest() if after_hash_password == name_two['password_hash']: print('登录成功！！！') active = 1 break elif after_hash_password != name_two['password_hash']: print('密码错误,请重试！！！\n') break else: print('用户名不存在,请重试！！！\n')
withopen(filename, 'r') as file: names = file.read().splitlines() names = [name for name in names] while active == 0: emailinput = input('请输入你的邮箱：') userpasswordinput = input('请输入你的密码：') if (len(emailinput.strip()) == 0) or (len(userpasswordinput.strip()) == 0): print('邮箱或密码不为空,请重试！！！\n') continue for name_one in names: name_one = eval(name_one) email.append(name_one['email']) if emailinput in email: for name_two in names: name_two = eval(name_two) if emailinput == name_two['email']: pws = name_two['salt'] + userpasswordinput after_hash_password = hashlib.sha256(pws.encode("utf-8")).hexdigest() if after_hash_password == name_two['password_hash']: print('登录成功！！！') active = 1 break elif after_hash_password != name_two['password_hash']: print('密码错误,请重试！！！\n') break else: print('邮箱不存在,请重试！！！\n')
