atquery 2.13.0__tar.gz → 2.13.2__tar.gz

{atquery-2.13.0 → atquery-2.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atquery
-Version: 2.13.0
+Version: 2.13.2
 Summary: A Python module for simplifying DBAPI usage with one-query-per-file SQL management.
 Keywords: sql,database,dbapi,mysql,sqlite,duckdb
 Author: alpine

{atquery-2.13.0 → atquery-2.13.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.11.15,<0.12"]
+requires = ["uv_build>=0.11.15"]
 build-backend = "uv_build"
 
 [project]
 name = "atquery"
-version = "2.13.0"
+version = "2.13.2"
 description = "A Python module for simplifying DBAPI usage with one-query-per-file SQL management."
 readme = "README.md"
 requires-python = ">=3.10"

{atquery-2.13.0 → atquery-2.13.2}/pyproject.toml.orig

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.11.15,<0.12"]
+requires = ["uv_build>=0.11.15"]
 build-backend = "uv_build"
 
 [project]
 name = "atquery"
-version = "2.13.0"
+version = "2.13.2"
 description = "A Python module for simplifying DBAPI usage with one-query-per-file SQL management."
 readme = "README.md"
 requires-python = ">=3.10"

{atquery-2.13.0 → atquery-2.13.2}/src/atquery/cli/ecd.py

@@ -9,6 +9,12 @@
     # ECDファイルからCREATE文を生成（ディレクトリ指定は配下を再帰的に探索）
     atquery ecd ddl docs/ecd -o schema.sql
 
+    # 列挙値マスタの`values`からUPSERT文（初期データ投入SQL）を生成
+    atquery ecd seed docs/ecd -o seed.sql --dialect mysql
+
+    # 監査列（*_by等）に全テーブル共通の固定値を注入する
+    atquery ecd seed docs/ecd -o seed.sql --column created_by "rev 1" --column created_id "tx-232311"
+
     # glob表現で複数ファイルをまとめて指定
     atquery ecd ddl "docs/ecd/**/*.md" -o schema.sql
 
@@ -70,6 +76,25 @@ def setup_parser(parser: argparse.ArgumentParser) -> None:
     _add_ecd_source_args(erd_parser)
     erd_parser.add_argument("-o", "--output", help="出力先ファイル（省略時は標準出力）")
 
+    seed_parser = subparsers.add_parser(
+        "seed",
+        help="Generate UPSERT statements from ECD `values` (enum master seed data)",
+    )
+    _add_ecd_source_args(seed_parser)
+    seed_parser.add_argument("-o", "--output", help="出力先ファイル（省略時は標準出力）")
+    seed_parser.add_argument(
+        "--dialect", default="mysql", choices=["mysql", "sqlite"], help="出力するSQL方言（既定: mysql）"
+    )
+    seed_parser.add_argument(
+        "--column",
+        nargs=2,
+        metavar=("NAME", "VALUE"),
+        action="append",
+        dest="columns",
+        help="全テーブル共通の固定値を持つ列を追加指定する（監査列`created_by`等向け、複数回指定可）。"
+        "対象列が存在しないテーブルには書き込まれない",
+    )
+
     catalog_parser = subparsers.add_parser(
         "catalog",
         help="Generate a Markdown catalog (summary + details) from ECD files",
@@ -139,12 +164,14 @@ def execute_ecd(args: argparse.Namespace) -> int:
         return _execute_ddl(args)
     if command == "erd":
         return _execute_erd(args)
+    if command == "seed":
+        return _execute_seed(args)
     if command == "catalog":
         return _execute_catalog(args)
     if command == "diff":
         return _execute_diff(args)
 
-    print("Usage: atquery ecd <skeleton|ddl|erd|catalog|diff> ...", file=sys.stderr)
+    print("Usage: atquery ecd <skeleton|ddl|erd|seed|catalog|diff> ...", file=sys.stderr)
     print("       atquery ecd --help", file=sys.stderr)
     return EXIT_ERROR
 
@@ -235,6 +262,34 @@ def _execute_ddl(args: argparse.Namespace) -> int:
     return EXIT_SUCCESS
 
 
+def _execute_seed(args: argparse.Namespace) -> int:
+    documents = _load_ecd_documents(args)
+    if documents is None:
+        return EXIT_ERROR
+
+    from atquery.ecd import ECDError, generate_seed_sql, resolve_documents
+
+    static_columns = dict(args.columns) if getattr(args, "columns", None) else {}
+
+    try:
+        sql, warnings = generate_seed_sql(
+            resolve_documents(documents), dialect=args.dialect, static_columns=static_columns
+        )
+    except ECDError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return EXIT_ERROR
+
+    for warning in warnings:
+        print(f"Warning: {warning}", file=sys.stderr)
+
+    if not sql.strip():
+        print("No `values` definitions found.", file=sys.stderr)
+        return EXIT_SUCCESS
+
+    _write_output(sql, args.output)
+    return EXIT_SUCCESS
+
+
 def _execute_erd(args: argparse.Namespace) -> int:
     documents = _load_ecd_documents(args)
     if documents is None:

{atquery-2.13.0 → atquery-2.13.2}/src/atquery/cli/main.py

@@ -273,6 +273,12 @@ class OutputWriter:
 
     def write_header(self, keys: Sequence[str]):
         """ヘッダーを出力"""
+        # DBのJSON型カラムはPython API (get()/getall()) と同じ基準で自動デコード対象に加える
+        # （column_type == "JSON"）。tables.py等が明示指定するjson_columns（JSON文字列だが型はJSONでない
+        # カラム）はこれとは別に維持されるため、ここでは追加(|=)のみ行う。
+        if self.column_types:
+            self.json_columns |= {name for name, type_ in zip(keys, self.column_types) if type_ == "JSON"}
+
         if self.output_format == "json":
             if self.with_types:
                 columns = self._columns_metadata(keys)
@@ -782,7 +788,8 @@ Examples:
                 with datasource.connect() as conn:
                     result = explain_query.execute(conn, params=params)
                     # 検証のみ実行、結果は破棄
-                    result.fetchall()
+                    plan_rows = result.fetchall()
+                print(f"OK: dry-run succeeded (validated via EXPLAIN, {len(plan_rows)} plan row(s), no data was modified)", file=sys.stderr)
                 return EXIT_SUCCESS
             else:
                 # INSERT/UPDATE/DELETE文の場合はPREPAREで構文チェック（MySQL限定）
@@ -798,10 +805,12 @@ Examples:
                         conn.execute(prepare_sql)
                         # 正常に準備できたらDEALLOCATE
                         conn.execute(f"DEALLOCATE PREPARE {stmt_name}")
+                        print("OK: dry-run succeeded (validated via PREPARE, no data was modified)", file=sys.stderr)
                         return EXIT_SUCCESS
                     except AttributeError:
                         # MySQL以外のDBの場合は構文チェック不可
                         # パラメータバインドまで成功していればOKとする
+                        print("OK: dry-run succeeded (parameters bound; syntax check unavailable for this DBMS, no data was modified)", file=sys.stderr)
                         return EXIT_SUCCESS
 
         # 7. クエリの実行

{atquery-2.13.0 → atquery-2.13.2}/src/atquery/ecd/__init__.py

@@ -28,6 +28,7 @@ from atquery.ecd.model import (
 )
 from atquery.ecd.parser import is_ecd_document, parse_file, parse_text
 from atquery.ecd.resolver import ResolvedTable, resolve_documents
+from atquery.ecd.seed import generate_seed_sql
 from atquery.ecd.skeleton import generate_skeleton
 
 __all__ = [
@@ -52,6 +53,7 @@ __all__ = [
     "generate_catalog_markdown",
     "generate_diff_sql",
     "generate_erd_svg",
+    "generate_seed_sql",
     "generate_skeleton",
     "generate_table_ddl",
     "generate_view_ddl",

{atquery-2.13.0 → atquery-2.13.2}/src/atquery/ecd/model.py

@@ -18,10 +18,15 @@ class Frontmatter:
 
 @dataclass(frozen=True)
 class CodeValue:
-    """`values` 配列の要素（コード値定義）。"""
+    """`values` 配列の要素（コード値定義）。
+
+    `code`/`label` 以外のキー（`sort_order`/`description`等）は`extra`に汎用的に集約する。
+    仕様: docs/dev/adr/0037-ecd-enum-master-seed-and-value-metadata.md
+    """
 
     code: object
     label: str
+    extra: dict[str, object] = field(default_factory=dict)
 
 
 @dataclass(frozen=True)

{atquery-2.13.0 → atquery-2.13.2}/src/atquery/ecd/parser.py

@@ -205,7 +205,7 @@ def _build_view_block(path: str, meta: dict, sql_blocks: dict[str, str]) -> View
 
 
 def _build_column_def(name: str, table: dict) -> ColumnDef:
-    values = tuple(CodeValue(code=v["code"], label=v["label"]) for v in table.get("values", ()))
+    values = tuple(_build_code_value(v) for v in table.get("values", ()))
     return ColumnDef(
         name=name,
         logical_name=table.get("logical_name"),
@@ -215,10 +215,16 @@ def _build_column_def(name: str, table: dict) -> ColumnDef:
     )
 
 
+def _build_code_value(v: dict) -> CodeValue:
+    """`values`配列の1要素をパースする。`code`/`label`以外のキーは`extra`へ集約する。"""
+    extra = {k: val for k, val in v.items() if k not in ("code", "label")}
+    return CodeValue(code=v["code"], label=v["label"], extra=extra)
+
+
 def _build_column_ref(name: str, table: dict) -> ColumnRef:
     values = None
     if "values" in table:
-        values = tuple(CodeValue(code=v["code"], label=v["label"]) for v in table["values"])
+        values = tuple(_build_code_value(v) for v in table["values"])
     return ColumnRef(
         name=name,
         block_name=table["ref"][len("columns:") :],

atquery-2.13.2/src/atquery/ecd/seed.py

@@ -0,0 +1,217 @@
+"""`values`（コード値定義）から初期データ投入用のUPSERT文を生成する（`atquery ecd seed`）。
+
+仕様: docs/dev/adr/0037-ecd-enum-master-seed-and-value-metadata.md
+
+- 対象テーブル: いずれかの列が非空の`values`を持つテーブル（1テーブルにつき`values`を持つ列は1つの前提）。
+- 列マッピング: `code`/`label`/`extra`のキーを問わず、同名の列がテーブルに実在する場合のみ書き込む
+  （エイリアスは無し。未マッピングの`extra`キーは警告を返す）。
+- 行の並び順: 全エントリに`extra["sort_order"]`があればそれで昇順ソート、無ければ宣言順。
+  SQLリテラルへの型変換: マッピング先の列の`sql_def`（DDL型）を見て決める（`code`/`label`にも共通適用）。
+- SQL種別: UPSERT（MySQL: `ON DUPLICATE KEY UPDATE`、SQLite: `ON CONFLICT(...) DO UPDATE SET`）。
+  UPSERTのキーはテーブルの`primary_keys`宣言をそのまま用いる（複合PKも全列をキーにする）。
+- 監査列など`values`由来では埋められない列は`static_columns`（CLIの`--column NAME VALUE`）で
+  全テーブル共通の固定値として注入できる。対象列が無いテーブルはサイレントにスキップする（
+  複数テーブルへのブロードキャストを前提とした仕様のため）。`values`由来の列名と衝突する場合は
+  `--column`側を無視して警告する。INSERT/UPDATE両方に一律で含める（更新を防ぎたい場合は利用者が
+  別途差分migrationを作成する想定）。
+"""
+
+import re
+from collections.abc import Iterable
+from typing import Any
+
+from atquery.ecd.model import CodeValue, ColumnDef
+from atquery.ecd.resolver import ResolvedTable
+
+# MySQLの裸識別子として許可される文字（ddl.pyの規則に合わせる）
+_SAFE_BARE_IDENTIFIER_RE = re.compile(r"^[0-9A-Za-z_$\u0080-\U0010ffff]+$")
+
+_TEXT_SQL_TYPES = {"CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "SET"}
+_DATE_SQL_TYPES = {"DATE", "DATETIME", "TIMESTAMP", "TIME", "YEAR"}
+
+
+def generate_seed_sql(
+    tables: Iterable[ResolvedTable], *, dialect: str = "mysql", static_columns: dict[str, str] | None = None
+) -> tuple[str, list[str]]:
+    """`values`を持つ全テーブル分のUPSERT文を生成する。
+
+    Args:
+        tables: 対象の`ResolvedTable`一覧
+        dialect: 出力するSQL方言（"mysql" | "sqlite"）
+        static_columns: `--column NAME VALUE`で指定された全テーブル共通の固定値
+            （例: 監査列`created_by`/`created_id`）。対象列が無いテーブルはサイレントにスキップする。
+
+    Returns:
+        tuple: (UPSERT文を`\\n\\n`で連結したSQL文字列, 警告メッセージのリスト)
+    """
+    sql_parts: list[str] = []
+    warnings: list[str] = []
+
+    for table in tables:
+        result = _generate_table_seed(table, dialect=dialect, static_columns=static_columns or {})
+        if result is None:
+            continue
+        sql, table_warnings = result
+        sql_parts.append(sql)
+        warnings.extend(table_warnings)
+
+    return "\n\n".join(sql_parts), warnings
+
+
+def _generate_table_seed(
+    table: ResolvedTable, *, dialect: str, static_columns: dict[str, str]
+) -> tuple[str, list[str]] | None:
+    values_col = next((col for col in table.columns if col.values), None)
+    if values_col is None:
+        return None
+
+    columns_by_name = {col.name: col for col in table.columns}
+    mapped_names, static_values, warnings = _map_columns(table.name, values_col, columns_by_name, static_columns)
+    rows = _ordered_rows(values_col.values)
+
+    value_rows = [_render_row(values_col, entry, mapped_names, columns_by_name, static_values) for entry in rows]
+    key_columns = list(table.primary_keys) or [values_col.name]
+
+    if dialect == "sqlite":
+        sql = _render_sqlite_upsert(table.name, mapped_names, value_rows, key_columns)
+    else:
+        sql = _render_mysql_upsert(table.name, mapped_names, value_rows, key_columns)
+    return sql, warnings
+
+
+def _map_columns(
+    table_name: str,
+    values_col: ColumnDef,
+    columns_by_name: dict[str, ColumnDef],
+    static_columns: dict[str, str],
+) -> tuple[list[str], dict[str, str], list[str]]:
+    """`code`列自身 + `label`/`extra`のキーのうち、同名の列が実在するものだけをマッピングする。
+    さらに`static_columns`（`--column`）を、values由来の列名と衝突しない範囲で追加する。
+    """
+    mapped = [values_col.name]
+    warnings: list[str] = []
+
+    if "label" in columns_by_name:
+        mapped.append("label")
+
+    extra_keys: dict[str, None] = {}
+    for entry in values_col.values:
+        for key in entry.extra:
+            extra_keys.setdefault(key, None)
+
+    for key in extra_keys:
+        if key in columns_by_name:
+            mapped.append(key)
+        else:
+            warnings.append(
+                f"table {table_name!r}: values の extra キー {key!r} に対応する列が見つからないため無視します"
+            )
+
+    static_values: dict[str, str] = {}
+    for name, value in static_columns.items():
+        if name in mapped:
+            warnings.append(
+                f"table {table_name!r}: --column {name!r} は values 由来の列と同名のため無視します"
+            )
+            continue
+        if name in columns_by_name:
+            mapped.append(name)
+            static_values[name] = value
+        # 対象テーブルに列が無ければサイレントにスキップ（複数テーブルへのブロードキャストを前提）
+
+    return mapped, static_values, warnings
+
+
+def _ordered_rows(values: tuple[CodeValue, ...]) -> list[CodeValue]:
+    if all("sort_order" in v.extra for v in values):
+        return sorted(values, key=_sort_order_key)
+    return list(values)
+
+
+def _sort_order_key(v: CodeValue) -> Any:
+    return v.extra["sort_order"]
+
+
+def _render_row(
+    values_col: ColumnDef,
+    entry: CodeValue,
+    mapped_names: list[str],
+    columns_by_name: dict[str, ColumnDef],
+    static_values: dict[str, str],
+) -> list[str]:
+    literals = []
+    for name in mapped_names:
+        if name == values_col.name:
+            value = entry.code
+        elif name == "label":
+            value = entry.label
+        elif name in static_values:
+            value = static_values[name]
+        else:
+            value = entry.extra.get(name)
+        literals.append(_render_literal(value, columns_by_name[name].sql_def))
+    return literals
+
+
+def _render_literal(value: object, sql_def: str) -> str:
+    if value is None:
+        return "NULL"
+    base_type = _base_sql_type(sql_def)
+    if isinstance(value, bool):
+        return "1" if value else "0"
+    if base_type in _TEXT_SQL_TYPES or base_type in _DATE_SQL_TYPES or isinstance(value, str):
+        return f"'{_escape(str(value))}'"
+    return str(value)
+
+
+def _base_sql_type(sql_def: str) -> str:
+    token = sql_def.split()[0] if sql_def else ""
+    return token.split("(")[0].upper()
+
+
+def _render_mysql_upsert(
+    table_name: str, columns: list[str], value_rows: list[list[str]], key_columns: list[str]
+) -> str:
+    update_columns = [c for c in columns if c not in key_columns]
+    column_list = ", ".join(_quote_ident(c, dialect="mysql") for c in columns)
+    values_block = ",\n".join(f"  ({', '.join(row)})" for row in value_rows)
+    sql = f"INSERT INTO {_quote_ident(table_name, dialect='mysql')} ({column_list})\nVALUES\n{values_block}"
+    if update_columns:
+        update_clause = ",\n".join(
+            f"  {_quote_ident(c, dialect='mysql')} = VALUES({_quote_ident(c, dialect='mysql')})"
+            for c in update_columns
+        )
+        sql += f"\nON DUPLICATE KEY UPDATE\n{update_clause}"
+    return sql + "\n;"
+
+
+def _render_sqlite_upsert(
+    table_name: str, columns: list[str], value_rows: list[list[str]], key_columns: list[str]
+) -> str:
+    update_columns = [c for c in columns if c not in key_columns]
+    column_list = ", ".join(_quote_ident(c, dialect="sqlite") for c in columns)
+    values_block = ",\n".join(f"  ({', '.join(row)})" for row in value_rows)
+    conflict_columns = ", ".join(_quote_ident(c, dialect="sqlite") for c in key_columns)
+    sql = f"INSERT INTO {_quote_ident(table_name, dialect='sqlite')} ({column_list})\nVALUES\n{values_block}"
+    sql += f"\nON CONFLICT({conflict_columns})"
+    if update_columns:
+        update_clause = ",\n".join(
+            f"  {_quote_ident(c, dialect='sqlite')} = excluded.{_quote_ident(c, dialect='sqlite')}"
+            for c in update_columns
+        )
+        sql += f" DO UPDATE SET\n{update_clause}"
+    else:
+        sql += " DO NOTHING"
+    return sql + "\n;"
+
+
+def _quote_ident(name: str, *, dialect: str) -> str:
+    if _SAFE_BARE_IDENTIFIER_RE.match(name) and not name.isdigit():
+        return name
+    if dialect == "sqlite":
+        return f'"{name.replace(chr(34), chr(34) * 2)}"'
+    return f"`{name.replace('`', '``')}`"
+
+
+def _escape(s: str) -> str:
+    return s.replace("'", "''")