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

frontend/pages/settings.py

@@ -0,0 +1,60 @@
+"""Settings page for SQL Dialect Master v2."""
+from __future__ import annotations
+
+import streamlit as st
+
+from backend.core import metadata as meta
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.state import SessionState
+
+
+def render_settings_page(theme: ColorTokens) -> None:
+    """Render the Settings 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};">
+                Settings
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Theme
+    st.markdown("##### Theme")
+    col_theme_sel, _ = st.columns([2, 1])
+    with col_theme_sel:
+        current = state.theme
+        selected = st.selectbox("Color theme", ["dark", "light"], index=["dark", "light"].index(current) if current in ["dark", "light"] else 0, key="settings_theme_sel")
+    with st.container():
+        if st.button("Apply Theme", key="settings_apply_theme"):
+            state.theme = selected
+            st.rerun()
+
+    # Keyboard shortcuts reference
+    st.markdown("---")
+    st.markdown("##### Notes")
+    st.markdown("""
+    Streamlit does not support native keyboard shortcuts.
+    Actions are performed via buttons and menu selections.
+    """)
+
+    # About
+    st.markdown("---")
+    st.markdown("##### About")
+    st.markdown(
+        f"""
+        **SQL Dialect Master {meta.PROJECT_VERSION}**
+
+        Professional SQL conversion workspace (Frontend v{meta.FRONTEND_ARCHITECTURE_VERSION})
+        powered by sqlglot and semantic analysis.
+
+        - {meta.SUPPORTED_DIALECTS_COUNT} supported dialects
+        - {meta.FUNCTION_COUNT}+ functions indexed
+        - {meta.TYPE_COUNT}+ type mappings
+        - Semantic diff analysis
+        """
+    )

frontend/pages/templates.py

@@ -0,0 +1,67 @@
+"""Templates page for SQL Dialect Master v2."""
+from __future__ import annotations
+
+import streamlit as st
+
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+from frontend.templates_v2 import TEMPLATES
+
+
+def render_templates_page(theme: ColorTokens) -> None:
+    """Render the Templates 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};">
+                Templates
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Quick-start SQL templates by category
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Group by category (TEMPLATES maps category -> list of (label, sql)).
+    categories: dict[str, list[tuple[str, str]]] = {}
+    for cat, items in TEMPLATES.items():
+        if isinstance(items, list):
+            categories[cat] = list(items)
+        else:
+            categories[cat] = [(cat, items)]
+
+    for cat, items in categories.items():
+        st.markdown(f"##### {esc(cat)}")
+        for label, sql in items:
+            short_label = label.replace(f"{cat} · ", "")
+            with st.expander(f"{esc(short_label)}", expanded=False):
+                st.code(esc(sql), language="sql")
+                st.button(
+                    "Use in Convert",
+                    key=_deterministic_key("tpl", f"{cat}::{label}"),
+                    on_click=_load_template,
+                    args=(sql,),
+                )
+
+
+def _deterministic_key(prefix: str, value: str) -> str:
+    """Build a stable, process-independent widget key.
+
+    ``str.hash`` is salted per process on CPython, so it must never be
+    used for Streamlit widget keys.  The previous code also applied
+    ``hash()`` to a list of template tuples, which is unhashable and
+    crashed the page at runtime.
+    """
+    import hashlib
+
+    digest = hashlib.sha1(value.encode("utf-8")).hexdigest()[:8]
+    return f"{prefix}_{digest}"
+
+
+def _load_template(sql: str) -> None:
+    """Load a template SQL into the Convert workspace."""
+    st.session_state.convert_src_sql = sql
+    st.query_params["page"] = "convert"

frontend/pages/types.py

@@ -0,0 +1,110 @@
+"""Type Mapping page for SQL Dialect Master v2."""
+from __future__ import annotations
+
+import streamlit as st
+
+from frontend.app_context_v2 import DIALECTS, get_dialect_label, get_page_data
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.escaping import esc
+
+TYPE_CATEGORIES = {
+    "String Types": ["STRING", "VARCHAR", "CHAR", "TEXT", "MEDIUMTEXT", "LONGTEXT"],
+    "Numeric Types": ["BIGINT", "INT", "SMALLINT", "TINYINT", "DOUBLE", "FLOAT", "DECIMAL", "MONEY", "SERIAL"],
+    "Boolean & Bit": ["BOOLEAN", "BIT"],
+    "Date/Time Types": ["DATE", "TIME", "TIMESTAMP", "TIMESTAMP_TZ", "INTERVAL", "YEAR"],
+    "Complex Types": ["ARRAY", "MAP", "STRUCT", "JSON", "JSONB", "XML"],
+    "Binary Types": ["BINARY"],
+    "Special Types": ["UUID", "INET", "GEOMETRY", "GEOGRAPHY", "ENUM", "SET"],
+}
+
+
+def render_types_page(theme: ColorTokens) -> None:
+    """Render the Type Mapping 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()
+    types_data = data.types_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};">
+                Type Mapping
+            </div>
+            <div style="font-size:12px; color:{theme.text_muted}; margin-top:2px;">
+                Compare data types across database dialects
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    mappings = types_data.get("mappings", {})
+
+    col_src, col_tgt = st.columns(2)
+    with col_src:
+        src_db = st.selectbox("Source", DIALECTS, index=DIALECTS.index("postgres") if "postgres" in DIALECTS else 0,
+                               format_func=get_dialect_label, key="type_src")
+    with col_tgt:
+        tgt_db = st.selectbox("Target", DIALECTS, index=DIALECTS.index("mysql") if "mysql" in DIALECTS else 0,
+                               format_func=get_dialect_label, key="type_tgt")
+
+    st.markdown(f"**{esc(src_db.upper())}** → **{esc(tgt_db.upper())}**")
+
+    # Build table data
+    table_data = []
+    for type_name, type_map in mappings.items():
+        src_type = type_map.get(src_db, "N/A")
+        tgt_type = type_map.get(tgt_db, "N/A")
+        if src_type == tgt_type:
+            status = "exact"
+        elif tgt_type != "N/A":
+            status = "mapped"
+        else:
+            status = "missing"
+        table_data.append({
+            "Type": type_name,
+            esc(src_db.upper()): src_type,
+            esc(tgt_db.upper()): tgt_type,
+            "Status": status,
+        })
+
+    # Render as dataframe
+    import pandas as pd
+    df = pd.DataFrame(table_data)
+    st.dataframe(df, use_container_width=True, hide_index=True)
+
+    # Detail explorer
+    st.markdown("---")
+    st.markdown("##### Type Details")
+
+    col_cat, col_type = st.columns([1, 2])
+    with col_cat:
+        cat_options = ["All"] + list(TYPE_CATEGORIES.keys())
+        selected_cat = st.selectbox("Category", cat_options, key="type_detail_cat")
+
+    if selected_cat == "All":
+        available = list(mappings.keys())
+    else:
+        available = [t for t in TYPE_CATEGORIES.get(selected_cat, []) if t in mappings]
+
+    with col_type:
+        selected_type = st.selectbox("Select Type", available, key="type_detail_sel")
+
+    if selected_type and selected_type in mappings:
+        m = mappings[selected_type]
+        st.markdown(f"### `{esc(selected_type)}`")
+        if "notes" in m:
+            st.info(esc(m["notes"]))
+
+        # Show all dialect mappings
+        dialect_items = [(d, t) for d, t in m.items() if d != "notes"]
+        for row_start in range(0, len(dialect_items), 4):
+            cols = st.columns(min(4, len(dialect_items) - row_start))
+            for j, (dialect, typ) in enumerate(dialect_items[row_start:row_start+4]):
+                with cols[j]:
+                    status_icon = "✓" if typ not in ["N/A", "JSON", "STRING"] else "⚠"
+                    st.markdown(f"**{esc(dialect.upper())}**\n`{esc(typ)}` {status_icon}")

frontend/templates_v2.py

@@ -0,0 +1,53 @@
+"""Templates for SQL Dialect Master v2.
+
+Cleaned-up template library without emoji clutter.
+"""
+from __future__ import annotations
+
+TEMPLATES: dict[str, str] = {
+    "Basic Queries": [
+        ("Basic SELECT", "SELECT * FROM users WHERE id = 1"),
+        ("DISTINCT with ORDER", "SELECT DISTINCT category, brand FROM products ORDER BY category, brand"),
+        ("COALESCE null handling", "SELECT id, COALESCE(nickname, username, email, 'Anonymous') AS display_name FROM users"),
+    ],
+    "Aggregations": [
+        ("Group aggregation", "SELECT dept, COUNT(*) AS cnt, AVG(salary) AS avg_sal FROM employees GROUP BY dept"),
+        ("HAVING filter", "SELECT dept, COUNT(*) AS emp_count FROM employees GROUP BY dept HAVING COUNT(*) > 5 ORDER BY emp_count DESC"),
+        ("Multiple aggregates", "SELECT category, COUNT(*) AS cnt, SUM(price) AS total, AVG(price) AS avg_price FROM products GROUP BY category"),
+    ],
+    "Joins": [
+        ("Multi-table JOIN", "SELECT u.name, o.order_id, p.product_name FROM users u JOIN orders o ON u.id = o.user_id JOIN products p ON o.product_id = p.id"),
+        ("LEFT JOIN with NULL", "SELECT u.name, COUNT(o.id) AS order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id GROUP BY u.name"),
+        ("Self JOIN", "SELECT e.name AS employee, m.name AS manager FROM employees e LEFT JOIN employees m ON e.manager_id = m.id"),
+    ],
+    "Window Functions": [
+        ("ROW_NUMBER", "SELECT *, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn FROM employees"),
+        ("LAG/LEAD", "SELECT date, amount, LAG(amount, 1, 0) OVER (ORDER BY date) AS prev_amount FROM sales"),
+        ("Running total", "SELECT date, amount, SUM(amount) OVER (ORDER BY date ROWS UNBOUNDED PRECEDING) AS running_total FROM sales"),
+    ],
+    "Subqueries": [
+        ("Subquery IN clause", "SELECT * FROM products WHERE category_id IN (SELECT id FROM categories WHERE status = 'active')"),
+        ("Correlated subquery", "SELECT * FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE dept = e.dept)"),
+        ("EXISTS subquery", "SELECT * FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id AND o.amount > 1000)"),
+    ],
+    "CTEs": [
+        ("Basic CTE", "WITH active_users AS (SELECT * FROM users WHERE status = 'active') SELECT * FROM active_users WHERE created_at > '2024-01-01'"),
+        ("Multiple CTEs", "WITH sales_2024 AS (SELECT * FROM sales WHERE YEAR(date) = 2024), top_products AS (SELECT product_id, SUM(amount) AS total FROM sales_2024 GROUP BY product_id) SELECT * FROM top_products ORDER BY total DESC LIMIT 10"),
+    ],
+    "Date Operations": [
+        ("Date extraction", "SELECT YEAR(created_at) AS year, MONTH(created_at) AS month, COUNT(*) AS cnt FROM orders GROUP BY YEAR(created_at), MONTH(created_at)"),
+        ("Date arithmetic", "SELECT id, created_at, DATE_ADD(created_at, 30) AS expires_at FROM subscriptions"),
+        ("Date formatting", "SELECT id, DATE_FORMAT(created_at, '%Y-%m-%d') AS formatted_date FROM orders"),
+    ],
+    "Set Operations": [
+        ("UNION ALL", "SELECT 'Q1' AS quarter, SUM(amount) AS total FROM sales WHERE month <= 3 UNION ALL SELECT 'Q2', SUM(amount) FROM sales WHERE month BETWEEN 4 AND 6"),
+        ("INTERSECT", "SELECT user_id FROM orders WHERE YEAR(created_at) = 2023 INTERSECT SELECT user_id FROM orders WHERE YEAR(created_at) = 2024"),
+        ("EXCEPT", "SELECT user_id FROM users EXCEPT SELECT DISTINCT user_id FROM orders"),
+    ],
+}
+
+# Flatten for compatibility with old lookup pattern
+FLAT_TEMPLATES: dict[str, str] = {}
+for cat, items in TEMPLATES.items():
+    for label, sql in items:
+        FLAT_TEMPLATES[f"{cat} · {label}"] = sql

frontend/ui/command_palette.py

@@ -0,0 +1,153 @@
+"""Command Palette for SQL Dialect Master v2.
+
+Provides a button-based command palette for quick access to all workspace actions.
+All commands produce NavigationIntent objects — no direct routing.
+
+Note: Streamlit does not support native keyboard shortcuts, so the ⌘K button
+is used as the trigger instead of a keyboard listener.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import streamlit as st
+
+from frontend.core.design_tokens import ColorTokens
+from frontend.core.navigation import create_navigation_intent
+
+
+@dataclass(frozen=True)
+class Command:
+    """A single command in the palette."""
+
+    label: str
+    description: str
+    category: str
+    action: str
+    shortcut: str = ""
+
+
+# ── Command registry ──────────────────────────────────────────────────
+
+COMMANDS: list[Command] = [
+    # Workspace
+    Command("Convert SQL", "Open the SQL conversion workspace", "Workspace", "new_conversion", ""),
+    Command("NL2SQL", "Generate SQL from natural language", "Workspace", "open_nl2sql", ""),
+    Command("Semantic Diff", "Compare two SQL statements", "Workspace", "open_diff", ""),
+    Command("Lineage", "Visualize table dependencies", "Workspace", "open_lineage", ""),
+    Command("Runtime", "Execute and verify SQL against databases", "Workspace", "open_runtime", ""),
+    # Library
+    Command("Function Library", "Search and compare SQL functions", "Library", "open_functions", ""),
+    Command("Type Mapping", "Compare data types across dialects", "Library", "open_types", ""),
+    Command("Templates", "Browse SQL templates by category", "Library", "open_templates", ""),
+    Command("History", "View recent conversions", "Library", "open_history", ""),
+    # System
+    Command("Query Analysis", "Static analysis of SQL queries", "System", "open_query_analysis", ""),
+    Command("Settings", "Theme and configuration", "System", "open_settings", ""),
+]
+
+CATEGORY_ORDER = ["Workspace", "Library", "System"]
+
+
+def render_command_palette(theme: ColorTokens) -> None:
+    """Render the command palette overlay."""
+    # Check for keyboard shortcut (⌘K / Ctrl+K)
+    # Streamlit doesn't support direct key listeners, so we use a text input
+    # as the palette trigger. The actual keyboard shortcut is documented.
+
+    # Palette trigger button in topbar
+    if st.button("⌘K", key="cmd_palette_trigger", help="Open command palette",
+                  use_container_width=False):
+        _show_palette(theme)
+
+
+def _show_palette(theme: ColorTokens) -> None:
+    """Show the command palette modal."""
+    query = st.text_input(
+        "Search commands...",
+        key="cmd_palette_query",
+        placeholder="Type a command name...",
+        label_visibility="collapsed",
+    )
+
+    # Filter commands
+    q = query.lower().strip()
+    if q:
+        filtered = [
+            c for c in COMMANDS
+            if q in c.label.lower() or q in c.description.lower() or q in c.category.lower()
+        ]
+    else:
+        # Group by category
+        filtered = list(COMMANDS)
+
+    # Render results
+    if not filtered:
+        st.caption("No commands found.")
+        return
+
+    # Group by category
+    groups: dict[str, list[Command]] = {}
+    for cmd in filtered:
+        if cmd.category not in groups:
+            groups[cmd.category] = []
+        groups[cmd.category].append(cmd)
+
+    for cat in CATEGORY_ORDER:
+        if cat not in groups:
+            continue
+        st.markdown(
+            f'<div style="font-size:10px; font-weight:600; letter-spacing:0.08em; '
+            f'text-transform:uppercase; color:{theme.text_muted}; margin:8px 0 4px;">'
+            f'{cat}</div>',
+            unsafe_allow_html=True,
+        )
+        for cmd in groups[cat]:
+            _render_command_item(cmd, theme)
+
+
+def _render_command_item(cmd: Command, theme: ColorTokens) -> None:
+    """Render a single command item."""
+    col_cmd, col_shortcut = st.columns([5, 1])
+
+    with col_cmd:
+        clicked = st.button(
+            f"**{cmd.label}**\n{cmd.description}",
+            key=f"cmd_{cmd.action}",
+            use_container_width=True,
+            help=f"{cmd.label} — {cmd.description}",
+        )
+        if clicked:
+            _execute_command(cmd)
+
+    with col_shortcut:
+        if cmd.shortcut:
+            st.caption(cmd.shortcut)
+
+
+def _execute_command(cmd: Command) -> None:
+    """Execute a command by creating and storing a NavigationIntent."""
+    intent = create_navigation_intent(
+        target_page=_action_to_page(cmd.action),
+        action=cmd.action,
+    )
+    st.session_state.sdm_navigation_intent = intent
+    st.rerun()
+
+
+def _action_to_page(action: str) -> str:
+    """Map action to target page."""
+    mapping = {
+        "new_conversion": "convert",
+        "open_nl2sql": "nl2sql",
+        "open_diff": "diff",
+        "open_lineage": "lineage",
+        "open_runtime": "runtime",
+        "open_functions": "functions",
+        "open_types": "types",
+        "open_templates": "templates",
+        "open_history": "history",
+        "open_query_analysis": "query_analysis",
+        "open_settings": "settings",
+    }
+    return mapping.get(action, "convert")