企业官网建设流程全解析

简介：面向需要本地化行政区划底座的开发者、后端工程师与数据分析人员，这份全国五级行政区划数据集覆盖省、市、区县、乡镇及村委会层级，合计近77万条记录，可用于地图定位、分级统计、物流配送与电商本地化等场景。压缩包为rar格式，内含1个SQL文件，大小约7.97MB，借助建表DDL与批量INSERT语句组织数据，可在MySQL等关系型数据库中快速创建并填充行政区划表，减少手工整理成本。目前已有1074人学习下载，页面热度从侧面反映其在地址库、地域维表与业务测试数据搭建中的参考价值。数据按省、市、区县、乡镇、村分层存储，可直接作为地域维表，支撑按行政区划聚合统计、地址选择、范围筛选与多源数据关联；近77万条的规模既能满足快速搭建测试环境的需要，也便于后续依据区划调整进行增量维护。

1. 六级地区数据不是多一张表：77万条行政区划先看层级

做地址库的人搜“六级地区数据”时，十有八九会被一堆层级表绕晕：省、市、区县、乡镇、村委会到底存几张表，parent_code 怎么挂，村委会这一级要不要单独拆。这份全国5级行政区划数据把省、市、区县、乡镇、村委会的父子关系一次性摊开，规模将近77万条，解决的是地址下拉联动、CRM 区域字段、物流面单和区域统计里最烦的层级拼装问题。它适合两类人：新手拿它照着建表、导入、查子级就能跑通；熟手重点看编码长度、孤儿节点、省直辖层级跳级和缓存边界。别急着全量塞进前端，先想清楚你要的是五级主表，还是“六级地区数据”的查询视角。

2. 层级模型与字段设计：五级数据为什么要留冗余列

2.1 先定父子关系：parent_code 比 level 更可靠

行政区划数据最常见的结构是邻接表：每条记录有一个唯一编码 code，一个父级编码 parent_code，再用 level 标记层级。省、市、区县、乡镇、村委会五级依次是 1 到 5，顶级节点的 parent_code 用0或空串表示。这里不要犯一个常见错误：把 level 当成唯一真相，然后用“子级 level 必须等于父级 level + 1”去硬校验。实际数据里存在父级不是严格上一级的情况，比如某些县级单位直接挂在省级下面，level 从 1 跳到 3。业务上要允许这种跳级，否则导入校验会误杀。

字段设计我一般会留冗余列，不是为了好看，是为了少写递归。下面这张表是常见落库结构，实际字段名以你拿到的数据为准，导入前先抽样确认。

建表 SQL 可以这样写，PostgreSQL 和 MySQL 的差异主要在自增类型和部分索引语法，核心字段别省。

CREATE TABLE region ( id BIGSERIAL PRIMARY KEY, code VARCHAR(32) NOT NULL, name VARCHAR(128) NOT NULL, parent_code VARCHAR(32) NOT NULL DEFAULT '0', level SMALLINT NOT NULL, full_name VARCHAR(512), full_code VARCHAR(256), sort_order INT DEFAULT 0, status SMALLINT DEFAULT 1, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE UNIQUE INDEX uk_region_code ON region(code); CREATE INDEX idx_region_parent ON region(parent_code, level, sort_order); CREATE INDEX idx_region_level ON region(level);

这段 SQL 的关键点在两个地方：code用VARCHAR(32)而不是CHAR(6)，因为乡镇和村委会一级的编码长度不一定还是六位，拿六位去截断是后面最常见的翻车点；idx_region_parent把 parent_code、level、sort_order 放在一个联合索引里，下拉联动查“某个父级下的直接子级”时能直接命中。status先留着，后面做失效数据兼容时不用改表。

2.2 冗余全路径：用一次写入换掉高频递归

很多项目一开始只存 code、name、parent_code，查“示例省A / 示例市B / 示例区C”这种全路径时临时递归，数据量小的时候没感觉，到了77万条、接口 QPS 一上来就开始慢。我的做法是在导入阶段就把 full_name 和 full_code 算好，查询时直接按 code 取。全路径的分隔符不要用逗号，名称里可能出现逗号，常见做法是用/或-，自己统一就行。

下面这段 Python 用来从原始行生成全路径，同时防环。实际字段名按你的表头改。

import csv rows = list(csv.DictReader(open("region_raw.csv", encoding="utf-8"))) by_code = {r["code"]: r for r in rows} def build_path(code, seen=None): """返回 (名称路径列表, 编码路径列表)，发现环直接抛错""" if seen is None: seen = set() if code in seen: raise ValueError(f"发现父子环: {code}") seen.add(code) row = by_code.get(code) if not row: return [], [] parent = row.get("parent_code") or "0" if parent == "0" or parent not in by_code: return [row["name"]], [row["code"]] p_names, p_codes = build_path(parent, seen) return p_names + [row["name"]], p_codes + [row["code"]] for r in rows: names, codes = build_path(r["code"]) r["full_name"] = " / ".join(names) r["full_code"] = "-".join(codes) with open("region_clean.csv", "w", encoding="utf-8", newline="") as f: writer = csv.DictWriter(f, fieldnames=rows[0].keys()) writer.writeheader() writer.writerows(rows)

逻辑说明：by_code是编码到行的字典，递归向上找父级，直到 parent_code 为0或找不到父级为止。seen用来检测环，行政区划数据正常不会有环，但清洗阶段遇到脏数据时，这段能让你快速定位而不是栈溢出。参数上，分隔符可以改，seen不要省；如果数据量再大，递归深度有限，五级最多五次，不会爆栈。注意：找不到父级的节点不要直接丢掉，先打日志，后面按孤儿节点处理。

2.3 导入前先抽样：字段映射比建表更容易错

拿到压缩包后不要直接全量灌库，先抽 200 行看表头。常见字段叫法有code、id、region_code，父级叫parent_code、pid、parent_id，层级叫level、type、region_level。名称字段也可能带“全称”“简称”两列。先做列名映射，再决定哪一列进 code。抽样时重点看四件事：编码长度分布、parent_code 是否有空值、level 的取值集合、名称里有没有前后空格。下面这段只读前 200 行做体检。

import csv from collections import Counter with open("region_raw.csv", encoding="utf-8") as f: reader = csv.DictReader(f) sample = [next(reader) for _ in range(200)] print("列名:", sample[0].keys()) print("编码长度:", Counter(len(r.get("code", "").strip()) for r in sample)) print("层级取值:", Counter(r.get("level", "").strip() for r in sample)) print("父级空值:", sum(1 for r in sample if not r.get("parent_code", "").strip()))

这段代码不写库，只做字段体检。Counter看编码长度分布，如果出现 6 位、9 位、12 位混在一起，说明你的 VARCHAR 长度不能卡太死；level取值集合能确认层级编码是数字还是字母；父级空值数量决定顶级节点用0还是空串。抽样阶段发现字段对不上，比全量导入后再回滚省事得多。

提示：先抽 200 行确认字段名和编码长度，再全量导入；不要拿“看起来像六位”的编码去设计表结构。

3. 导入与清洗：把77万条数据平稳灌进数据库的四个动作

3.1 统一编码和列名：先清洗再入库

原始数据常见的坑是编码不统一：有的文件是 UTF-8，有的是带 BOM 的 UTF-8，有的从表格软件导出后变成 GBK。直接读会报UnicodeDecodeError，或者第一列列名前面带一个不可见字符。我一般先做一次转码和列名映射，输出一份干净的 CSV，再进数据库。下面这段带编码探测和列名映射，字段名按你的实际表头改。

import csv from pathlib import Path raw = Path("region_raw.csv") text = None for enc in ("utf-8-sig", "utf-8", "gb18030"): try: text = raw.read_text(encoding=enc) print("使用编码:", enc) break except UnicodeDecodeError: continue if text is None: raise RuntimeError("编码探测失败，请手动确认文件编码") reader = csv.DictReader(text.splitlines()) mapping = { "region_code": "code", "region_name": "name", "pid": "parent_code", "region_level": "level", } clean_rows = [] for row in reader: item = {mapping.get(k, k): (v or "").strip() for k, v in row.items()} if not item.get("code") or not item.get("name"): continue item["parent_code"] = item.get("parent_code") or "0" item["level"] = int(item.get("level") or 0) item["sort_order"] = int(item.get("sort_order") or 0) item["status"] = 1 clean_rows.append(item) with open("region_clean.csv", "w", encoding="utf-8", newline="") as f: writer = csv.DictWriter(f, fieldnames=clean_rows[0].keys()) writer.writeheader() writer.writerows(clean_rows)

这段的逻辑是：先按候选编码读全文，读成功就停；mapping把原始列名映射到统一字段名，映射不到的原样保留；空 code 或空 name 的行直接跳过，避免后面主键冲突；parent_code 空值统一成0；level 和 sort_order 转整数，失败会直接报错，早报比晚报好。参数上，utf-8-sig放第一位是为了吃掉 BOM，gb18030覆盖常见中文表格导出编码。注意：跳过脏行时最好写日志，不要静默丢数据。

3.2 批量导入：COPY 比一条条 INSERT 快一个数量级

77万条数据用逐条 INSERT 也能跑，但你会等很久，而且事务日志膨胀。PostgreSQL 下我一般用COPY，MySQL 下用LOAD DATA，核心思路是批量。下面以 PostgreSQL 的psycopg2为例，建表后先清空再灌，适合首次导入。

import psycopg2 conn = psycopg2.connect( host="127.0.0.1", port=5432, dbname="region_db", user="region_user", password="region_pass" ) conn.autocommit = False cur = conn.cursor() try: cur.execute("TRUNCATE TABLE region RESTART IDENTITY;") with open("region_clean.csv", encoding="utf-8") as f: cur.copy_expert( "COPY region(code,name,parent_code,level,full_name,full_code,sort_order,status) " "FROM STDIN WITH (FORMAT CSV, HEADER TRUE)", f ) conn.commit() print("导入完成") except Exception as e: conn.rollback() print("导入失败，已回滚:", e) raise finally: cur.close() conn.close()

逻辑说明：autocommit = False让整个导入在一个事务里，失败可以回滚；TRUNCATE ... RESTART IDENTITY只在首次导入或确认可清空时用，生产环境不要随便执行；copy_expert直接把 CSV 流给数据库，比 Python 逐行拼 INSERT 快很多。参数上，FORMAT CSV, HEADER TRUE表示文件有表头，列顺序要和 COPY 里写的一致；如果 CSV 带引号、换行，COPY 也能处理。注意：如果表里已有业务数据，不要用 TRUNCATE，改成导入临时表再合并。

3.3 导入后校验：重复、孤儿、层级异常一次查清

导入完成不等于数据可用。我通常会跑三类校验：code 是否重复、parent_code 是否存在、层级是否异常。下面这组 SQL 可以直接抄，把region换成你的表名。

-- 1. 重复编码 SELECT code, COUNT(*) AS cnt FROM region GROUP BY code HAVING COUNT(*) > 1 ORDER BY cnt DESC LIMIT 20; -- 2. 孤儿节点：父级编码在表里找不到 SELECT r.code, r.name, r.parent_code, r.level FROM region r LEFT JOIN region p ON r.parent_code = p.code WHERE r.parent_code <> '0' AND p.code IS NULL LIMIT 50; -- 3. 层级取值分布 SELECT level, COUNT(*) AS cnt FROM region GROUP BY level ORDER BY level; -- 4. 编码长度分布 SELECT LENGTH(code) AS code_len, COUNT(*) AS cnt FROM region GROUP BY LENGTH(code) ORDER BY code_len;

第一类查重复，重复 code 会让唯一索引建不上，也会让按 code 反查时出现多条。第二类查孤儿，常见原因是父级数据缺失、parent_code 前后空格、顶级节点用了空串而不是0。第三类和第四类看分布，level 如果出现 0 或 6，说明字段映射或原始数据有异常；编码长度分布能直接暴露“是不是有人把村级编码截断了”。校验结果不要只看数量，抽几条具体记录看名称和父级路径，比盯总数有用。

4. 查询与联动：按parent_code取子级、拼全路径、做缓存

4.1 下拉联动只查直接子级，不要一次拉全量

地址下拉最常见的错误是前端初始化时把77万条全量拉下来，浏览器内存直接上去，首屏白屏。正确做法是按 parent_code 逐级查：初始化查 parent_code =0的省级列表，用户选省后再查该省下的市，依次往下。SQL 很简单，关键是索引要命中。

SELECT code, name, level FROM region WHERE parent_code = %s AND status = 1 ORDER BY sort_order, code LIMIT %s OFFSET %s;

这条 SQL 的参数有三个：parent_code是当前选中的父级编码，LIMIT控制单次返回条数，OFFSET做分页。省级和市级数据量小，可能一次返回几十条；乡镇和村委会一级数据量大，必须分页或加关键字搜索。索引(parent_code, level, sort_order)能让这条查询走索引，不要只给 parent_code 建单列索引，排序时还会回表。前端调用时把 parent 编码做encodeURIComponent，避免特殊字符出问题。

async function loadChildren(parentCode, page = 1) { const url = `/api/regions/children?parent=${encodeURIComponent(parentCode)}&page=${page}`; const resp = await fetch(url); if (!resp.ok) throw new Error("加载子级失败"); const data = await resp.json(); return data.items; }

这段前端代码只做一件事：按父级编码请求直接子级，不在浏览器里做全量过滤。page参数给分页留口子，items是后端返回的当前页列表。注意：不要把parentCode拼进 SQL 字符串，后端必须用参数化查询；前端也不要缓存所有层级的完整树，缓存当前展开路径就够了。

4.2 全路径查询用冗余列，批量反查别逐条递归

用户输入的地址往往是一整串，比如“示例省A / 示例市B / 示例区C”。如果只存了 code 和 parent_code，反查编码时得逐级拆名称，遇到重名就翻车。前面导入时算了 full_name，这里可以直接用。查询时先用全路径精确匹配，匹配不到再降级按名称加父级匹配。

-- 精确匹配全路径 SELECT code, name, level, full_name FROM region WHERE full_name = %s AND status = 1 LIMIT 10; -- 只知道末级名称时，带上父级名称缩小范围 SELECT code, name, level, full_name FROM region WHERE name = %s AND full_name LIKE %s AND status = 1 LIMIT 20;

第一段用 full_name 精确匹配，适合前端已经存了完整路径的场景；第二段用末级名称加全路径前缀，适合用户只输入“示例村E”但你知道大概在哪个区县。参数%s分别传完整路径和%父级路径%。注意：LIKE前面的%会让索引失效，数据量大时尽量用前缀匹配，或者把全路径拆成独立字段做等值查询。批量反查时不要循环里一条条查库，用IN或临时表。

def batch_full_name(codes, cursor): if not codes: return {} placeholders = ",".join(["%s"] * len(codes)) sql = f"SELECT code, full_name FROM region WHERE code IN ({placeholders})" cursor.execute(sql, codes) return {code: full_name for code, full_name in cursor.fetchall()}

这段批量反查把编码列表一次传给数据库，返回 code 到 full_name 的字典。参数codes是编码列表，placeholders根据列表长度动态生成，避免 SQL 注入。注意：列表特别大时（比如几千个）要分批，每批 500 到 1000 个，别让 SQL 语句过长。

4.3 缓存按 parent_code 做，不要缓存整棵树

77万条数据里，省级和市级变化很少，乡镇和村级查询频率高但单次结果不大。我一般用进程内缓存加短过期，缓存 key 用 parent_code，缓存 value 是直接子级列表。不要缓存整棵树，序列化和反序列化成本高，数据更新时也不好失效。

from functools import lru_cache @lru_cache(maxsize=4096) def get_children(parent_code): # 这里替换成你的数据库查询 cur.execute( "SELECT code, name, level FROM region " "WHERE parent_code = %s AND status = 1 " "ORDER BY sort_order, code", (parent_code,) ) return cur.fetchall()

lru_cache的maxsize=4096控制缓存条目数，按 parent_code 做 key，命中率高的省级、市级父级会留在内存里。参数上，maxsize 不要设太大，77万条全放进去会吃内存；缓存失效可以靠重启进程或加版本号，数据更新频繁时换成带 TTL 的缓存。注意：数据库连接不要放进缓存函数里长期持有，连接池和缓存分开管理。

5. 避坑与排查：77万条行政区划数据最容易翻车的五个点

5.1 坑一：把行政区划代码当定长六位，村级数据直接截断

现象：导入后村级记录少了一截，或者编码后面几位变成空，按 code 反查不到。原因：建表时用了CHAR(6)或代码里code[:6]，但乡镇、村委会一级的编码长度不止六位。解决：字段长度放宽到 32，导入前先看长度分布，禁止截断。

SELECT LENGTH(code) AS code_len, COUNT(*) AS cnt FROM region GROUP BY LENGTH(code) ORDER BY code_len;

这条 SQL 直接看编码长度分布。如果只有一种长度，反而要警惕是不是已经被截断过；正常五级数据至少存在多种长度。参数不用传，跑完看结果，村级长度明显更长。发现长度异常，回到原始文件重新导，不要试图在库里补零，补错了更麻烦。

5.2 坑二：只按名称匹配，重名乡镇和村委会导致父子错挂

现象：用户选“示例镇D”，系统返回了另一个同名镇的下级村；或者地址反查时命中多条，取第一条后全路径不对。原因：名称不是唯一键，乡镇和村级重名很常见，只按 name 查询必然出问题。解决：所有关联查询都带 code 或 parent_code，名称只做展示和模糊搜索。

SELECT name, COUNT(*) AS cnt FROM region GROUP BY name HAVING COUNT(*) > 1 ORDER BY cnt DESC LIMIT 20;

这条查重名分布，结果里数量多的名称不要拿来当唯一键。正确做法是前端下拉的 value 用 code，显示用 name；后端反查时用 code 精确匹配，或者用 full_name 加父级路径缩小范围。注意：不要给 name 建唯一索引，建了会导入失败。

5.3 坑三：一次性查全量做前端联动，首屏卡死

现象：页面打开后下拉框转圈，浏览器内存飙升，移动端直接崩。原因：初始化接口把 77万条全量返回，前端再在本地过滤层级。解决：按 parent_code 逐级请求，单次限制条数，村级加关键字搜索。

SELECT code, name FROM region WHERE parent_code = %s AND status = 1 ORDER BY sort_order, code LIMIT 100 OFFSET 0;

这条查询只取直接子级，LIMIT 100防止某个父级下数据过多撑爆响应。参数parent_code从上一级选中的 code 传进来。村级数据量大时，把LIMIT调到 50 到 100，配合搜索框按名称前缀查。注意：不要用SELECT *，只返回前端需要的 code 和 name。

5.4 坑四：导入时未关自动提交，77万条写入慢到怀疑人生

现象：逐条 INSERT 跑了很久还没完，磁盘 IO 一直高，事务日志膨胀。原因：每条 INSERT 自动提交，每次都要刷盘。解决：批量提交或 COPY，事务包住整批，失败回滚。

conn.autocommit = False cur = conn.cursor() batch = [] for row in rows: batch.append(row) if len(batch) >= 1000: cur.executemany( "INSERT INTO region(code,name,parent_code,level) VALUES (%s,%s,%s,%s)", batch ) conn.commit() batch.clear()

这段用executemany每 1000 条提交一次，比逐条快很多；如果数据库支持 COPY，优先用 COPY。参数1000是批大小，太大内存高，太小提交次数多，按机器调整。注意：批量提交失败时，最后一批要单独处理，别把半批数据留在内存里。

5.5 坑五：忽略失效和变更数据，历史地址对不上

现象：业务表里存了旧编码，新数据里查不到；或者同一个名称对应了新旧两个 code。原因：行政区划会调整，数据包只给当前有效版本，历史编码没有保留。解决：加 status 字段，导入时标记有效状态；业务表存 code 的同时留一份 full_name 快照，不要只存 code。

ALTER TABLE region ADD COLUMN IF NOT EXISTS status SMALLINT DEFAULT 1; UPDATE region SET status = 0 WHERE code IN ( SELECT code FROM region_old );

这段演示用 status 标记失效，实际导入时按数据包里的状态字段来。业务侧查询默认加status = 1，历史订单展示用快照字段。注意：不要物理删除旧编码，删了之后历史数据回查会断链，留 status 比留后悔药便宜。

6. 验证与进阶：用递归CTE和抽样对账把数据用稳

6.1 递归CTE校验全路径，别让冗余列变成黑匣子

full_name 是导入时算的，算错了后面全错。我会用递归 CTE 从根节点往下走一遍，和表里的 full_name 做对比，抽样看差异。下面这段 PostgreSQL 递归 CTE 从顶级节点开始拼路径，限制深度 6 层，防止脏数据导致无限递归。

WITH RECURSIVE tree AS ( SELECT code, name, parent_code, level, name::text AS path_name, 1 AS depth FROM region WHERE parent_code = '0' UNION ALL SELECT r.code, r.name, r.parent_code, r.level, t.path_name || ' / ' || r.name, t.depth + 1 FROM region r JOIN tree t ON r.parent_code = t.code WHERE t.depth < 6 ) SELECT t.code, t.path_name, r.full_name FROM tree t JOIN region r ON r.code = t.code WHERE t.path_name <> r.full_name LIMIT 50;

这段 CTE 的锚点是 parent_code =0的顶级节点，递归部分按 parent_code 关联子级，depth < 6限制最多六层，避免环导致查询跑不完。最后拿递归算出的 path_name 和表里的 full_name 对比，有差异就抽样看是哪一级拼错了。参数上，分隔符要和导入时一致，深度按你的数据层级调整；如果顶级节点不是0，锚点条件要改。

6.2 抽样对账：给业务方一份能核对的清单

数据导入后，业务方最常问“这个村怎么查不到”。我一般抽 200 条，按层级分层抽样，导出 code、name、full_name、parent_code 四列，让对方随机点几条核对。下面这段 Python 从数据库抽样并导出 CSV。

import csv import psycopg2 conn = psycopg2.connect("dbname=region_db user=region_user password=region_pass host=127.0.0.1") cur = conn.cursor() cur.execute(""" SELECT code, name, parent_code, level, full_name FROM region WHERE status = 1 ORDER BY random() LIMIT 200 """) rows = cur.fetchall() with open("region_sample_check.csv", "w", encoding="utf-8", newline="") as f: writer = csv.writer(f) writer.writerow(["code", "name", "parent_code", "level", "full_name"]) writer.writerows(rows)

ORDER BY random()在 77万条数据上会扫全表，抽样一次可以接受，频繁跑就换成按 id 区间随机。导出后重点看全路径是否连续、parent_code 是否能在表里找到父级。业务方核对过的样本，比你自己盯 SQL 结果更有说服力。

6.3 一个具体技巧：把“六级地区数据”做成查询视图

有人搜“六级地区数据”，想要的是省、市、区县、乡镇、村/社区六级展示。手里这份是五级主表，不必再复制一份 77万条的数据，建一个视图把层级标签和路径拼出来就能满足查询视角。下面这个视图给每级打标签，业务查询直接按 level_label 过滤。

CREATE VIEW region_level_view AS SELECT code, name, parent_code, level, full_name, CASE level WHEN 1 THEN '省级' WHEN 2 THEN '市级' WHEN 3 THEN '区县级' WHEN 4 THEN '乡镇级' WHEN 5 THEN '村/社区级' ELSE '其他' END AS level_label FROM region WHERE status = 1;

这个视图不存数据，只做展示层映射。查询“某个省下面所有层级”时，可以按 full_name 前缀加 level_label 过滤；做统计时按 level 分组。参数上，level 的枚举值要和你导入的数据一致，如果实际数据用 0 表示省，改 CASE 就行。注意：视图不要嵌套太多层，否则查询计划会变复杂，简单映射就够。

血泪经验是，拿到行政区划数据后先别急着写接口，先跑一遍编码长度分布、孤儿节点、抽样全路径这三件事。从那以后我每次导入这类数据都强制走一遍校验，宁可导入慢十分钟，也不要在业务查询里补窟窿。需要这份数据的话，拿到包后先按上面的字段体检和校验跑一遍，再决定全量入库还是先做子集。希望帮到你。

本文还有配套的精品资源，点击获取