@hupan56/wlkj 2.5.0 → 2.7.0

package/templates/qoder/scripts/kg_incremental.py

@@ -0,0 +1,393 @@
+# -*- coding: utf-8 -*-
+"""
+Incremental UPSERT builder for the DuckDB knowledge graph.
+
+Instead of full rebuild (build_style_index.py → kg_duckdb.py bulk_import),
+this takes a list of changed files (from git diff) and only updates the
+entities + edges that belong to those files.
+
+Performance: ~0.2s per file vs 60s full rebuild.
+For 500 changed files: ~2 minutes incremental vs 5+ minutes full rebuild.
+
+Usage:
+  python kg_incremental.py                  # auto-detect changes via git diff
+  python kg_incremental.py file1.vue file2.ts  # explicit file list
+"""
+import json
+import os
+import re
+import sys
+
+SCRIPTS = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, SCRIPTS)
+
+from common.paths import DATA_INDEX_DIR, PROJECT_ROOT
+from kg_duckdb import get_db, init_schema, upsert_entity, upsert_alias, upsert_edge, delete_edges_from
+from common.ts_extract import ts_build_api_fn_table, ts_trace_clicks
+from common.extract import build_api_fn_table
+from common.test_extract import extract_test_assertions
+
+CODE_DIR = str(PROJECT_ROOT / 'data' / 'code')
+INDEX_DIR = str(DATA_INDEX_DIR)
+
+
+def get_changed_files():
+    """Auto-detect ALL changed files since last kg_build via stored commit hash.
+
+    Records the last-built commit per project in build_meta table.
+    Next run diffs from that commit to HEAD, capturing ALL changes (not just last 2 commits).
+    """
+    changed = []
+    if not os.path.isdir(CODE_DIR):
+        return changed
+    import subprocess
+
+    # Read last-built commits from DuckDB build_meta
+    last_commits = {}
+    try:
+        con = get_db()
+        rows = con.execute("SELECT key, value FROM build_meta WHERE key LIKE 'last_commit_%'").fetchall()
+        con.close()
+        for k, v in rows:
+            last_commits[k.replace('last_commit_', '')] = v
+    except Exception:
+        pass
+
+    current_commits = {}
+    for proj in os.listdir(CODE_DIR):
+        proj_path = os.path.join(CODE_DIR, proj)
+        if not os.path.isdir(os.path.join(proj_path, '.git')):
+            continue
+        try:
+            # Get current HEAD
+            r = subprocess.run(['git', 'rev-parse', 'HEAD'],
+                               cwd=proj_path, capture_output=True, text=True, encoding='utf-8')
+            if r.returncode != 0:
+                continue
+            current_head = r.stdout.strip()
+            current_commits[proj] = current_head
+
+            # Determine diff range: from last-built commit to HEAD
+            last_built = last_commits.get(proj)
+            if last_built and last_built != current_head:
+                # Diff from last build to now — captures ALL changes since last build
+                diff_args = ['git', 'diff', '--name-only', last_built, current_head]
+            elif not last_built:
+                # First run — get last 7 days of changes (or all if repo is new)
+                r3 = subprocess.run(['git', 'log', '--since=7 days ago', '--oneline'],
+                                    cwd=proj_path, capture_output=True, text=True, encoding='utf-8')
+                log_lines = [l for l in r3.stdout.strip().split('\n') if l.strip()]
+                if len(log_lines) >= 2:
+                    old_commit = log_lines[-1].split()[0]
+                    diff_args = ['git', 'diff', '--name-only', old_commit, current_head]
+                else:
+                    continue  # No changes or single commit
+            else:
+                continue  # Already up to date, no diff needed
+
+            r2 = subprocess.run(diff_args,
+                                cwd=proj_path, capture_output=True, text=True, encoding='utf-8')
+            for f in r2.stdout.strip().split('\n'):
+                f = f.strip()
+                if f:
+                    changed.append(os.path.join(proj_path, f.replace('/', os.sep)))
+        except Exception:
+            pass
+
+    # Save current commits as last-built
+    try:
+        con = get_db()
+        for proj, commit in current_commits.items():
+            con.execute(
+                "INSERT OR REPLACE INTO build_meta VALUES (?, ?)",
+                ['last_commit_%s' % proj, commit]
+            )
+        con.close()
+    except Exception:
+        pass
+
+    return changed
+
+
+def incremental_update(changed_files):
+    """Update DuckDB incrementally for a list of changed files.
+
+    For each file:
+      - .vue: re-extract trace_clicks, UPSERT button entities + click edges
+      - .ts (api): re-extract api functions, UPSERT endpoint entities
+      - .java (test): re-extract test assertions, UPSERT test entities
+    """
+    con = get_db()
+    init_schema(con)
+
+    stats = {'vue': 0, 'ts': 0, 'java_test': 0, 'edges_updated': 0, 'entities_upserted': 0}
+
+    # 判断是否有 api 文件变更 — 决定是否需要重建 api_table
+    has_api_changes = any(
+        f.replace('\\', '/').endswith('.ts') and '/api/' in f.replace('\\', '/')
+        for f in changed_files if os.path.isfile(f)
+    )
+
+    api_dir = _find_api_dir()
+
+    if has_api_changes:
+        # api 文件变了 — 必须重建完整 api_table
+        api_table = ts_build_api_fn_table(api_dir) if api_dir else {}
+        # 缓存到文件, 供下次增量复用
+        if api_table and api_dir:
+            _save_api_cache(api_table, api_dir)
+    else:
+        # api 文件没变 — 从缓存加载 (毫秒级, 不扫文件系统)
+        api_table = _load_api_cache(api_dir)
+        if not api_table:
+            # 缓存不存在 (首次运行) — 重建并缓存
+            api_table = ts_build_api_fn_table(api_dir) if api_dir else {}
+            if api_table and api_dir:
+                _save_api_cache(api_table, api_dir)
+
+    for filepath in changed_files:
+        if not os.path.isfile(filepath):
+            # File was deleted — clean up its entities
+            _cleanup_deleted_file(con, filepath)
+            continue
+
+        rel_path = filepath.replace('\\', '/')
+
+        if filepath.endswith('.vue'):
+            stats['vue'] += 1
+            _update_vue_file(con, filepath, api_table, stats)
+
+        elif filepath.endswith('.ts') and '/api/' in rel_path:
+            stats['ts'] += 1
+            _update_api_file(con, filepath, stats)
+
+        elif filepath.endswith('Test.java'):
+            stats['java_test'] += 1
+            _update_test_file(con, filepath, stats)
+
+    # After file updates, refresh PRD + Wiki from git_sync's JSON output
+    _refresh_prds_and_wiki(con, stats)
+
+    con.close()
+    return stats
+
+
+def _refresh_prds_and_wiki(con, stats):
+    """Import PRD index + Wiki from git_sync's JSON output into DuckDB.
+
+    git_sync.py writes these as JSON; kg_incremental reads them and UPSERTs
+    into DuckDB so MCP tools can query them.
+    """
+    INDEX = str(DATA_INDEX_DIR)
+    import json as _json
+
+    # PRD
+    prd_path = os.path.join(INDEX, '_build_cache', 'prd-index.json')
+    if not os.path.isfile(prd_path):
+        prd_path = os.path.join(INDEX, 'prd-index.json')
+    if os.path.isfile(prd_path):
+        try:
+            prds = _json.load(open(prd_path, encoding='utf-8'))
+            con.execute("DELETE FROM prds")
+            rows = [(f, info.get('title', ''),
+                     _json.dumps(info.get('keywords', []), ensure_ascii=False),
+                     _json.dumps(info.get('features', []), ensure_ascii=False),
+                     _json.dumps(info.get('cn_terms', []), ensure_ascii=False))
+                    for f, info in prds.items()]
+            if rows:
+                _batch_insert(con, 'prds', rows, ignore=True)
+                stats['prds_refreshed'] = len(rows)
+        except Exception:
+            pass
+
+    # Wiki
+    wiki_path = os.path.join(INDEX, 'wiki-index.json')
+    if os.path.isfile(wiki_path):
+        try:
+            wiki = _json.load(open(wiki_path, encoding='utf-8'))
+            con.execute("DELETE FROM wiki")
+            wiki_rows = []
+            for kw, entries in (wiki.get('index', {}) if isinstance(wiki, dict) else {}).items():
+                for e in (entries if isinstance(entries, list) else []):
+                    wiki_rows.append((kw, e.get('project', ''), e.get('title', ''),
+                                      e.get('md_path', ''), e.get('description', '')))
+            if wiki_rows:
+                _batch_insert(con, 'wiki', wiki_rows)
+                stats['wiki_refreshed'] = len(wiki_rows)
+        except Exception:
+            pass
+
+
+def _find_api_dir():
+    """Find the fywl-ui api directory."""
+    apps = os.path.join(CODE_DIR, 'fywl-ui', 'apps')
+    if os.path.isdir(apps):
+        for app in os.listdir(apps):
+            candidate = os.path.join(apps, app, 'src', 'api')
+            if os.path.isdir(candidate):
+                return candidate
+    return None
+
+
+def _load_api_table_from_duckdb(con):
+    """从 DuckDB 加载 api_table (api 函数名→端点), 避免重建。"""
+    table = {}
+    try:
+        rows = con.execute("SELECT id, props FROM entities WHERE type = 'ENDPOINT'").fetchall()
+        for eid, props_json in rows:
+            url = eid.replace('E:', '')
+            props = json.loads(props_json) if props_json else {}
+            fn_name = props.get('api_fn', '')
+            if fn_name:
+                table[fn_name] = {'url': url, 'verb': props.get('verb', '?'),
+                                  'file': props.get('source_file', '')}
+    except Exception:
+        pass
+    return table
+
+
+_API_CACHE_PATH = os.path.join(INDEX_DIR, '.api-table-cache.json')
+
+
+def _save_api_cache(api_table, api_dir):
+    """保存 api_table 到缓存文件 (含 api_dir 的 mtime 作为失效依据)。"""
+    import time
+    cache = {
+        'api_dir_mtime': os.path.getmtime(api_dir) if os.path.isdir(api_dir) else 0,
+        'saved_at': time.time(),
+        'table': api_table,
+    }
+    with open(_API_CACHE_PATH, 'w', encoding='utf-8') as f:
+        json.dump(cache, f, ensure_ascii=False)
+
+
+def _load_api_cache(api_dir):
+    """从缓存文件加载 api_table。如果缓存不存在或过期返回 {}。"""
+    if not os.path.isfile(_API_CACHE_PATH):
+        return {}
+    try:
+        cache = json.load(open(_API_CACHE_PATH, encoding='utf-8'))
+        # 检查 api_dir 的 mtime 是否变了
+        current_mtime = os.path.getmtime(api_dir) if api_dir and os.path.isdir(api_dir) else 0
+        if cache.get('api_dir_mtime') == current_mtime:
+            return cache.get('table', {})
+    except Exception:
+        pass
+    return {}
+
+
+def _update_vue_file(con, filepath, api_table, stats):
+    """Re-extract traces from one Vue file and UPSERT its button entities + edges."""
+    try:
+        content = open(filepath, 'rb').read().decode('utf-8', errors='replace')
+    except Exception:
+        return
+    if '@click' not in content:
+        return
+
+    traces = ts_trace_clicks(filepath, content, api_table)
+    vue_norm = filepath.replace('\\', '/')
+    # Normalize vue_short — MUST match kg_build.py's format exactly
+    if '/views/' in vue_norm:
+        vue_short = vue_norm.split('/views/')[-1]
+    elif '/pages/' in vue_norm:
+        vue_short = vue_norm.split('/pages/')[-1]
+    else:
+        vue_short = os.path.basename(filepath)
+
+    for t in traces:
+        handler = t.get('handler', '')
+        eid = 'B:%s:%s' % (vue_short, handler)
+        # UPSERT entity (INSERT OR REPLACE, no duplicates)
+        upsert_entity(con, eid, 'BUTTON', handler, '',
+                      {'button_text': t.get('button', ''),
+                       'vue_file': vue_norm,
+                       'confidence': t.get('confidence', '')})
+        upsert_alias(con, handler.lower(), eid)
+        stats['entities_upserted'] += 1
+
+        # Delete ALL old edges from this button first, then insert fresh
+        delete_edges_from(con, eid)
+        ep = t.get('endpoint')
+        if ep and ep != 'None':
+            to_eid = 'E:%s' % ep
+            upsert_edge(con, eid, to_eid, 'clicks', props={
+                'button': t.get('button', ''),
+                'confidence': t.get('confidence', ''),
+            })
+            stats['edges_updated'] += 1
+
+
+def _update_api_file(con, filepath, stats):
+    """Re-extract API functions from one .ts file and UPSERT endpoint entities."""
+    # Re-use the bulk api_table extraction on this single file's directory
+    api_dir = os.path.dirname(filepath)
+    file_table = build_api_fn_table(api_dir)
+    for fn_name, info in file_table.items():
+        # Only update functions defined in THIS file
+        if info.get('file', '').replace('\\', '/') != filepath.replace('\\', '/'):
+            continue
+        eid = 'E:%s' % info['url']
+        upsert_entity(con, eid, 'ENDPOINT', info['url'], '',
+                      {'verb': info.get('verb', '?'),
+                       'api_fn': fn_name,
+                       'source_file': filepath.replace('\\', '/')})
+        upsert_alias(con, fn_name.lower(), eid)
+        stats['entities_upserted'] += 1
+
+
+def _update_test_file(con, filepath, stats):
+    """Re-extract test assertions from one Test.java and UPSERT test entities."""
+    tests = extract_test_assertions(os.path.dirname(filepath))
+    # Filter to only this file
+    file_norm = filepath.replace('\\', '/')
+    for t in tests:
+        if t.get('file', '').replace('\\', '/') != file_norm:
+            continue
+        name = '%s.%s' % (t['class'], t['method'])
+        eid = 'T:%s' % name
+        upsert_entity(con, eid, 'TEST', name, '',
+                      {'display': t.get('display_name', ''),
+                       'deps': t.get('injected_deps', []),
+                       'assertions': t.get('assertions', []),
+                       'package': t.get('package', '')})
+        upsert_alias(con, name.lower(), eid)
+        stats['entities_upserted'] += 1
+
+
+def _cleanup_deleted_file(con, filepath):
+    """Remove entities belonging to a deleted file."""
+    rel = filepath.replace('\\', '/')
+    # Delete buttons from this vue file
+    if '.vue' in rel:
+        vue_short = rel.split('/views/')[-1] if '/views/' in rel else os.path.basename(rel)
+        con.execute("DELETE FROM entities WHERE id LIKE 'B:%s:%%'" % vue_short.replace("'", "''"))
+        con.execute("DELETE FROM edges WHERE from_id LIKE 'B:%s:%%'" % vue_short.replace("'", "''"))
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        changed = sys.argv[1:]
+    else:
+        print('Auto-detecting changes via git diff...')
+        changed = get_changed_files()
+
+    if not changed:
+        print('No changes detected.')
+        sys.exit(0)
+
+    # Filter to relevant file types
+    relevant = [f for f in changed if f.endswith(('.vue', '.ts', '.java'))]
+    print('Changed files: %d total, %d relevant' % (len(changed), len(relevant)))
+
+    if relevant:
+        import time
+        t0 = time.time()
+        stats = incremental_update(relevant)
+        elapsed = time.time() - t0
+        print('Incremental update done in %.1fs' % elapsed)
+        print('  Vue: %d, TS: %d, Java: %d' % (stats['vue'], stats['ts'], stats['java_test']))
+        print('  Entities UPSERTed: %d' % stats['entities_upserted'])
+        print('  Edges updated: %d' % stats['edges_updated'])
+    else:
+        print('No relevant files to update.')

package/templates/qoder/scripts/kg_link_db.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""kg_link_db.py - 扫代码 @TableName 注解, 建 Entity 类 ↔ 数据库表 的语义桥。
+
+解决"数据层孤岛"问题: kg_db.duckdb 有表结构, 但不知道对应代码里的哪个 Entity。
+本脚本扫 Java 源码里的 @TableName("xxx") 注解, 提取:
+  Entity 类名 → 数据库表名 → (关联到) db_columns 的真实列
+
+调研依据 (FalkorDB "结构遍历 > 语义匹配"):
+  - 不靠表名子串猜 endpoint (验证过 0 命中, 不准)
+  - 靠代码显式声明的关系 (@TableName 注解) 建边, 这才准
+
+产出表 (写进 kg_db.duckdb, 不动 kg.duckdb 写锁):
+  entity_table_map:
+    entity_class  TEXT   -- QualityCaseBo (代码层类名)
+    table_name    TEXT   -- quality_case (数据库表名, 关联 db_tables)
+    source_file   TEXT   -- 哪个 .java 读到的
+    annotation    TEXT   -- @TableName("quality_case") 原文
+
+建好后可遍历:
+  数据库表 → entity_table_map → Entity 类 → (kg.duckdb) Controller/接口
+
+用法:
+  python kg_link_db.py              # 扫 data/code/ 全量
+  python kg_link_db.py --rebuild    # 清旧重建
+  python kg_link_db.py --stats      # 看统计
+"""
+import os
+import re
+import sys
+import time
+
+SCRIPTS = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPTS)
+
+import duckdb
+from common.paths import DATA_INDEX_DIR, PROJECT_ROOT
+
+CODE_DIR = str(PROJECT_ROOT / 'data' / 'code')
+DB_PATH = str(DATA_INDEX_DIR / 'kg_db.duckdb')
+
+# @TableName 的两种格式:
+#   @TableName("quality_case")
+#   @TableName(value = "quality_case")
+RE_TABLENAME = re.compile(
+    r'@TableName\s*\(\s*(?:value\s*=\s*)?"([^"]+)"',
+    re.IGNORECASE
+)
+# 紧跟注解的 class 声明: class QualityCaseBo
+RE_CLASS = re.compile(r'class\s+(\w+)')
+
+
+def _normalize_table_name(raw):
+    """归一化表名, 提升和数据库真实表的匹配率。
+    处理注解写法不规范的情况:
+      fywl_ics_cloud.sys_dept → sys_dept (去库名前缀)
+      empContractImport → emp_contract_import (camelCase→snake_case)
+      quality_case → quality_case (已是规范, 不变)
+    """
+    t = raw.strip().lower()
+    # 去库名前缀 (db.table → table)
+    if '.' in t:
+        t = t.rsplit('.', 1)[-1]
+    # 去常见前缀 t_/tb_/t (数据库表常加这些, 注解有时不加)
+    # 注意: 不在这里去前缀, 因为 db_tables 里有的带 t_ 有的不带, 留原样让 JOIN 双向兜
+    # camelCase → snake_case (Java 注解里有时写驼峰表名)
+    if re.search(r'[a-z][A-Z]', t):
+        t = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', t).lower()
+    return t
+
+
+def _scan_java_files():
+    """扫 data/code/ 下所有 .java, 返回 [(entity_class, table_name, normalized_table, source_file, annotation)]。"""
+    mappings = []
+    scanned = 0
+    for root, dirs, files in os.walk(CODE_DIR):
+        # 跳过非业务目录
+        dirs[:] = [d for d in dirs if d not in (
+            '.git', 'node_modules', '__pycache__', 'target', 'test')]
+        for fn in files:
+            if not fn.endswith('.java'):
+                continue
+            scanned += 1
+            fpath = os.path.join(root, fn)
+            try:
+                for enc in ('utf-8', 'gbk'):
+                    try:
+                        with open(fpath, encoding=enc) as f:
+                            content = f.read()
+                        break
+                    except (UnicodeDecodeError, OSError):
+                        content = ''
+                        continue
+            except OSError:
+                continue
+            if '@TableName' not in content:
+                continue
+            # 找所有 @TableName 注解
+            for m in RE_TABLENAME.finditer(content):
+                table_name = m.group(1)
+                normalized = _normalize_table_name(table_name)
+                annotation = content[m.start():m.end() + 1]
+                # 找注解之后最近的 class 声明 (Entity 类名)
+                after = content[m.end():m.end() + 500]
+                cm = RE_CLASS.search(after)
+                entity_class = cm.group(1) if cm else os.path.splitext(fn)[0]
+                rel = os.path.relpath(fpath, PROJECT_ROOT).replace('\\', '/')
+                mappings.append((entity_class, table_name, normalized, rel, annotation))
+    return mappings, scanned
+
+
+def build(rebuild=False):
+    """扫代码 @TableName → 写 entity_table_map。"""
+    t0 = time.time()
+    print('扫描 data/code/ 下的 @TableName 注解...')
+    mappings, scanned = _scan_java_files()
+    print('  扫描 %d 个 .java 文件, 找到 %d 个 @TableName 映射 (%.1fs)'
+          % (scanned, len(mappings), time.time() - t0))
+
+    if not mappings:
+        print('未找到任何 @TableName 注解。检查 data/code/ 是否有 Java 源码。')
+        return 0
+
+    con = duckdb.connect(DB_PATH)
+    try:
+        con.execute("""CREATE TABLE IF NOT EXISTS entity_table_map (
+            entity_class TEXT,
+            table_name TEXT,
+            normalized_table TEXT,
+            source_file TEXT,
+            annotation TEXT
+        )""")
+        con.execute("CREATE INDEX IF NOT EXISTS idx_etm_table ON entity_table_map(table_name)")
+        con.execute("CREATE INDEX IF NOT EXISTS idx_etm_norm ON entity_table_map(normalized_table)")
+        con.execute("CREATE INDEX IF NOT EXISTS idx_etm_class ON entity_table_map(entity_class)")
+
+        if rebuild:
+            con.execute("DELETE FROM entity_table_map")
+
+        # 用 JSONL COPY 批量插入 (DuckDB 1.4 executemany 慢)
+        import json as _json
+        import tempfile
+        tmp = tempfile.NamedTemporaryFile(suffix='.jsonl', delete=False,
+                                          mode='w', encoding='utf-8')
+        cols = ['entity_class', 'table_name', 'normalized_table', 'source_file', 'annotation']
+        for row in mappings:
+            obj = {cols[i]: (row[i] if row[i] is not None else '')
+                   for i in range(len(cols))}
+            tmp.write(_json.dumps(obj, ensure_ascii=False) + '\n')
+        tmp.close()
+        try:
+            con.execute("COPY entity_table_map FROM '%s' (FORMAT JSON)"
+                        % tmp.name.replace('\\', '/'))
+        finally:
+            os.unlink(tmp.name)
+
+        con.execute("INSERT OR REPLACE INTO build_meta(key, value) VALUES (?,?)",
+                    ['entity_table_map_built', str(time.time())])
+        print('写入 %d 条 Entity→表 映射到 entity_table_map' % len(mappings))
+        return len(mappings)
+    finally:
+        con.close()
+
+
+def query_impact(table_name):
+    """查某张表关联的 Entity 类 (给"改表影响分析"用)。"""
+    con = duckdb.connect(DB_PATH, read_only=True)
+    try:
+        rows = con.execute(
+            "SELECT DISTINCT entity_class, source_file FROM entity_table_map "
+            "WHERE table_name = ?", [table_name]
+        ).fetchall()
+        return rows
+    finally:
+        con.close()
+
+
+def stats():
+    """映射统计 + 和 db_tables/db_columns 的关联率。"""
+    con = duckdb.connect(DB_PATH, read_only=True)
+    try:
+        total = con.execute("SELECT COUNT(*) FROM entity_table_map").fetchone()[0]
+        classes = con.execute("SELECT COUNT(DISTINCT entity_class) FROM entity_table_map").fetchone()[0]
+        tables_mapped = con.execute("SELECT COUNT(DISTINCT table_name) FROM entity_table_map").fetchone()[0]
+        # 关联率: 映射的表名 vs 数据库真实表名 (原始 + 归一化)
+        try:
+            raw_matched = con.execute("""
+                SELECT COUNT(DISTINCT m.table_name) FROM entity_table_map m
+                JOIN db_tables t ON m.table_name = t.table_name
+            """).fetchone()[0]
+            norm_matched = con.execute("""
+                SELECT COUNT(DISTINCT m.normalized_table) FROM entity_table_map m
+                JOIN db_tables t ON m.normalized_table = t.table_name
+            """).fetchone()[0]
+            db_total = con.execute("SELECT COUNT(DISTINCT table_name) FROM db_tables").fetchone()[0]
+        except Exception:
+            raw_matched, norm_matched, db_total = 0, 0, 0
+        print('entity_table_map 统计:')
+        print('  总映射: %d' % total)
+        print('  Entity 类数: %d' % classes)
+        print('  映射的表名数: %d' % tables_mapped)
+        if db_total:
+            print('  原始表名匹配: %d/%d (%.0f%%)'
+                  % (raw_matched, db_total, raw_matched / db_total * 100))
+            print('  归一化后匹配: %d/%d (%.0f%%)'
+                  % (norm_matched, db_total, norm_matched / db_total * 100))
+        # 抽样
+        sample = con.execute(
+            "SELECT entity_class, table_name FROM entity_table_map LIMIT 8"
+        ).fetchall()
+        print('  抽样:')
+        for ec, tn in sample:
+            print('    %s → %s' % (ec, tn))
+    finally:
+        con.close()
+
+
+if __name__ == '__main__':
+    args = sys.argv[1:]
+    if '--stats' in args:
+        stats()
+    else:
+        build(rebuild='--rebuild' in args)
+        stats()