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

frontend/pages/convert.py

@@ -0,0 +1,283 @@
+"""Convert Workspace for SQL Dialect Master v2.
+
+This is the primary workspace — a professional SQL IDE-style interface
+for dialect conversion with semantic analysis integration.
+
+Fixes the batch conversion bug from v1: properly delegates statement
+splitting to the canonical backend API.
+"""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import streamlit as st
+
+from frontend.app_context_v2 import (
+    DIALECTS,
+    batch_convert_sql,
+    convert_sql,
+    copy_sql,
+    format_sql_local,
+    split_sql_statements,
+)
+from frontend.core.design_tokens import (
+    ColorTokens,
+)
+from frontend.core.escaping import esc
+from frontend.core.navigation import create_navigation_intent
+from frontend.core.state import SessionState
+from frontend.core.viewmodels import (
+    BatchConversionViewModel,
+    ConversionViewModel,
+)
+from frontend.ui.status import render_batch_result, render_result_panel
+
+
+def render_convert_page(theme: ColorTokens) -> None:
+    """Render the Convert workspace page."""
+    state = SessionState.get()
+
+    # ── Toolbar ──────────────────────────────────────────────────────
+    _render_toolbar(theme)
+
+    # ── Dialect selectors + SQL editors ────────────────────────────
+    src_dialect = st.selectbox(
+        "Source dialect",
+        DIALECTS,
+        index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+        key="convert_src",
+        label_visibility="collapsed",
+    )
+    tgt_dialect = st.selectbox(
+        "Target dialect",
+        DIALECTS,
+        index=DIALECTS.index("mysql") if "mysql" in DIALECTS else 0,
+        key="convert_tgt",
+        label_visibility="collapsed",
+    )
+
+    # Swap button between selectors
+    col_swap, _ = st.columns([1, 10])
+    with col_swap:
+        if st.button("⇄", key="swap_dialects", help="Swap source and target dialects"):
+            st.session_state.convert_src, st.session_state.convert_tgt = st.session_state.convert_tgt, st.session_state.convert_src
+            st.rerun()
+
+    # ── SQL editors (two-panel) ────────────────────────────────────
+    col_src, col_tgt = st.columns([1, 1])
+
+    with col_src:
+        st.markdown(
+            f'<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+            f'text-transform:uppercase; color:{theme.text_muted}; margin-bottom:6px;">'
+            f'Source · {esc(src_dialect.upper())}</div>',
+            unsafe_allow_html=True,
+        )
+        src_sql = st.text_area(
+            "Source SQL",
+            key="convert_src_sql",
+            height=300,
+            placeholder="SELECT * FROM users WHERE created_at > NOW() - INTERVAL '7 days'",
+            label_visibility="collapsed",
+        )
+
+        col_fmt, col_clear = st.columns([1, 1])
+        with col_fmt:
+            if st.button("Format", key="format_src", use_container_width=True, type="secondary"):
+                formatted = format_sql_local(src_sql, src_dialect)
+                st.session_state.convert_src_sql = formatted
+                st.rerun()
+        with col_clear:
+            if st.button("Clear", key="clear_src", use_container_width=True):
+                st.session_state.convert_src_sql = ""
+                st.rerun()
+
+    with col_tgt:
+        st.markdown(
+            f'<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+            f'text-transform:uppercase; color:{theme.text_muted}; margin-bottom:6px;">'
+            f'Target · {esc(tgt_dialect.upper())}</div>',
+            unsafe_allow_html=True,
+        )
+
+        # Show converted SQL or placeholder
+        target_sql_display = state.convert_target_sql
+        if target_sql_display:
+            st.code(target_sql_display, language="sql")
+            col_copy, col_dl = st.columns([1, 1])
+            with col_copy:
+                copy_sql(target_sql_display, key="copy_tgt")
+            with col_dl:
+                st.download_button(
+                    "Download",
+                    target_sql_display,
+                    "converted.sql",
+                    mime="text/sql",
+                    key="download_tgt_sql",
+                )
+        else:
+            st.markdown(
+                f'<div style="border:1px dashed {theme.border}; border-radius:6px; '
+                f'padding:40px; text-align:center; color:{theme.text_muted};">'
+                f'Converted SQL will appear here</div>',
+                unsafe_allow_html=True,
+            )
+
+    # ── Convert button ─────────────────────────────────────────────
+    convert_clicked = st.button("Convert", key="convert_btn", type="primary", use_container_width=True)
+
+    if convert_clicked and src_sql.strip():
+        with st.spinner("Converting..."):
+            result = convert_sql(src_sql, src_dialect, tgt_dialect)
+
+        vm = ConversionViewModel.from_transpile_result(result)
+        state.convert_last_vm = vm
+        state.convert_target_sql = vm.target_sql or ""
+
+        # Add to history
+        _add_to_history(state, vm, theme)
+        st.rerun()
+    elif convert_clicked and not src_sql.strip():
+        st.warning("Please enter SQL to convert.")
+
+    # ── Result display ─────────────────────────────────────────────
+    vm: ConversionViewModel | None = state.convert_last_vm
+    if vm is not None:
+        st.markdown("---")
+        render_result_panel(
+            sql=vm.target_sql or "",
+            source_dialect=vm.source_dialect,
+            target_dialect=vm.target_dialect,
+            warnings=vm.warnings,
+            transformations=vm.transformations,
+            compatibility_notes=vm.compatibility_notes,
+            error_message=vm.error_message,
+            semantic_label=vm.semantic_label,
+            semantic_status=vm.semantic_status,
+            theme=theme,
+            target_validation_state=vm.target_validation_state,
+        )
+
+        # Navigate to Diff workspace
+        if vm.target_sql and vm.success:
+            col_diff, _ = st.columns([1, 3])
+            with col_diff:
+                if st.button("Semantic Diff →", key="run_semantic_diff", type="secondary", use_container_width=True):
+                    intent = create_navigation_intent(
+                        target_page="diff",
+                        action="open_diff",
+                        source=vm.source_sql,
+                        target=vm.target_sql,
+                        src_dialect=vm.source_dialect,
+                        tgt_dialect=vm.target_dialect,
+                    )
+                    st.session_state.sdm_navigation_intent = intent
+                    st.rerun()
+
+    # ── Batch conversion ───────────────────────────────────────────
+    with st.expander("Batch Conversion", expanded=False):
+        _render_batch_section(src_dialect, tgt_dialect, theme)
+
+
+def _render_toolbar(theme: ColorTokens) -> None:
+    """Render the top toolbar for the Convert page."""
+    st.markdown(
+        f"""
+        <div style="display:flex; align-items:center; justify-content:space-between;
+                    padding:12px 0; margin-bottom:16px; border-bottom:1px solid {theme.border};">
+            <div>
+                <div style="font-size:18px; font-weight:700; color:{theme.text_primary};">
+                    Convert
+                </div>
+                <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                    Transform SQL between database dialects
+                </div>
+            </div>
+            <div style="display:flex; gap:8px;">
+                <span style="font-size:11px; color:{theme.text_muted}; font-family:monospace;">
+                    Click Convert to run
+                </span>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _render_batch_section(src_dialect: str, tgt_dialect: str, theme: ColorTokens) -> None:
+    """Render the batch conversion section."""
+    state = SessionState.get()
+    st.markdown(
+        '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+        'text-transform:uppercase; color:' + theme.text_muted + '; margin-bottom:8px;">'
+        'Batch Mode</div>',
+        unsafe_allow_html=True,
+    )
+
+    batch_sql = st.text_area(
+        "Enter SQL statements (one per line or separated by semicolons)",
+        key="batch_sql_input",
+        height=150,
+        placeholder="SELECT * FROM users;\nSELECT id, name FROM orders WHERE status = 'active';",
+    )
+
+    col_bs, col_bt, col_bb = st.columns([1, 1, 2])
+    with col_bs:
+        batch_src = st.selectbox("Source", DIALECTS, index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+                                   key="batch_src", label_visibility="collapsed")
+    with col_bt:
+        batch_tgt = st.selectbox("Target", DIALECTS, index=DIALECTS.index("mysql") if "mysql" in DIALECTS else 0,
+                                   key="batch_tgt", label_visibility="collapsed")
+    with col_bb:
+        if st.button("Convert All", key="batch_convert_btn", type="primary", use_container_width=True):
+            if not batch_sql.strip():
+                st.warning("Please enter SQL statements.")
+            else:
+                with st.spinner("Batch converting..."):
+                    # Use canonical backend for proper semicolon splitting
+                    statements = split_sql_statements(batch_sql, batch_src)
+                    results = batch_convert_sql(statements, batch_src, batch_tgt)
+                    bvm = BatchConversionViewModel.from_results(statements, results)
+                    state.batch_last_vm = bvm
+                st.rerun()
+
+    bvm: BatchConversionViewModel | None = state.batch_last_vm
+    if bvm is not None:
+        render_batch_result(
+            total=bvm.total,
+            succeeded=bvm.succeeded,
+            failed=bvm.failed,
+            items=bvm.items,
+            theme=theme,
+        )
+
+        # Download all
+        combined = "\n\n".join(
+            item.converted_sql or f"-- Statement {item.statement_index} failed"
+            for item in bvm.items
+        )
+        st.download_button(
+            "Download All",
+            combined,
+            "batch_converted.sql",
+            mime="text/sql",
+            use_container_width=True,
+        )
+
+
+def _add_to_history(
+    state: SessionState,
+    vm: ConversionViewModel,
+    theme: ColorTokens,
+) -> None:
+    """Add a successful conversion to session history via SessionState."""
+    if not vm.success:
+        return
+    state.add_history_entry(
+        sql=vm.source_sql,
+        source_dialect=vm.source_dialect,
+        target_dialect=vm.target_dialect,
+        result_sql=vm.target_sql,
+        status=vm.status,
+        created_at=datetime.now(UTC).isoformat(),
+    )

frontend/pages/diff.py

@@ -0,0 +1,157 @@
+"""Semantic Diff Workspace for SQL Dialect Master v2.
+
+Full workspace with:
+- Overall semantic classification banner
+- Finding list (clickable, with severity indicators)
+- Inspector panel (shows selected finding details)
+- Semantic vs Text diff tab switcher
+- Integration with Convert workspace via unified NavigationIntent
+"""
+from __future__ import annotations
+
+import streamlit as st
+
+from backend.core.semantic_diff import diff_sql_ast
+from frontend.app_context_v2 import DIALECTS
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.navigation import consume_navigation_intent
+from frontend.core.state import SessionState
+from frontend.core.viewmodels import SemanticDiffViewModel
+
+_FINDING_KEY = "sdm_selected_finding_index"
+
+
+def render_diff_page(theme: ColorTokens) -> None:
+    """Render the Semantic Diff workspace."""
+    state = SessionState.get()
+
+    _render_header(theme)
+    _render_input_section(theme)
+
+    # Process navigation intent from Convert → Diff handoff
+    intent = consume_navigation_intent()
+    if intent and intent.action == "open_diff" and not state.diff_last_vm:
+        st.session_state.diff_src_sql = intent.get_payload("source", "")
+        st.session_state.diff_tgt_sql = intent.get_payload("target", "")
+        st.session_state.diff_src_dialect = intent.get_payload("src_dialect", "postgres")
+        st.session_state.diff_tgt_dialect = intent.get_payload("tgt_dialect", "mysql")
+        state.selected_finding_index = None
+
+    # Get saved inputs (widget keys — managed by Streamlit)
+    src_sql = st.session_state.get("diff_src_sql", "")
+    tgt_sql = st.session_state.get("diff_tgt_sql", "")
+
+    # Render results if available
+    vm: SemanticDiffViewModel | None = state.diff_last_vm
+    if vm is not None:
+        selected_idx = state.selected_finding_index
+        _render_results(vm, src_sql, tgt_sql, selected_idx, 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};">
+                Semantic Diff
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                AST-based semantic equivalence analysis between two SQL statements
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _render_input_section(theme: ColorTokens) -> None:
+    """Render the SQL input section."""
+    col_src, col_tgt = st.columns(2)
+
+    with col_src:
+        st.markdown(
+            '<div style="font-size:11px; font-weight:600; letter-spacing:0.06em; '
+            'text-transform:uppercase; color:' + theme.text_muted + '; margin-bottom:6px;">'
+            'Source SQL</div>',
+            unsafe_allow_html=True,
+        )
+        st.text_area(
+            "Source",
+            key="diff_src_sql",
+            height=160,
+            label_visibility="collapsed",
+            placeholder="SELECT DATE_ADD(created_at, INTERVAL 7 DAY) FROM users",
+        )
+        st.selectbox(
+            "Dialect",
+            DIALECTS,
+            key="diff_src_dialect",
+            label_visibility="collapsed",
+        )
+
+    with col_tgt:
+        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 SQL</div>',
+            unsafe_allow_html=True,
+        )
+        st.text_area(
+            "Target",
+            key="diff_tgt_sql",
+            height=160,
+            label_visibility="collapsed",
+            placeholder="SELECT created_at + INTERVAL '7 days' FROM users",
+        )
+        st.selectbox(
+            "Dialect",
+            DIALECTS,
+            key="diff_tgt_dialect",
+            label_visibility="collapsed",
+        )
+
+    # Compare button
+    col_btn, _ = st.columns([1, 5])
+    with col_btn:
+        if st.button("Compare", type="primary", key="diff_compare", use_container_width=True):
+            _run_comparison(theme)
+
+
+def _run_comparison(theme: ColorTokens) -> None:
+    """Run semantic diff and store result in session state."""
+    state = SessionState.get()
+    src_sql = st.session_state.get("diff_src_sql", "")
+    tgt_sql = st.session_state.get("diff_tgt_sql", "")
+    src_dialect = st.session_state.get("diff_src_dialect", "postgres")
+    tgt_dialect = st.session_state.get("diff_tgt_dialect", "mysql")
+
+    if not src_sql.strip() or not tgt_sql.strip():
+        st.warning("Please enter both SQL statements.")
+        return
+
+    with st.spinner("Analyzing semantic equivalence..."):
+        backend_result = diff_sql_ast(src_sql, tgt_sql, src_dialect, tgt_dialect)
+
+    vm = SemanticDiffViewModel.from_backend(
+        source_sql=src_sql,
+        target_sql=tgt_sql,
+        source_dialect=src_dialect,
+        target_dialect=tgt_dialect,
+        diff=backend_result,
+    )
+    state.diff_last_vm = vm
+    state.clear_finding_selection()
+    st.rerun()
+
+
+def _render_results(
+    vm: SemanticDiffViewModel,
+    source_sql: str,
+    target_sql: str,
+    selected_idx: int | None,
+    theme: ColorTokens,
+) -> None:
+    """Render the diff results with finding list and inspector."""
+    from frontend.ui.diff import render_semantic_diff_workspace
+    render_semantic_diff_workspace(vm, source_sql, target_sql, theme, selected_idx)

frontend/pages/functions.py

@@ -0,0 +1,100 @@
+"""Function Library page for SQL Dialect Master v2."""
+from __future__ import annotations
+
+import streamlit as st
+
+from frontend.app_context_v2 import get_page_data
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+
+CATEGORY_ICONS = {
+    "string": "S",
+    "date": "D",
+    "math": "M",
+    "aggregate": "A",
+    "window": "W",
+    "conditional": "C",
+    "conversion": "V",
+    "json": "J",
+    "array": "L",
+    "system": "Y",
+    "geo": "G",
+}
+
+
+def render_functions_page(theme: ColorTokens) -> None:
+    """Render the Function Library page.
+
+    Data is injected by the page registry via ``get_page_data()`` — the
+    renderer keeps the unified PageRenderer contract of receiving only
+    the active theme.
+    """
+    data = get_page_data()
+    funcs_data = data.funcs_data
+
+    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};">
+                Function Library
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Search and compare SQL functions across dialects
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    all_funcs = funcs_data.get("functions", [])
+
+    # Search and filter
+    col_search, col_cat = st.columns([2, 1])
+    with col_search:
+        query = st.text_input("Search", key="func_search", placeholder="Type function name...", label_visibility="collapsed")
+    with col_cat:
+        categories = sorted({f.get("category", "other") for f in all_funcs})
+        cat_options = ["All"] + categories
+        selected_cat = st.selectbox("Category", cat_options, key="func_cat")
+
+    # Filter
+    funcs = all_funcs
+    if query:
+        q = query.lower()
+        funcs = [f for f in funcs if q in f.get("name", "").lower() or q in f.get("description", "").lower()]
+    if selected_cat != "All":
+        funcs = [f for f in funcs if f.get("category", "") == selected_cat]
+
+    st.caption(f"{len(funcs)} functions" + (f" matching '{esc(query)}'" if query else ""))
+
+    if not funcs:
+        st.info("No functions found.")
+        return
+
+    # Display as compact table
+    for f in funcs[:50]:
+        _render_function_row(f, theme)
+
+
+def _render_function_row(func: dict, theme: ColorTokens) -> None:
+    """Render a single function row in the library table."""
+    name = esc(func.get("name", ""))
+    category = func.get("category", "other")
+    icon = CATEGORY_ICONS.get(category, "?")
+    description = esc(func.get("description", ""))
+    dialect_count = len(func.get("dialects", {}))
+
+    with st.expander(f"**{name}** · `{icon}` {esc(category.title())} · {dialect_count} dialects", expanded=False):
+        st.markdown(f"**{description}**")
+
+        dialects = func.get("dialects", {})
+        if dialects:
+            st.markdown("**Syntax by Database:**")
+            items = list(dialects.items())
+            for i in range(0, len(items), 3):
+                cols = st.columns(min(3, len(items) - i))
+                for j, (dialect, syntax) in enumerate(items[i:i+3]):
+                    with cols[j]:
+                        st.markdown(
+                            f'**{esc(dialect.upper())}**\n`{esc(syntax)}`'
+                        )

frontend/pages/history.py

@@ -0,0 +1,144 @@
+"""History page for SQL Dialect Master v2."""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import streamlit as st
+
+from frontend.app_context_v2 import copy_sql
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+from frontend.core.state import SessionState
+
+
+def render_history_page(theme: ColorTokens) -> None:
+    """Render the History page."""
+    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};">
+                History
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Recent conversions and saved queries
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    history = state.history
+
+    if not history:
+        st.info("No conversion history yet.")
+        return
+
+    # Search and filter controls (widget keys — managed by Streamlit)
+    col_search, col_filter = st.columns([2, 1])
+    with col_search:
+        search = st.text_input("Search", key="hist_search", placeholder="Search SQL...", label_visibility="collapsed")
+    with col_filter:
+        filter_status = st.selectbox("Status", ["All", "Success", "Error"], key="hist_filter")
+
+    # Apply filters
+    filtered = history
+    if search:
+        s = search.lower()
+        filtered = [h for h in filtered if s in h.get("sql", "").lower()]
+    if filter_status == "Success":
+        filtered = [h for h in filtered if h.get("status") == "valid"]
+    elif filter_status == "Error":
+        filtered = [h for h in filtered if h.get("status") == "error"]
+
+    st.caption(f"{len(filtered)} entries")
+
+    # Render entries
+    for entry in filtered:
+        _render_history_entry(state, entry, theme)
+
+
+def _render_history_entry(
+    state: SessionState,
+    entry: dict,
+    theme: ColorTokens,
+) -> None:
+    """Render a single history entry."""
+    src = esc(entry.get("src", "unknown"))
+    tgt = esc(entry.get("tgt", "unknown"))
+    sql_preview = esc(entry.get("sql", "")[:80])
+    if len(entry.get("sql", "")) > 80:
+        sql_preview += "..."
+    status = entry.get("status", "neutral")
+    created_at = entry.get("created_at", "")
+    identity = entry.get("identity", "")
+
+    # Status badge color
+    if status == "valid":
+        status_color = theme.success
+        status_text = "✓ Valid"
+    elif status == "error":
+        status_color = theme.danger
+        status_text = "✗ Error"
+    else:
+        status_color = theme.text_muted
+        status_text = "—"
+
+    # Time ago
+    time_str = _format_time_ago(created_at) if created_at else "recent"
+
+    with st.expander(f"{src} → {tgt} · {time_str}", expanded=False):
+        st.markdown(
+            f'<div style="display:flex; align-items:center; gap:8px; margin-bottom:8px;">'
+            f'<span style="color:{status_color}; font-size:11px; font-weight:600;">{status_text}</span>'
+            f'</div>',
+            unsafe_allow_html=True,
+        )
+        st.code(sql_preview, language="sql")
+
+        col_load, col_copy, col_fav, col_del = st.columns([1, 1, 1, 1])
+        with col_load:
+            if st.button("Load", key=f"hist_load_{identity}"):
+                from frontend.core.navigation import create_navigation_intent
+                intent = create_navigation_intent(
+                    target_page="convert",
+                    action="open_conversion",
+                    sql=entry.get("sql", ""),
+                    dialect=entry.get("src", "postgres"),
+                    origin="history",
+                )
+                st.session_state.sdm_navigation_intent = intent
+                st.rerun()
+        with col_copy:
+            if st.button("Copy", key=f"hist_copy_{identity}"):
+                copy_sql(entry.get("sql", ""), key=f"hist_copy_sql_{identity}")
+        with col_fav:
+            if not state.is_favorite(identity):
+                if st.button("☆", key=f"hist_fav_{identity}"):
+                    state.add_favorite(identity)
+                    st.rerun()
+            else:
+                st.button("★", key=f"hist_fav_{identity}", disabled=True)
+        with col_del:
+            if st.button("Del", key=f"hist_del_{identity}"):
+                state.remove_history_entry(identity)
+                st.rerun()
+
+
+def _format_time_ago(iso_str: str) -> str:
+    """Format an ISO timestamp as 'X minutes ago' etc."""
+    try:
+        dt = datetime.fromisoformat(iso_str)
+        delta = datetime.now(UTC) - dt
+        seconds = int(delta.total_seconds())
+        if seconds < 60:
+            return f"{seconds}s ago"
+        elif seconds < 3600:
+            return f"{seconds // 60}m ago"
+        elif seconds < 86400:
+            return f"{seconds // 3600}h ago"
+        else:
+            return f"{seconds // 86400}d ago"
+    except (ValueError, TypeError):
+        return "recent"