532 lines
21 KiB
Python
532 lines
21 KiB
Python
"""
|
||
检查模板的 file_id 和相关关联关系是否正确
|
||
重点检查：
|
||
1. f_polic_file_config 表中的模板记录（file_id）
|
||
2. f_polic_file_field 表中的关联关系（file_id 和 filed_id 的对应关系）
|
||
"""
|
||
import sys
|
||
import pymysql
|
||
from pathlib import Path
|
||
from typing import Dict, List, Set, Tuple
|
||
from collections import defaultdict
|
||
|
||
# 设置控制台编码为UTF-8（Windows兼容）
|
||
if sys.platform == 'win32':
|
||
try:
|
||
sys.stdout.reconfigure(encoding='utf-8')
|
||
sys.stderr.reconfigure(encoding='utf-8')
|
||
except:
|
||
pass
|
||
|
||
# 数据库连接配置
|
||
DB_CONFIG = {
|
||
'host': '152.136.177.240',
|
||
'port': 5012,
|
||
'user': 'finyx',
|
||
'password': '6QsGK6MpePZDE57Z',
|
||
'database': 'finyx',
|
||
'charset': 'utf8mb4'
|
||
}
|
||
|
||
# 固定值
|
||
TENANT_ID = 615873064429507639
|
||
|
||
# 项目根目录
|
||
PROJECT_ROOT = Path(__file__).parent
|
||
TEMPLATES_DIR = PROJECT_ROOT / "template_finish"
|
||
|
||
# 文档类型映射（用于识别模板）
|
||
DOCUMENT_TYPE_MAPPING = {
|
||
"1.请示报告卡（XXX）": "REPORT_CARD",
|
||
"2.初步核实审批表（XXX）": "PRELIMINARY_VERIFICATION_APPROVAL",
|
||
"3.附件初核方案(XXX)": "INVESTIGATION_PLAN",
|
||
"谈话通知书第一联": "NOTIFICATION_LETTER_1",
|
||
"谈话通知书第二联": "NOTIFICATION_LETTER_2",
|
||
"谈话通知书第三联": "NOTIFICATION_LETTER_3",
|
||
"1.请示报告卡（初核谈话）": "REPORT_CARD_INTERVIEW",
|
||
"2谈话审批表": "INTERVIEW_APPROVAL_FORM",
|
||
"3.谈话前安全风险评估表": "PRE_INTERVIEW_RISK_ASSESSMENT",
|
||
"4.谈话方案": "INTERVIEW_PLAN",
|
||
"5.谈话后安全风险评估表": "POST_INTERVIEW_RISK_ASSESSMENT",
|
||
"1.谈话笔录": "INTERVIEW_RECORD",
|
||
"2.谈话询问对象情况摸底调查30问": "INVESTIGATION_30_QUESTIONS",
|
||
"3.被谈话人权利义务告知书": "RIGHTS_OBLIGATIONS_NOTICE",
|
||
"4.点对点交接单": "HANDOVER_FORM",
|
||
"4.点对点交接单2": "HANDOVER_FORM_2",
|
||
"5.陪送交接单（新）": "ESCORT_HANDOVER_FORM",
|
||
"6.1保密承诺书（谈话对象使用-非中共党员用）": "CONFIDENTIALITY_COMMITMENT_NON_PARTY",
|
||
"6.2保密承诺书（谈话对象使用-中共党员用）": "CONFIDENTIALITY_COMMITMENT_PARTY",
|
||
"7.办案人员-办案安全保密承诺书": "INVESTIGATOR_CONFIDENTIALITY_COMMITMENT",
|
||
"8-1请示报告卡（初核报告结论） ": "REPORT_CARD_CONCLUSION",
|
||
"8.XXX初核情况报告": "INVESTIGATION_REPORT"
|
||
}
|
||
|
||
|
||
def get_template_files() -> Dict[str, Path]:
|
||
"""获取所有模板文件"""
|
||
templates = {}
|
||
if not TEMPLATES_DIR.exists():
|
||
return templates
|
||
|
||
for root, dirs, files in os.walk(TEMPLATES_DIR):
|
||
for file in files:
|
||
if file.endswith('.docx') and not file.startswith('~$'):
|
||
file_path = Path(root) / file
|
||
base_name = Path(file).stem
|
||
if base_name in DOCUMENT_TYPE_MAPPING:
|
||
templates[base_name] = file_path
|
||
|
||
return templates
|
||
|
||
|
||
def check_file_configs(conn) -> Dict:
|
||
"""检查 f_polic_file_config 表中的模板记录"""
|
||
print("\n" + "="*80)
|
||
print("1. 检查 f_polic_file_config 表中的模板记录")
|
||
print("="*80)
|
||
|
||
cursor = conn.cursor(pymysql.cursors.DictCursor)
|
||
|
||
# 查询所有模板记录
|
||
cursor.execute("""
|
||
SELECT id, name, template_code, file_path, state, parent_id
|
||
FROM f_polic_file_config
|
||
WHERE tenant_id = %s
|
||
ORDER BY name
|
||
""", (TENANT_ID,))
|
||
|
||
all_configs = cursor.fetchall()
|
||
|
||
# 按 template_code 和 name 组织数据
|
||
configs_by_code = {}
|
||
configs_by_name = {}
|
||
|
||
for config in all_configs:
|
||
config_id = config['id']
|
||
name = config['name']
|
||
template_code = config.get('template_code')
|
||
|
||
if template_code:
|
||
if template_code not in configs_by_code:
|
||
configs_by_code[template_code] = []
|
||
configs_by_code[template_code].append(config)
|
||
|
||
if name:
|
||
if name not in configs_by_name:
|
||
configs_by_name[name] = []
|
||
configs_by_name[name].append(config)
|
||
|
||
print(f"\n总模板记录数: {len(all_configs)}")
|
||
print(f"按 template_code 分组: {len(configs_by_code)} 个不同的 template_code")
|
||
print(f"按 name 分组: {len(configs_by_name)} 个不同的 name")
|
||
|
||
# 检查重复的 template_code
|
||
duplicate_codes = {code: configs for code, configs in configs_by_code.items() if len(configs) > 1}
|
||
if duplicate_codes:
|
||
print(f"\n[WARN] 发现重复的 template_code ({len(duplicate_codes)} 个):")
|
||
for code, configs in duplicate_codes.items():
|
||
print(f" - {code}: {len(configs)} 条记录")
|
||
for cfg in configs:
|
||
print(f" ID: {cfg['id']}, 名称: {cfg['name']}, 路径: {cfg.get('file_path', 'N/A')}")
|
||
|
||
# 检查重复的 name
|
||
duplicate_names = {name: configs for name, configs in configs_by_name.items() if len(configs) > 1}
|
||
if duplicate_names:
|
||
print(f"\n[WARN] 发现重复的 name ({len(duplicate_names)} 个):")
|
||
for name, configs in duplicate_names.items():
|
||
print(f" - {name}: {len(configs)} 条记录")
|
||
for cfg in configs:
|
||
print(f" ID: {cfg['id']}, template_code: {cfg.get('template_code', 'N/A')}, 路径: {cfg.get('file_path', 'N/A')}")
|
||
|
||
# 检查未启用的记录
|
||
disabled_configs = [cfg for cfg in all_configs if cfg.get('state') != 1]
|
||
if disabled_configs:
|
||
print(f"\n[WARN] 发现未启用的模板记录 ({len(disabled_configs)} 个):")
|
||
for cfg in disabled_configs:
|
||
print(f" - ID: {cfg['id']}, 名称: {cfg['name']}, 状态: {cfg.get('state')}")
|
||
|
||
# 检查 file_path 为空的记录
|
||
empty_path_configs = [cfg for cfg in all_configs if not cfg.get('file_path')]
|
||
if empty_path_configs:
|
||
print(f"\n[WARN] 发现 file_path 为空的记录 ({len(empty_path_configs)} 个):")
|
||
for cfg in empty_path_configs:
|
||
print(f" - ID: {cfg['id']}, 名称: {cfg['name']}, template_code: {cfg.get('template_code', 'N/A')}")
|
||
|
||
cursor.close()
|
||
|
||
return {
|
||
'all_configs': all_configs,
|
||
'configs_by_code': configs_by_code,
|
||
'configs_by_name': configs_by_name,
|
||
'duplicate_codes': duplicate_codes,
|
||
'duplicate_names': duplicate_names,
|
||
'disabled_configs': disabled_configs,
|
||
'empty_path_configs': empty_path_configs
|
||
}
|
||
|
||
|
||
def check_file_field_relations(conn) -> Dict:
|
||
"""检查 f_polic_file_field 表中的关联关系"""
|
||
print("\n" + "="*80)
|
||
print("2. 检查 f_polic_file_field 表中的关联关系")
|
||
print("="*80)
|
||
|
||
cursor = conn.cursor(pymysql.cursors.DictCursor)
|
||
|
||
# 查询所有关联关系
|
||
cursor.execute("""
|
||
SELECT fff.id, fff.file_id, fff.filed_id, fff.state, fff.tenant_id
|
||
FROM f_polic_file_field fff
|
||
WHERE fff.tenant_id = %s
|
||
ORDER BY fff.file_id, fff.filed_id
|
||
""", (TENANT_ID,))
|
||
|
||
all_relations = cursor.fetchall()
|
||
|
||
print(f"\n总关联关系数: {len(all_relations)}")
|
||
|
||
# 检查无效的 file_id（关联到不存在的文件配置）
|
||
cursor.execute("""
|
||
SELECT fff.id, fff.file_id, fff.filed_id
|
||
FROM f_polic_file_field fff
|
||
LEFT JOIN f_polic_file_config fc ON fff.file_id = fc.id AND fff.tenant_id = fc.tenant_id
|
||
WHERE fff.tenant_id = %s AND fc.id IS NULL
|
||
""", (TENANT_ID,))
|
||
invalid_file_relations = cursor.fetchall()
|
||
|
||
# 检查无效的 filed_id（关联到不存在的字段）
|
||
cursor.execute("""
|
||
SELECT fff.id, fff.file_id, fff.filed_id
|
||
FROM f_polic_file_field fff
|
||
LEFT JOIN f_polic_field f ON fff.filed_id = f.id AND fff.tenant_id = f.tenant_id
|
||
WHERE fff.tenant_id = %s AND f.id IS NULL
|
||
""", (TENANT_ID,))
|
||
invalid_field_relations = cursor.fetchall()
|
||
|
||
# 检查重复的关联关系（相同的 file_id 和 filed_id）
|
||
cursor.execute("""
|
||
SELECT file_id, filed_id, COUNT(*) as count, GROUP_CONCAT(id ORDER BY id) as ids
|
||
FROM f_polic_file_field
|
||
WHERE tenant_id = %s
|
||
GROUP BY file_id, filed_id
|
||
HAVING COUNT(*) > 1
|
||
""", (TENANT_ID,))
|
||
duplicate_relations = cursor.fetchall()
|
||
|
||
# 检查关联到未启用文件的记录
|
||
cursor.execute("""
|
||
SELECT fff.id, fff.file_id, fff.filed_id, fc.name as file_name, fc.state as file_state
|
||
FROM f_polic_file_field fff
|
||
INNER JOIN f_polic_file_config fc ON fff.file_id = fc.id AND fff.tenant_id = fc.tenant_id
|
||
WHERE fff.tenant_id = %s AND fc.state != 1
|
||
""", (TENANT_ID,))
|
||
disabled_file_relations = cursor.fetchall()
|
||
|
||
# 检查关联到未启用字段的记录
|
||
cursor.execute("""
|
||
SELECT fff.id, fff.file_id, fff.filed_id, f.name as field_name, f.filed_code, f.state as field_state
|
||
FROM f_polic_file_field fff
|
||
INNER JOIN f_polic_field f ON fff.filed_id = f.id AND fff.tenant_id = f.tenant_id
|
||
WHERE fff.tenant_id = %s AND f.state != 1
|
||
""", (TENANT_ID,))
|
||
disabled_field_relations = cursor.fetchall()
|
||
|
||
# 统计每个文件关联的字段数量
|
||
file_field_counts = defaultdict(int)
|
||
for rel in all_relations:
|
||
file_field_counts[rel['file_id']] += 1
|
||
|
||
print(f"\n文件关联字段统计:")
|
||
print(f" 有关联关系的文件数: {len(file_field_counts)}")
|
||
if file_field_counts:
|
||
max_count = max(file_field_counts.values())
|
||
min_count = min(file_field_counts.values())
|
||
avg_count = sum(file_field_counts.values()) / len(file_field_counts)
|
||
print(f" 每个文件关联字段数: 最少 {min_count}, 最多 {max_count}, 平均 {avg_count:.1f}")
|
||
|
||
# 输出检查结果
|
||
if invalid_file_relations:
|
||
print(f"\n[ERROR] 发现无效的 file_id 关联 ({len(invalid_file_relations)} 条):")
|
||
for rel in invalid_file_relations[:10]: # 只显示前10条
|
||
print(f" - 关联ID: {rel['id']}, file_id: {rel['file_id']}, filed_id: {rel['filed_id']}")
|
||
if len(invalid_file_relations) > 10:
|
||
print(f" ... 还有 {len(invalid_file_relations) - 10} 条")
|
||
else:
|
||
print(f"\n[OK] 所有 file_id 关联都有效")
|
||
|
||
if invalid_field_relations:
|
||
print(f"\n[ERROR] 发现无效的 filed_id 关联 ({len(invalid_field_relations)} 条):")
|
||
for rel in invalid_field_relations[:10]: # 只显示前10条
|
||
print(f" - 关联ID: {rel['id']}, file_id: {rel['file_id']}, filed_id: {rel['filed_id']}")
|
||
if len(invalid_field_relations) > 10:
|
||
print(f" ... 还有 {len(invalid_field_relations) - 10} 条")
|
||
else:
|
||
print(f"\n[OK] 所有 filed_id 关联都有效")
|
||
|
||
if duplicate_relations:
|
||
print(f"\n[WARN] 发现重复的关联关系 ({len(duplicate_relations)} 组):")
|
||
for dup in duplicate_relations[:10]: # 只显示前10组
|
||
print(f" - file_id: {dup['file_id']}, filed_id: {dup['filed_id']}, 重复次数: {dup['count']}, 关联ID: {dup['ids']}")
|
||
if len(duplicate_relations) > 10:
|
||
print(f" ... 还有 {len(duplicate_relations) - 10} 组")
|
||
else:
|
||
print(f"\n[OK] 没有重复的关联关系")
|
||
|
||
if disabled_file_relations:
|
||
print(f"\n[WARN] 发现关联到未启用文件的记录 ({len(disabled_file_relations)} 条):")
|
||
for rel in disabled_file_relations[:10]:
|
||
print(f" - 文件: {rel['file_name']} (ID: {rel['file_id']}, 状态: {rel['file_state']})")
|
||
if len(disabled_file_relations) > 10:
|
||
print(f" ... 还有 {len(disabled_file_relations) - 10} 条")
|
||
|
||
if disabled_field_relations:
|
||
print(f"\n[WARN] 发现关联到未启用字段的记录 ({len(disabled_field_relations)} 条):")
|
||
for rel in disabled_field_relations[:10]:
|
||
print(f" - 字段: {rel['field_name']} ({rel['filed_code']}, ID: {rel['filed_id']}, 状态: {rel['field_state']})")
|
||
if len(disabled_field_relations) > 10:
|
||
print(f" ... 还有 {len(disabled_field_relations) - 10} 条")
|
||
|
||
cursor.close()
|
||
|
||
return {
|
||
'all_relations': all_relations,
|
||
'invalid_file_relations': invalid_file_relations,
|
||
'invalid_field_relations': invalid_field_relations,
|
||
'duplicate_relations': duplicate_relations,
|
||
'disabled_file_relations': disabled_file_relations,
|
||
'disabled_field_relations': disabled_field_relations,
|
||
'file_field_counts': dict(file_field_counts)
|
||
}
|
||
|
||
|
||
def check_template_file_mapping(conn, file_configs: Dict) -> Dict:
|
||
"""检查模板文件与数据库记录的映射关系"""
|
||
print("\n" + "="*80)
|
||
print("3. 检查模板文件与数据库记录的映射关系")
|
||
print("="*80)
|
||
|
||
import os
|
||
templates = get_template_files()
|
||
|
||
print(f"\n本地模板文件数: {len(templates)}")
|
||
|
||
cursor = conn.cursor(pymysql.cursors.DictCursor)
|
||
|
||
# 检查每个模板文件是否在数据库中有对应记录
|
||
missing_in_db = []
|
||
found_in_db = []
|
||
duplicate_mappings = []
|
||
|
||
for template_name, file_path in templates.items():
|
||
template_code = DOCUMENT_TYPE_MAPPING.get(template_name)
|
||
if not template_code:
|
||
continue
|
||
|
||
# 通过 name 和 template_code 查找对应的数据库记录
|
||
# 优先通过 name 精确匹配，然后通过 template_code 匹配
|
||
matching_configs = []
|
||
|
||
# 1. 通过 name 精确匹配
|
||
if template_name in file_configs['configs_by_name']:
|
||
for config in file_configs['configs_by_name'][template_name]:
|
||
if config.get('file_path'): # 有文件路径的记录
|
||
matching_configs.append(config)
|
||
|
||
# 2. 通过 template_code 匹配
|
||
if template_code in file_configs['configs_by_code']:
|
||
for config in file_configs['configs_by_code'][template_code]:
|
||
if config.get('file_path') and config not in matching_configs:
|
||
matching_configs.append(config)
|
||
|
||
if len(matching_configs) == 0:
|
||
missing_in_db.append({
|
||
'template_name': template_name,
|
||
'template_code': template_code,
|
||
'file_path': str(file_path)
|
||
})
|
||
elif len(matching_configs) == 1:
|
||
config = matching_configs[0]
|
||
found_in_db.append({
|
||
'template_name': template_name,
|
||
'template_code': template_code,
|
||
'file_id': config['id'],
|
||
'file_path': config.get('file_path'),
|
||
'name': config.get('name')
|
||
})
|
||
else:
|
||
# 多个匹配，选择 file_path 最新的（包含最新日期的）
|
||
duplicate_mappings.append({
|
||
'template_name': template_name,
|
||
'template_code': template_code,
|
||
'matching_configs': matching_configs
|
||
})
|
||
# 仍然记录第一个作为找到的记录
|
||
config = matching_configs[0]
|
||
found_in_db.append({
|
||
'template_name': template_name,
|
||
'template_code': template_code,
|
||
'file_id': config['id'],
|
||
'file_path': config.get('file_path'),
|
||
'name': config.get('name'),
|
||
'is_duplicate': True
|
||
})
|
||
|
||
print(f"\n找到数据库记录的模板: {len(found_in_db)}")
|
||
print(f"未找到数据库记录的模板: {len(missing_in_db)}")
|
||
print(f"有重复映射的模板: {len(duplicate_mappings)}")
|
||
|
||
if duplicate_mappings:
|
||
print(f"\n[WARN] 以下模板文件在数据库中有多个匹配记录:")
|
||
for item in duplicate_mappings:
|
||
print(f" - {item['template_name']} (template_code: {item['template_code']}):")
|
||
for cfg in item['matching_configs']:
|
||
print(f" * file_id: {cfg['id']}, name: {cfg.get('name')}, path: {cfg.get('file_path', 'N/A')}")
|
||
|
||
if missing_in_db:
|
||
print(f"\n[WARN] 以下模板文件在数据库中没有对应记录:")
|
||
for item in missing_in_db:
|
||
print(f" - {item['template_name']} (template_code: {item['template_code']})")
|
||
|
||
cursor.close()
|
||
|
||
return {
|
||
'found_in_db': found_in_db,
|
||
'missing_in_db': missing_in_db,
|
||
'duplicate_mappings': duplicate_mappings
|
||
}
|
||
|
||
|
||
def check_field_type_consistency(conn, relations: Dict) -> Dict:
|
||
"""检查关联关系的字段类型一致性"""
|
||
print("\n" + "="*80)
|
||
print("4. 检查关联关系的字段类型一致性")
|
||
print("="*80)
|
||
|
||
cursor = conn.cursor(pymysql.cursors.DictCursor)
|
||
|
||
# 查询所有关联关系及其字段类型
|
||
cursor.execute("""
|
||
SELECT
|
||
fff.id,
|
||
fff.file_id,
|
||
fff.filed_id,
|
||
fc.name as file_name,
|
||
f.name as field_name,
|
||
f.filed_code,
|
||
f.field_type,
|
||
CASE
|
||
WHEN f.field_type = 1 THEN '输入字段'
|
||
WHEN f.field_type = 2 THEN '输出字段'
|
||
ELSE '未知'
|
||
END as field_type_name
|
||
FROM f_polic_file_field fff
|
||
INNER JOIN f_polic_file_config fc ON fff.file_id = fc.id AND fff.tenant_id = fc.tenant_id
|
||
INNER JOIN f_polic_field f ON fff.filed_id = f.id AND fff.tenant_id = f.tenant_id
|
||
WHERE fff.tenant_id = %s
|
||
ORDER BY fff.file_id, f.field_type, f.name
|
||
""", (TENANT_ID,))
|
||
|
||
all_relations_with_type = cursor.fetchall()
|
||
|
||
# 统计字段类型分布
|
||
input_fields = [r for r in all_relations_with_type if r['field_type'] == 1]
|
||
output_fields = [r for r in all_relations_with_type if r['field_type'] == 2]
|
||
|
||
print(f"\n字段类型统计:")
|
||
print(f" 输入字段 (field_type=1): {len(input_fields)} 条关联")
|
||
print(f" 输出字段 (field_type=2): {len(output_fields)} 条关联")
|
||
|
||
# 按文件统计
|
||
file_type_counts = defaultdict(lambda: {'input': 0, 'output': 0})
|
||
for rel in all_relations_with_type:
|
||
file_id = rel['file_id']
|
||
if rel['field_type'] == 1:
|
||
file_type_counts[file_id]['input'] += 1
|
||
elif rel['field_type'] == 2:
|
||
file_type_counts[file_id]['output'] += 1
|
||
|
||
print(f"\n每个文件的字段类型分布:")
|
||
for file_id, counts in sorted(file_type_counts.items())[:10]: # 只显示前10个
|
||
print(f" 文件ID {file_id}: 输入字段 {counts['input']} 个, 输出字段 {counts['output']} 个")
|
||
if len(file_type_counts) > 10:
|
||
print(f" ... 还有 {len(file_type_counts) - 10} 个文件")
|
||
|
||
cursor.close()
|
||
|
||
return {
|
||
'input_fields': input_fields,
|
||
'output_fields': output_fields,
|
||
'file_type_counts': dict(file_type_counts)
|
||
}
|
||
|
||
|
||
def main():
|
||
"""主函数"""
|
||
print("="*80)
|
||
print("检查模板的 file_id 和相关关联关系")
|
||
print("="*80)
|
||
|
||
# 连接数据库
|
||
try:
|
||
conn = pymysql.connect(**DB_CONFIG)
|
||
print("\n[OK] 数据库连接成功")
|
||
except Exception as e:
|
||
print(f"\n[ERROR] 数据库连接失败: {e}")
|
||
return
|
||
|
||
try:
|
||
# 1. 检查文件配置表
|
||
file_configs = check_file_configs(conn)
|
||
|
||
# 2. 检查文件字段关联表
|
||
relations = check_file_field_relations(conn)
|
||
|
||
# 3. 检查模板文件与数据库记录的映射
|
||
template_mapping = check_template_file_mapping(conn, file_configs)
|
||
|
||
# 4. 检查字段类型一致性
|
||
field_type_info = check_field_type_consistency(conn, relations)
|
||
|
||
# 汇总报告
|
||
print("\n" + "="*80)
|
||
print("检查汇总")
|
||
print("="*80)
|
||
|
||
issues = []
|
||
|
||
if file_configs['duplicate_codes']:
|
||
issues.append(f"发现 {len(file_configs['duplicate_codes'])} 个重复的 template_code")
|
||
if file_configs['duplicate_names']:
|
||
issues.append(f"发现 {len(file_configs['duplicate_names'])} 个重复的 name")
|
||
if file_configs['empty_path_configs']:
|
||
issues.append(f"发现 {len(file_configs['empty_path_configs'])} 个 file_path 为空的记录")
|
||
if relations['invalid_file_relations']:
|
||
issues.append(f"发现 {len(relations['invalid_file_relations'])} 条无效的 file_id 关联")
|
||
if relations['invalid_field_relations']:
|
||
issues.append(f"发现 {len(relations['invalid_field_relations'])} 条无效的 filed_id 关联")
|
||
if relations['duplicate_relations']:
|
||
issues.append(f"发现 {len(relations['duplicate_relations'])} 组重复的关联关系")
|
||
if template_mapping['missing_in_db']:
|
||
issues.append(f"发现 {len(template_mapping['missing_in_db'])} 个模板文件在数据库中没有对应记录")
|
||
|
||
if issues:
|
||
print("\n[WARN] 发现以下问题:")
|
||
for issue in issues:
|
||
print(f" - {issue}")
|
||
else:
|
||
print("\n[OK] 未发现严重问题")
|
||
|
||
print(f"\n总模板记录数: {len(file_configs['all_configs'])}")
|
||
print(f"总关联关系数: {len(relations['all_relations'])}")
|
||
print(f"有关联关系的文件数: {len(relations['file_field_counts'])}")
|
||
|
||
finally:
|
||
conn.close()
|
||
print("\n数据库连接已关闭")
|
||
|
||
|
||
if __name__ == '__main__':
|
||
import os
|
||
main()
|
||
|