sql-dialect-master 1.1.1__py3-none-any.whl

frontend/pages/lineage.py

@@ -0,0 +1,168 @@
+"""Lineage Workspace for SQL Dialect Master v2."""
+from __future__ import annotations
+
+import sqlglot
+import streamlit as st
+
+from frontend.app_context_v2 import DIALECTS, get_dialect_label
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+from frontend.core.state import SessionState
+from frontend.core.viewmodels import (
+    LineageOutputColumn,
+    LineageTable,
+    LineageViewModel,
+    sanitize_mermaid_id,
+    sanitize_mermaid_label,
+)
+
+
+def render_lineage_page(theme: ColorTokens) -> None:
+    """Render the Lineage workspace."""
+    state = SessionState.get()
+
+    st.markdown(
+        f"""
+        <div style="padding:12px 0; margin-bottom:16px; border-bottom:1px solid {theme.border};">
+            <div style="font-size:18px; font-weight:700; color:{theme.text_primary};">Lineage</div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Table dependencies and column references from AST analysis
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    dialect = st.selectbox(
+        "SQL Dialect",
+        DIALECTS,
+        index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+        format_func=get_dialect_label,
+        key="lineage_dialect",
+    )
+
+    sql = st.text_area(
+        "SQL",
+        key="lineage_sql",
+        height=180,
+        placeholder="SELECT u.name AS user_name, COUNT(o.id) AS order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id GROUP BY u.name",
+    )
+
+    if st.button("Analyze", type="primary", key="lineage_analyze", use_container_width=True):
+        if not sql.strip():
+            st.warning("Please enter SQL to analyze.")
+        else:
+            try:
+                vm = _build_lineage(sql, dialect)
+                state.lineage_last_vm = vm
+                st.rerun()
+            except Exception as e:  # noqa: BLE001
+                st.error(f"Parse error: {esc(str(e))}")
+
+    vm: LineageViewModel | None = state.lineage_last_vm
+    if vm is None:
+        return
+
+    col_diagram, col_details = st.columns([2, 1])
+
+    with col_diagram:
+        st.markdown("### Lineage Diagram")
+        mermaid = _build_mermaid(vm)
+        st.markdown(mermaid)
+
+    with col_details:
+        st.markdown("### Tables")
+        for t in vm.tables:
+            alias_str = f" as {esc(t.alias)}" if t.alias and t.alias != t.name else ""
+            st.caption(f"`{esc(t.name)}`{alias_str}")
+
+        st.markdown("### Output Columns")
+        for oc in vm.output_columns:
+            st.caption(f"`{esc(oc.name)}`")
+            if oc.expression:
+                st.caption(f"  Expr: {esc(oc.expression)}")
+
+        if vm.column_references:
+            st.markdown("### Column References")
+            for tbl, cols in list(vm.column_references.items())[:5]:
+                st.caption(f"**{esc(tbl)}**: {', '.join(esc(c) for c in cols)}")
+
+
+def _build_lineage(sql: str, dialect: str) -> LineageViewModel:
+    """Build a LineageViewModel from SQL using sqlglot AST."""
+    parsed = sqlglot.parse_one(sql, read=dialect)
+
+    # Extract tables
+    tables = []
+    seen = set()
+    for t in parsed.find_all(sqlglot.exp.Table):
+        name = t.name
+        alias = t.alias or name
+        if name not in seen:
+            tables.append(LineageTable(name=name, alias=alias))
+            seen.add(name)
+
+    # Extract output columns from SELECT
+    output_columns = []
+    select = parsed.find(sqlglot.exp.Select)
+    if select:
+        for expr in select.expressions:
+            alias = getattr(expr, 'alias', None)
+            col_name = alias if alias else getattr(expr, 'name', None)
+            if col_name:
+                output_columns.append(LineageOutputColumn(
+                    name=str(col_name),
+                    expression=str(expr),
+                ))
+
+    # Extract column references
+    col_refs: dict[str, list[str]] = {}
+    for col in parsed.find_all(sqlglot.exp.Column):
+        table_ref = col.table or "unknown"
+        if table_ref not in col_refs:
+            col_refs[table_ref] = []
+        if col.name not in col_refs[table_ref]:
+            col_refs[table_ref].append(col.name)
+
+    return LineageViewModel(
+        dialect=dialect,
+        sql=sql,
+        tables=tables,
+        output_columns=output_columns,
+        column_references=col_refs,
+    )
+
+
+def _build_mermaid(vm: LineageViewModel) -> str:
+    """Build a Mermaid flowchart from LineageViewModel."""
+    lines = ["```mermaid", "flowchart LR"]
+
+    # Source tables
+    lines.append("    subgraph sources[\"Sources\"]")
+    for t in vm.tables:
+        safe_id = sanitize_mermaid_id(t.name)
+        lines.append(f"        {safe_id}[\"{esc(sanitize_mermaid_label(t.name))}\"]")
+    lines.append("    end")
+
+    # Query node
+    lines.append('    QUERY{"SQL Query"}')
+
+    # Output
+    lines.append("    subgraph output[\"Output\"]")
+    lines.append('        RESULT["Result Set"]')
+    for oc in vm.output_columns[:6]:
+        safe_id = sanitize_mermaid_id(oc.name)
+        lines.append(f"        {safe_id}[\"{esc(sanitize_mermaid_label(oc.name))}\"]")
+    lines.append("    end")
+
+    # Edges
+    for t in vm.tables:
+        safe_id = sanitize_mermaid_id(t.name)
+        lines.append(f"    {safe_id} --> QUERY")
+    lines.append("    QUERY --> RESULT")
+    for oc in vm.output_columns[:6]:
+        safe_id = sanitize_mermaid_id(oc.name)
+        lines.append(f"    RESULT --> {safe_id}")
+
+    lines.append("```")
+    return "\n".join(lines)

frontend/pages/nl2sql.py

@@ -0,0 +1,305 @@
+"""NL2SQL Workspace for SQL Dialect Master v2.
+
+Professional workspace for natural-language-to-SQL generation.
+Shows result with confidence, explanation, parsed elements, and
+conversion/diff handoff buttons.
+"""
+from __future__ import annotations
+
+import streamlit as st
+
+from frontend.app_context_v2 import DIALECTS, copy_sql, generate_nl2sql, get_dialect_label
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+from frontend.core.state import SessionState
+from frontend.core.viewmodels import NL2SQLViewModel
+
+# ── Example queries (no emoji) ─────────────────────────────────────────
+
+EXAMPLE_QUERIES: dict[str, str] = {
+    "Count all users": "统计所有用户的数量",
+    "Date filter": "查询最近7天的订单",
+    "Conditional": "查询金额大于100的订单",
+    "Group by": "按部门分组统计员工数量",
+    "Order and limit": "查询前10个用户按得分降序排列",
+    "Join query": "查询用户和订单关联的数据",
+    "Average": "查询员工的平均薪资",
+    "Like search": "查询名字包含张的用户",
+    "This month": "查询本月所有订单的总金额",
+    "Top N": "查询销售额最高的前5个产品",
+}
+
+
+def render_nl2sql_page(theme: ColorTokens) -> None:
+    """Render the NL2SQL workspace."""
+    state = SessionState.get()
+
+    _render_header(theme)
+    _render_input_section(theme)
+    _render_result_section(state, theme)
+
+
+def _render_header(theme: ColorTokens) -> None:
+    """Render the page header."""
+    st.markdown(
+        f"""
+        <div style="padding:12px 0; margin-bottom:16px; border-bottom:1px solid {theme.border};">
+            <div style="font-size:18px; font-weight:700; color:{theme.text_primary};">
+                NL2SQL
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Generate SQL from natural language descriptions
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _render_input_section(theme: ColorTokens) -> None:
+    """Render the input section: NL text, dialect, table hint."""
+    col_nl, col_dialect = st.columns([3, 1])
+
+    with col_nl:
+        # Example selector
+        examples = list(EXAMPLE_QUERIES.keys())
+        selected_example = st.selectbox(
+            "Quick example",
+            [""] + examples,
+            key="nl_example_sel",
+            label_visibility="collapsed",
+        )
+        if selected_example:
+            st.session_state.nl_input_text = EXAMPLE_QUERIES[selected_example]
+
+        st.text_area(
+            "Describe your query",
+            key="nl_input_text",
+            height=100,
+            label_visibility="collapsed",
+            placeholder="e.g., Get users who placed orders in the last 7 days",
+        )
+
+    with col_dialect:
+        st.markdown(
+            '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+            'text-transform:uppercase; color:' + theme.text_muted + '; margin-bottom:6px;">'
+            'Target dialect</div>',
+            unsafe_allow_html=True,
+        )
+        st.selectbox(
+            "Dialect",
+            DIALECTS,
+            index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+            format_func=get_dialect_label,
+            key="nl_dialect",
+        )
+
+    # Table hint + generate
+    col_hint, col_gen = st.columns([3, 1])
+    with col_hint:
+        st.text_input(
+            "Table hint (optional)",
+            key="nl_table_hint",
+            label_visibility="collapsed",
+            placeholder="e.g., users, orders, products",
+        )
+    with col_gen:
+        st.markdown("")
+        if st.button("Generate SQL", type="primary", key="nl_generate", use_container_width=True):
+            _run_generation(theme)
+
+
+def _run_generation(theme: ColorTokens) -> None:
+    """Run NL2SQL generation and store result."""
+    state = SessionState.get()
+    nl_input = st.session_state.get("nl_input_text", "")
+    dialect = st.session_state.get("nl_dialect", "postgres")
+    table_hint = st.session_state.get("nl_table_hint", "")
+
+    if not nl_input.strip():
+        st.warning("Please describe your query.")
+        return
+
+    with st.spinner("Generating SQL..."):
+        result = generate_nl2sql(nl_input, dialect, table_hint or None)
+
+    vm = NL2SQLViewModel.from_nl2sql_result(result)
+    state.nl_last_vm = vm
+    state.nl_generation_error = None
+    st.rerun()
+
+
+def _render_result_section(state: SessionState, theme: ColorTokens) -> None:
+    """Render the generation result."""
+    vm: NL2SQLViewModel | None = state.nl_last_vm
+    error: str | None = state.nl_generation_error
+
+    if error:
+        st.error(f"Generation failed: {esc(error)}")
+        return
+
+    if vm is None:
+        return
+
+    if not vm.success:
+        st.error(f"Generation failed: {esc(vm.explanation or 'No SQL produced')}")
+        return
+
+    _render_generated_sql(vm, theme)
+    _render_confidence(vm, theme)
+    _render_explanation(vm, theme)
+    _render_parsed_elements(vm, theme)
+    _render_action_buttons(vm, theme)
+
+
+def _render_generated_sql(vm: NL2SQLViewModel, theme: ColorTokens) -> None:
+    """Render the generated SQL code block."""
+    sql = vm.clean_sql()
+    if not sql:
+        return
+
+    st.markdown(
+        '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+        'text-transform:uppercase; color:' + theme.text_muted + '; margin:16px 0 8px;">'
+        'Generated SQL</div>',
+        unsafe_allow_html=True,
+    )
+    st.code(sql, language="sql")
+
+
+def _render_confidence(vm: NL2SQLViewModel, theme: ColorTokens) -> None:
+    """Render the overall confidence indicator."""
+    level_colors = {
+        "high": theme.success,
+        "review": theme.warning,
+        "low": theme.danger,
+    }
+    color = level_colors.get(vm.confidence_level, theme.text_muted)
+
+    st.markdown(
+        '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+        'text-transform:uppercase; color:' + theme.text_muted + '; margin:12px 0 8px;">'
+        'Confidence</div>',
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        f"""
+        <div style="display:flex; align-items:center; gap:12px; padding:8px 12px;
+                    background:{color}12; border:1px solid {color}30; border-radius:6px;">
+            <span style="font-size:20px; font-weight:700; color:{color}; font-family:monospace;">
+                {vm.confidence:.0%}
+            </span>
+            <span style="font-size:12px; color:{color}; font-weight:500;">
+                {esc(vm.confidence_label)}
+            </span>
+            <span style="font-size:11px; color:{theme.text_muted}; margin-left:auto;">
+                Overall
+            </span>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _render_explanation(vm: NL2SQLViewModel, theme: ColorTokens) -> None:
+    """Render the generation explanation."""
+    if not vm.explanation:
+        return
+
+    st.markdown(
+        '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+        'text-transform:uppercase; color:' + theme.text_muted + '; margin:12px 0 8px;">'
+        'Explanation</div>',
+        unsafe_allow_html=True,
+    )
+    st.info(esc(vm.explanation))
+
+
+def _render_parsed_elements(vm: NL2SQLViewModel, theme: ColorTokens) -> None:
+    """Render parsed elements: tables, columns, values."""
+    has_elements = vm.tables or vm.columns or vm.values or vm.token_count > 0
+
+    if not has_elements:
+        return
+
+    st.markdown(
+        '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+        'text-transform:uppercase; color:' + theme.text_muted + '; margin:12px 0 8px;">'
+        'Parsed Elements</div>',
+        unsafe_allow_html=True,
+    )
+
+    cols = st.columns(4)
+    with cols[0]:
+        if vm.tables:
+            st.markdown("**Tables**")
+            for t in vm.tables[:5]:
+                st.caption(f"`{esc(t)}`")
+        else:
+            st.caption("—")
+
+    with cols[1]:
+        if vm.columns:
+            st.markdown("**Columns**")
+            for c in vm.columns[:5]:
+                st.caption(f"`{esc(c)}`")
+        else:
+            st.caption("—")
+
+    with cols[2]:
+        if vm.values:
+            st.markdown("**Values**")
+            for v in vm.values[:5]:
+                st.caption(f"`{esc(v)}`")
+        else:
+            st.caption("—")
+
+    with cols[3]:
+        st.markdown("**Metadata**")
+        if vm.is_chinese:
+            st.caption("Language: Chinese")
+        st.caption(f"Tokens: {vm.token_count}")
+
+
+def _render_action_buttons(vm: NL2SQLViewModel, theme: ColorTokens) -> None:
+    """Render action buttons: Copy, Download, Open in Converter, Semantic Diff."""
+    sql = vm.clean_sql()
+    if not sql:
+        return
+
+    col_copy, col_dl, col_convert, col_diff = st.columns(4)
+
+    with col_copy:
+        copy_sql(sql)
+
+    with col_dl:
+        st.download_button("Download", sql, "generated.sql", mime="text/sql")
+
+    with col_convert:
+        if st.button("Open in Converter", key="nl_to_convert", use_container_width=True):
+            from frontend.core.navigation import create_navigation_intent
+            intent = create_navigation_intent(
+                target_page="convert",
+                action="open_conversion",
+                sql=sql,
+                dialect=vm.dialect,
+                origin="nl2sql",
+            )
+            st.session_state.sdm_navigation_intent = intent
+            st.rerun()
+
+    with col_diff:
+        if st.button("Semantic Diff", key="nl_to_diff", use_container_width=True):
+            from frontend.core.navigation import create_navigation_intent
+            intent = create_navigation_intent(
+                target_page="diff",
+                action="open_diff",
+                source=sql,
+                target=sql,
+                src_dialect=vm.dialect,
+                tgt_dialect=vm.dialect,
+            )
+            st.session_state.sdm_navigation_intent = intent
+            st.rerun()

frontend/pages/query_analysis.py

@@ -0,0 +1,120 @@
+"""Query Analysis (formerly Explain) Workspace for SQL Dialect Master v2.
+
+This is static analysis only — no real execution plans are generated.
+"""
+from __future__ import annotations
+
+import sqlglot
+import streamlit as st
+
+from frontend.app_context_v2 import DIALECTS, get_dialect_label
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+from frontend.core.state import SessionState
+
+
+def render_query_analysis_page(theme: ColorTokens) -> None:
+    """Render the Query Analysis workspace."""
+    state = SessionState.get()
+
+    st.markdown(
+        f"""
+        <div style="padding:12px 0; margin-bottom:16px; border-bottom:1px solid {theme.border};">
+            <div style="font-size:18px; font-weight:700; color:{theme.text_primary};">
+                Query Analysis
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Static structural analysis of SQL queries
+            </div>
+            <div style="font-size:11px; color:{theme.warning}; margin-top:4px;">
+                Note: This is static analysis only — not a real execution plan.
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    dialect = st.selectbox(
+        "SQL Dialect",
+        DIALECTS,
+        index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+        format_func=get_dialect_label,
+        key="qa_dialect",
+    )
+
+    sql = st.text_area(
+        "SQL",
+        key="qa_sql",
+        height=150,
+        placeholder="SELECT u.name, COUNT(o.id) AS order_count FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name ORDER BY order_count DESC LIMIT 10",
+    )
+
+    if st.button("Analyze", type="primary", key="qa_analyze", use_container_width=True):
+        if not sql.strip():
+            st.warning("Please enter SQL to analyze.")
+        else:
+            try:
+                result = _analyze_sql(sql, dialect)
+                state.qa_last_result = result
+                st.rerun()
+            except Exception as e:  # noqa: BLE001
+                st.error(f"Parse error: {esc(str(e))}")
+
+    result = state.qa_last_result
+    if result is None:
+        return
+
+    # Display results
+    cols = st.columns(4)
+    with cols[0]:
+        st.metric("Tables", len(result["tables"]))
+    with cols[1]:
+        st.metric("Joins", result["join_count"])
+    with cols[2]:
+        st.metric("Aggregation", "Yes" if result["has_aggregation"] else "No")
+    with cols[3]:
+        st.metric("Sorting", "Yes" if result["has_sorting"] else "No")
+
+    if result["tables"]:
+        st.markdown("##### Tables")
+        for t in result["tables"]:
+            st.caption(f"`{esc(t)}`")
+
+    if result["hints"]:
+        st.markdown("##### Dialect Characteristics")
+        st.caption("These are general characteristics of how this dialect handles queries, not optimizer output.")
+        for hint in result["hints"][:5]:
+            st.info(esc(hint))
+
+    if result.get("limit"):
+        st.markdown(f'**Limit:** `{esc(result["limit"])}`')
+
+
+def _analyze_sql(sql: str, dialect: str) -> dict:
+    """Perform static analysis on SQL."""
+    parsed = sqlglot.parse_one(sql, read=dialect)
+
+    tables = list({t.name for t in parsed.find_all(sqlglot.exp.Table)})
+    joins = list(parsed.find_all(sqlglot.exp.Join))
+    groups = list(parsed.find_all(sqlglot.exp.Group))
+    orders = list(parsed.find_all(sqlglot.exp.Order))
+    limit = parsed.find(sqlglot.exp.Limit)
+
+    dialect_hints: dict[str, list[str]] = {
+        "postgres": ["Seq/Index scan", "Hash/Merge join", "Parallel workers"],
+        "mysql": ["Index scan", "Nested loop join", "InnoDB buffer pool"],
+        "hive": ["MapReduce/Tez job", "Shuffle for GROUP BY"],
+        "spark": ["Exchange shuffle", "HashAggregate", "Broadcast join"],
+        "snowflake": ["Virtual warehouse", "Micro-partition pruning"],
+        "duckdb": ["Vectorized execution", "Parallel pipeline"],
+    }
+    hints = dialect_hints.get(dialect, ["Standard processing"])
+
+    return {
+        "tables": tables,
+        "join_count": len(joins),
+        "has_aggregation": bool(groups),
+        "has_sorting": bool(orders),
+        "limit": str(limit.expression) if limit else None,
+        "hints": hints,
+    }

frontend/pages/runtime.py

@@ -0,0 +1,66 @@
+"""Runtime Verification page for SQL Dialect Master v2.
+
+This page is a placeholder — real runtime verification requires a
+connected database, which is not currently available in the Streamlit
+environment. The UI clearly signals "not available" rather than
+fabricating results.
+"""
+from __future__ import annotations
+
+import streamlit as st
+
+from frontend.core.design_tokens import ColorTokens
+
+
+def render_runtime_page(theme: ColorTokens) -> None:
+    """Render the Runtime Verification page."""
+
+    st.markdown(
+        f"""
+        <div style="padding:12px 0; margin-bottom:16px; border-bottom:1px solid {theme.border};">
+            <div style="font-size:18px; font-weight:700; color:{theme.text_primary};">
+                Runtime Verification
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Execute SQL against connected databases to verify semantics
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Not available notice
+    st.markdown(
+        f"""
+        <div style="padding:24px; border:1px dashed {theme.border}; border-radius:8px;
+                    text-align:center; color:{theme.text_muted};">
+            <div style="font-size:16px; font-weight:600; margin-bottom:8px;">
+                Not Available
+            </div>
+            <div style="font-size:12px;">
+                Runtime verification requires a connected database. This feature
+                is available via the API when a database connection is configured.
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Architecture info
+    st.markdown("---")
+    st.markdown("### Architecture")
+    st.markdown(
+        f"""
+        <div style="font-size:12px; color:{theme.text_secondary}; line-height:1.8;">
+            <p>When a database connection is available, the Runtime workspace will:</p>
+            <ul style="margin:8px 0 8px 20px; padding:0;">
+                <li>Execute source and target SQL against connected databases</li>
+                <li>Compare result sets for semantic equivalence</li>
+                <li>Report execution time and row count differences</li>
+                <li>Flag cases where AST analysis was insufficient</li>
+            </ul>
+            <p style="color:{theme.text_muted};">Current status: No database connections configured.</p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )