这个能实现？@ 一下万能的 @老虎会游泳

@李沐沐，加个 KEY(uid) 试试？

另外，如果你能将 family_uid 的实际意义，从 身份证号 换成 户主id，就不用加 KEY(uid) 了

@李沐沐，你还希望，户主ID较小的整个家庭排前面，是嘛？若是：

SQL 代码

若速度太慢，可加索引。看具体需要（加个 KEY(uid) 应该可以大幅加速。但总共就几千行，原来的速度应该也不会太慢）

SELECT a.family_uid, a.id, a.name, a.relationship, a.Gender, a.nation, a.uid, a.phone, a.Culture, a.marriage
FROM personnels_too a
JOIN personnels_too b ON b.uid = a.family_uid
ORDER BY b.id, a.family_uid != a.uid, a.id;

结果

family_uid	id	name	relationship	Gender	nation	uid	phone	Culture	marriage
101100202202052252	1	张三	户主	男	汉	101100202202052252	18888888888	高中	已婚
101100202202052252	2	李娥	配偶	女	汉	101100202102052243	18888888888	高中	已婚
101100202202052252	5	李爱	女儿	女	汉	101100202204052243	18888888888	高中	未婚
101100201102052243	3	王五	户主	男	汉	101100201102052243	18888888888	高中	已婚
101100201102052243	4	丽丽	女儿	女	汉	101100201702052243	18888888888	高中	已婚

@老虎会游泳，老虎日常占用多少内存？（想看看 16 GB 够不够）

@老虎会游泳，

内存泄漏严重吗？还是说，非 Win 系统。。

@tasy5kg，我也用过 RamMap，但没看太明白。

只试过“清空工作集”。不一会儿内存又回去了。感觉有点像以前安全软件的“一键释放内存”。。

而且，感觉从原理上来说，没解决掉真正发生泄露的程序，应该都帮助不大（听有些人说，是由于核显驱动导致的泄露。。官方也好几年不管？）

@tasy5kg，反正我印象中 win 7 一直挺稳定的。毕竟人家测试的质量也比 win10 11 好

无论如何，win 7 也逐步成过去时了。连 Python 不支持 win 7 也快 2 年了。。

感觉我下一台笔电，至少 32 GB。省得整天陷入内存焦虑（就像 K40 有 12 GB 内存一样）

碰到微力同步这种莫名其妙吃固态的应用，也能开个 20 GB 内存盘，任它干个 100 TB 都不怕

@tasy5kg，我记得以前 win 7 没有此问题的

目前我觉得 win 7 是最稳定的一个系统

@tasy5kg，我也有同样的问题！！！

我是 Win 10，一般用了几天不重启，内存泄漏就很严重了

关掉所有程序，都会占用 4~5 GB。。

我实际使用感知也不太大，但固态扛下了一切

特别这一星期，被微力同步折腾的死去活来，感觉系统固态盘写了快 1TB 了，但实际数据没下多少 GB。。

@tasy5kg，感觉现在浏览器应用越来越多，IDE 吃内存又狠。

你觉得日常够用吗？一般占用多少内存？11、12 GB ？

@tasy5kg，你的电脑内存多大啊？16GB吗？

@李沐沐，5 楼的尝试了吗？效果咋样？

SELECT family_uid, id, name, relationship, Gender, nation, uid, phone, Culture, marriage
FROM personnels_too
ORDER BY family_uid, family_uid != uid, id;

@李沐沐，不能写成这样吗？

SQLite 代码

看需要加索引

WITH
  data(id, name, relationship, Gender, nation, uid, phone, Culture, marriage, family, family_uid, life, Village, remarks, WorkingAddress, addtime, uptime) AS (
    VALUES
(1, '张三', '户主', '男', '汉', '101100202202052252', '18888888888', '高中', '已婚', '张三', '101100202202052252', 1, '田系组', NULL, NULL, '', ''),
(2, '李娥', '配偶', '女', '汉', '101100202102052243', '18888888888', '高中', '已婚', '张三', '101100202202052252', 1, '田系组', NULL, NULL, '', ''),
(3, '王五', '户主', '男', '汉', '101100201102052243', '18888888888', '高中', '已婚', '王五', '101100201102052243', 1, '田系组', NULL, NULL, '', ''),
(4, '丽丽', '女儿', '女', '汉', '101100201702052243', '18888888888', '高中', '已婚', '王五', '101100201102052243', 1, '田系组', NULL, NULL, '', ''),
(5, '李爱', '女儿', '女', '汉', '101100202204052243', '18888888888', '高中', '未婚', '张三', '101100202202052252', 1, '田系组', NULL, NULL, '', '')
  )

SELECT family_uid, id, name, relationship, Gender, nation, uid, phone, Culture, marriage
FROM data
ORDER BY family_uid, family_uid != uid, id;
-- ORDER BY family_uid, relationship != '户主', id;

结果

family_uid	id	name	relationship	Gender	nation	uid	phone	Culture	marriage
101100201102052243	3	王五	户主	男	汉	101100201102052243	18888888888	高中	已婚
101100201102052243	4	丽丽	女儿	女	汉	101100201702052243	18888888888	高中	已婚
101100202202052252	1	张三	户主	男	汉	101100202202052252	18888888888	高中	已婚
101100202202052252	2	李娥	配偶	女	汉	101100202102052243	18888888888	高中	已婚
101100202202052252	5	李爱	女儿	女	汉	101100202204052243	18888888888	高中	未婚

看不懂这是个啥需求啊。。

@淡然，

从表a获取status状态为0的token，获取到后标记status为1

不加锁，多个连接同时获取同一个 status == 0 的标记记录，不是很正常吗？

然后多次 update xxx set status = 1 where id = ? 呗

@庸人，那就不知道了。。我用 3 楼的法子，都能绕开一段时间的 cloudflare。。

你本地运行着啥？有源码的话，直接瞅瞅逻辑呗？

@庸人，浏览器打开【开发工具】，在【网络】里，把这个请求复制成【curl】请求，然后粘贴运行试试？

@罐子，噢，有可能，开发商没给源代码，只给执行文件 + 配置文件，代理商能泄露的也只有这些了。。

大佬凭空造轮子的，我听说原神私服好像就是这样？

重金购买私服二开的，传奇是个例子吗？

@罐子，它们是如何流出的呢？为嘛源码没有顺便流出来呢？

@老虎会游泳，我做了下『闭包表』和『改良后的邻接表』的测试 （结尾附上一键建表和查询的 SQL 供测试）

• 数据源：2022 年中国全国 5 级行政区划
• 数据库：MySQL 8.0.29 和 SQLite 3.39.0
• 表结构：『闭包表』和『 (<pid, id>, is_leaf) 型邻接表』
• 测试项：『查询根节点所有后代』和『查询根节点第 5 层后代』

结果如下 （多次测试稳定后）：

『查询根节点所有后代』速度对比

表结构	MySQL	SQLite
闭包表	1.3 秒	0.13 秒
递归邻接表	1.2 秒	0.60 秒
理想中递归损耗很小的邻接表	0.6 秒	0.12 秒

『查询根节点第 5 层后代』速度对比

表结构	MySQL	SQLite
闭包表	1.2 秒	0.12 秒
递归邻接表	0.5 秒	0.13 秒
理想中递归损耗很小的邻接表	0.4 秒	0.10 秒

目前观点

1. 4W 多次的 ref 级 WHERE pid = ?，还是能和 66W 次 eq_ref 级的 WHERE id = ? 过过招，甚至更快的。而且，磁盘IO越慢，这个差异应该越大。

2. 数据库们的 WITH RECURSIVE 查询，损耗有点大。

   • MySQL 好歹每次递归都将上一次所有结果当作一张表来计算。但大概 5 次递归的耗时，就比非递归的多一倍了

   • SQLite 最摆烂，每次递归只取以前结果的一行来计算，直到取完为止。所以有 66W 次的递归，耗时大概 5 倍多。。

     Extract a single row from the queue.

     Pretend that the single row just extracted is the only row in the recursive table and run the recursive-select, adding all results to the queue.

『查询根节点所有后代』通用 SQL

下面 SQL 基本可用于 MySQL 和 SQLite （不支持的特性，数据库会报错，改掉即可）

PRAGMA cache_size = -204800; -- 允许 SQLite 缓存 200 MB

-- 闭包表查询
SELECT COUNT(*), SUM(code), SUM(CHAR_LENGTH(name)) -- SQLite 写法：SUM(LENGTH(name))
  FROM closure_tree
 FORCE INDEX (idx_closure_tree) -- 我这测试，MySQL 不加这行，耗时翻好几倍。SQLite 需去掉此行
  JOIN closure ON id = descendant
 WHERE ancestor = 0;

-- 递归邻接表查询
WITH RECURSIVE
  find(id, code, name, is_leaf) AS (
    SELECT id, code, name, is_leaf
      FROM adjacent
     WHERE pid = 0
     UNION ALL
    SELECT b.id, b.code, b.name, b.is_leaf
      FROM find a
      JOIN adjacent b ON NOT a.is_leaf AND b.pid = a.id
  )
SELECT COUNT(*), SUM(code), SUM(CHAR_LENGTH(name)) -- SQLite 写法：SUM(LENGTH(name))
  FROM find;

-- 理想中，没有递归损耗的邻接表查询
SELECT COUNT(*), SUM(b.code), SUM(CHAR_LENGTH(b.name)) -- SQLite 写法：SUM(LENGTH(b.name))
  FROM adjacent a
  LEFT JOIN adjacent b ON b.pid = a.id -- SQLite 需要 LEFT JOIN，否则耗时翻几倍
 WHERE NOT a.is_leaf;

『查询根节点第 5 层后代』通用 SQL

PRAGMA cache_size = -204800; -- 允许 SQLite 缓存 200 MB

-- 闭包表查询
SELECT COUNT(*), SUM(code), SUM(CHAR_LENGTH(name)) -- SQLite 写法：SUM(LENGTH(name))
  FROM closure_tree
 FORCE INDEX (idx_closure_tree) -- 我这测试，MySQL 不加这行，耗时翻好几倍。SQLite 需去掉此行
  JOIN closure ON id = descendant
 WHERE ancestor = 0
   AND distance = 5;

-- 递归邻接表查询
WITH RECURSIVE
  var(depth) AS (
    SELECT 5
  ),

  -- 递归部分查前 N - 1 层
  find(id, is_leaf, depth) AS (
    SELECT 0, FALSE, var.depth - 1
      FROM var
     UNION ALL
    SELECT b.id, b.is_leaf, a.depth - 1
      FROM find a
      JOIN adjacent b ON b.pid = a.id
     WHERE a.depth > 0
       AND NOT a.is_leaf
  )

-- 最后一次性 JOIN 第 N 层
SELECT COUNT(*), SUM(b.code), SUM(CHAR_LENGTH(b.name)) -- SQLite 写法：SUM(LENGTH(b.name))
  FROM find a
 CROSS JOIN adjacent b ON a.id = b.pid -- SQLite 要加 CROSS，否则耗时翻几倍
 WHERE a.depth = 0;

-- 理想中，没有递归损耗的邻接表查询（需要根据层数 N，动态生成 SQL）
SELECT COUNT(*), SUM(t5.code), SUM(CHAR_LENGTH(t5.name)) -- SQLite 写法：SUM(LENGTH(t5.name))
  FROM adjacent t1
  JOIN adjacent t2 ON t2.pid = t1.id
  JOIN adjacent t3 ON t3.pid = t2.id
  JOIN adjacent t4 ON t4.pid = t3.id
  JOIN adjacent t5 ON t5.pid = t4.id
 WHERE t1.pid = 0;

MySQL 一键建表 SQL

（在我低配笔记本和固态上，大约执行了 1 分钟）

-- 允许 200 MB 的内存表
SET max_heap_table_size = 200 << 20;

-- 建临时数据表，装载 csv 数据，以及计算序号和父子关系
CREATE TABLE data (
    code    BIGINT      NOT NULL,
    p_code  BIGINT      NOT NULL,
    type    TINYINT     NOT NULL,
    name    VARCHAR(25) NOT NULL,
    id      INT         NOT NULL,
    pid     INT         NOT NULL,
    PRIMARY KEY (code) USING BTREE,
    INDEX USING BTREE (id),
    INDEX USING BTREE (pid, id)
) ENGINE = MEMORY;

-- 加载 csv
LOAD DATA INFILE 'area_code_2022.csv'
INTO TABLE data
CHARACTER SET UTF8MB4
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
(code, name, type, p_code);

-- 按照 code 顺序计算 id
UPDATE data
  JOIN (SELECT code, ROW_NUMBER() OVER win row_num
          FROM data
        WINDOW win AS (ORDER BY code)) t USING(code)
   SET id = row_num;

-- 计算 parent_id（不存在的标0）
UPDATE data a
  LEFT JOIN data b ON b.code = a.p_code
   SET a.pid = IFNULL(b.id, 0);

-- 建邻接表，并从临时数据表填充数据
CREATE TABLE adjacent (
    id      INT         NOT NULL,
    pid     INT         NOT NULL,
    is_leaf BOOL        NOT NULL,
    type    TINYINT     NOT NULL,
    code    BIGINT      NOT NULL,
    name    VARCHAR(25) NOT NULL,
    PRIMARY KEY (pid, id)
)
SELECT -1 pid, 0 id, FALSE is_leaf, 0 type, 0 code, '' name
 UNION ALL
SELECT pid, id, type = 5 is_leaf, type, code, name
  FROM data;

-- 建闭包表主表，并从临时数据表填充数据
CREATE TABLE closure (
    id      INT         NOT NULL,
    type    TINYINT     NOT NULL,
    code    BIGINT      NOT NULL,
    name    VARCHAR(25) NOT NULL,
    PRIMARY KEY (id)
)
SELECT 0 id, 0 type, 0 code, '' name
 UNION ALL
SELECT id, type, code, name
  FROM data;

-- 建闭包表树形关系表
CREATE TABLE closure_tree (
    ancestor    INT     NOT NULL,
    descendant  INT     NOT NULL,
    distance    TINYINT NOT NULL,
    PRIMARY KEY (descendant, distance)
);

-- 递归构建树形关系
INSERT INTO closure_tree(ancestor, descendant, distance)
WITH RECURSIVE
  parent_of(orig_id, id, dist) AS (
    SELECT id, id, 0
      FROM data
     UNION ALL
    SELECT orig_id, pid, dist + 1
      FROM parent_of
      JOIN data USING(id)
     WHERE id
  )
SELECT id, orig_id, dist
  FROM parent_of;

-- 为闭包表树形关系表建二级索引
CREATE INDEX idx_closure_tree ON closure_tree (ancestor, distance);

-- 丢弃临时数据表
DROP TABLE data;

SQLite 一键建表 SQL

下列 SQL 需要依赖 SQLite Shell 的 .import --csv，核心 SQLite 库不提供此功能。

因此，需要使用命令行的 SQLite 来运行（Windows 可去官网下载个 1~2 MB 的 sqlite3.exe）。

下面使用 Bash Shell 来包装执行命令与 SQL，大约需要运行 30 秒，然后在同目录下生成 150 MB 左右的 test.db。

#!/bin/bash

sqlite3 :memory: <<'EOF'

-- 在内存中计算，最后整理紧凑才写入文件
PRAGMA TEMP_STORE = MEMORY;

-- 导入 csv 文件至临时表
CREATE TEMP TABLE csv (code INTEGER PRIMARY KEY, name TEXT, type INT, p_code INT);
.import --csv area_code_2022.csv csv

-- 建邻接表
CREATE TABLE adjacent (
    id      INT     NOT NULL,
    pid     INT     NOT NULL,
    is_leaf INT     NOT NULL,
    type    INT     NOT NULL,
    code    INT     NOT NULL,
    name    TEXT    NOT NULL,
    PRIMARY KEY (pid, id)
) WITHOUT ROWID;

-- 填充邻接表
INSERT INTO adjacent (pid, id, is_leaf, type, code, name)
SELECT -1, 0, FALSE, 0, 0, ""
 UNION ALL
SELECT p_code, ROW_NUMBER() OVER (), type = 5, type, code, name
  FROM csv
 ORDER BY code;

-- 建临时索引，提速 code 搜索
CREATE INDEX i ON adjacent (code);

-- 更新 pid
UPDATE adjacent
   SET pid = t2.id
  FROM adjacent t2
 WHERE adjacent.pid = t2.code;

-- 丢弃临时索引
DROP INDEX i;

-- 建 id -> pid 索引
CREATE INDEX idx_adjacent_id ON adjacent (id);

-- 建闭包表主表
CREATE TABLE closure (
    id      INTEGER PRIMARY KEY,
    type    INT     NOT NULL,
    code    INT     NOT NULL,
    name    TEXT    NOT NULL
);

-- 建闭包表树形关系表
CREATE TABLE closure_tree (
    ancestor    INT NOT NULL,
    descendant  INT NOT NULL,
    distance    INT NOT NULL,
    PRIMARY KEY (descendant, distance)
) WITHOUT ROWID;

-- 填充闭包表主表
INSERT INTO closure (id, type, code, name)
SELECT id, type, code, name
  FROM adjacent;

-- 递归构建树形关系
WITH RECURSIVE
  parent_of(orig_id, id, dist) AS (
    SELECT id, id, 0
      FROM adjacent
     UNION ALL
    SELECT orig_id, pid, dist + 1
      FROM parent_of
      JOIN adjacent USING(id)
     WHERE id
  )
INSERT INTO closure_tree (ancestor, descendant, distance)
SELECT id, orig_id, dist
  FROM parent_of;

-- 为闭包表树形关系表建二级索引
CREATE INDEX idx_closure_tree ON closure_tree (ancestor, distance);

-- 整理紧实数据库后，写入磁盘
ANALYZE;
VACUUM INTO 'test.db';

EOF