xforge 0.4.3__py3-none-any.whl

scripts/export_dsl.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""一键导出：SQLite 规则 → regula DSL JSON 文件。
+
+Usage:
+    python scripts/export_dsl.py
+    python scripts/export_dsl.py --model 靠企吃企
+    python scripts/export_dsl.py --status approved
+    python scripts/export_dsl.py --rule-id 1 --rule-id 2
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from src.database.connection import init_db
+from src.services.export_service import export_to_dsl
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="导出规则 → regula DSL JSON"
+    )
+    parser.add_argument("--model", "-m", type=str, help="按模型筛选")
+    parser.add_argument("--status", "-s", type=str, help="按状态筛选")
+    parser.add_argument("--rule-id", type=int, action="append", dest="rule_ids",
+                        help="指定规则 ID（可重复）")
+    args = parser.parse_args()
+
+    init_db()
+
+    result = export_to_dsl(
+        rule_ids=args.rule_ids,
+        model=args.model,
+        status=args.status,
+    )
+
+    print(f"[export] 完成: 生成 {result.generated}, 失败 {result.failed}")
+    if result.files:
+        print(f"[export] 输出目录: {result.files[0].parent}")
+        for f in result.files[:10]:
+            print(f"  - {f.name}")
+        if len(result.files) > 10:
+            print(f"  ... 共 {len(result.files)} 个文件")
+
+    if result.errors:
+        print(f"\n[export] 错误 ({len(result.errors)}):")
+        for err in result.errors[:10]:
+            print(f"  - {err}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_parquet_sql.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""从 rules_dsl/sql/*.sql 生成 parquet 直查版 SQL → rules_dsl/sql/parquet/
+
+转换规则：
+- ml_kqcq_zzsfp: 拼音别名 → 中文 parquet 列名 (read_parquet)
+- ml_cd_company / ml_base_fdjjr / ml_base_fdjjr_bx: 列名不变
+- 保留 DuckDB 语法 (string_agg, regexp_matches, any_value 等)
+- 跳过注释行，避免旧代码块被误转换
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+import polars as pl
+import yaml
+
+from src.services.sql_adapter import build_column_map
+
+SQL_DIR = _PROJECT_ROOT / "rules_dsl" / "sql"
+PARQUET_OUT_DIR = SQL_DIR / "parquet"
+CONFIG_PATH = _PROJECT_ROOT / "config.yaml"
+
+# 补充修正：build_column_map 模糊匹配会误伤的列
+# parquet 列名 → 正确拼音别名（覆盖 build_column_map 的错误结果）
+_ALIAS_FIXES: dict[str, dict[str, str]] = {
+    "ml_kqcq_zzsfp": {
+        "发票代码": "fpdm",    # 发票代码，模糊匹配错映射到 fphm(发票号码)
+        "单位": "dw",          # 计量单位，模糊匹配错映射到 xfdwmc(销方名称)
+    },
+}
+
+
+def load_config() -> dict:
+    with open(CONFIG_PATH, encoding="utf-8") as f:
+        return yaml.safe_load(f) or {}
+
+
+def build_subquery(table_name: str, parquet_path: str) -> str:
+    """为一张表生成 read_parquet 子查询，保证别名唯一。
+
+    返回: 子查询 SQL 文本
+    格式:
+        (SELECT "开票日期" AS kpsj, ... FROM read_parquet('/path'))
+    """
+    pq_path = str(Path(parquet_path).resolve())
+    df = pl.read_parquet(pq_path)
+    parquet_cols = list(df.columns)
+    fixes = _ALIAS_FIXES.get(table_name, {})
+
+    select_parts = []
+    used_aliases: set[str] = set()
+    dup_count: dict[str, int] = {}
+
+    if table_name == "ml_kqcq_zzsfp":
+        # 直接用 sql_adapter.build_column_map（读取 _MAPPING_FILE + 手动修正 + 模糊匹配）
+        col_map = build_column_map(table_name, parquet_cols)
+
+        for pc in parquet_cols:
+            # 覆盖修正优先
+            if pc in fixes:
+                alias = fixes[pc]
+            else:
+                alias = col_map.get(pc, pc)
+
+            # 去重：同一别名出现多次时，第一个保留，后续加 _2, _3...
+            if alias in used_aliases:
+                dup_count[alias] = dup_count.get(alias, 1) + 1
+                alias = f"{alias}_{dup_count[alias]}"
+            used_aliases.add(alias)
+
+            select_parts.append(f'    "{pc}" AS {alias}')
+    else:
+        for pc in parquet_cols:
+            select_parts.append(f'    "{pc}" AS "{pc}"')
+
+    col_list = ",\n".join(select_parts)
+    return (
+        f"(\n"
+        f"  SELECT\n"
+        f"{col_list}\n"
+        f"  FROM read_parquet('{pq_path}')\n"
+        f")"
+    )
+
+
+def _is_comment_line(line: str) -> bool:
+    """判断是否为纯注释行。"""
+    stripped = line.strip()
+    return stripped.startswith('--') or stripped == ''
+
+
+def replace_table_refs(sql: str, data_bindings: dict[str, str]) -> str:
+    """替换 SQL 中所有表引用为 read_parquet 子查询（跳过注释行）。"""
+    lines = sql.split('\n')
+    result_lines: list[str] = []
+
+    for line in lines:
+        if _is_comment_line(line):
+            result_lines.append(line)
+            continue
+
+        modified = line
+        for table_name, pq_path in sorted(
+            data_bindings.items(), key=lambda x: -len(x[0])
+        ):
+            subquery = build_subquery(table_name, pq_path)
+
+            # 模式: (FROM|JOIN) table_name alias → 替换
+            pattern = re.compile(
+                rf'\b((?:FROM|JOIN)\s+){re.escape(table_name)}\s+(\w+)\b',
+                re.IGNORECASE,
+            )
+            modified = pattern.sub(
+                lambda m, sq=subquery: (
+                    f"{m.group(1)}{sq} AS {m.group(2)}"
+                ),
+                modified,
+            )
+
+            # 模式: FROM table_name 无别名 (CTE 内等) → 自动生成别名
+            pattern_no_alias = re.compile(
+                rf'\b(FROM\s+){re.escape(table_name)}\b(?!\s+\w)',
+                re.IGNORECASE,
+            )
+            modified = pattern_no_alias.sub(
+                lambda m, sq=subquery, tn=table_name: (
+                    f"{m.group(1)}{sq} AS _{tn}"
+                ),
+                modified,
+            )
+
+        result_lines.append(modified)
+
+    return '\n'.join(result_lines)
+
+
+def _strip_comments(sql: str) -> str:
+    """去掉 SQL 注释行，返回纯净的 SQL 语句。"""
+    lines = []
+    for line in sql.split('\n'):
+        stripped = line.strip()
+        if stripped.startswith('--'):
+            continue
+        lines.append(line)
+    return '\n'.join(lines).strip().rstrip(';')
+
+
+def main() -> None:
+    config = load_config()
+    data_bindings = config.get("data_bindings", {})
+    if not data_bindings:
+        print("[generate] config.yaml 中无 data_bindings 配置，退出")
+        return
+
+    PARQUET_OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    sql_files = sorted(SQL_DIR.glob("*.sql"))
+    generated = 0
+    skipped = 0
+
+    for fp in sql_files:
+        sql_text = fp.read_text(encoding="utf-8").strip()
+
+        # 跳过 TODO 占位文件
+        sql_no_comments = _strip_comments(sql_text)
+        if sql_no_comments in ("SELECT 1", "SELECT 1;", "SELECT 1;"):
+            skipped += 1
+            continue
+
+        # 生成 parquet 版
+        header = (
+            f"-- Parquet 直查版: {fp.name}\n"
+            f"-- 来源: rules_dsl/sql/{fp.name}\n"
+            f"-- 可直接在 DuckDB 中执行，无需依赖项目 VIEW\n"
+            f"-- 生成脚本: scripts/generate_parquet_sql.py\n\n"
+        )
+        transformed = replace_table_refs(sql_text, data_bindings)
+        out_path = PARQUET_OUT_DIR / fp.name
+        out_path.write_text(header + transformed + "\n", encoding="utf-8")
+        print(f"  [OK] {fp.name} → parquet/{fp.name}")
+        generated += 1
+
+    print(f"\n[generate] 生成 {generated} 个, 跳过 {skipped} 个 (TODO/SELECT 1)")
+    print(f"[generate] 输出目录: {PARQUET_OUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()