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

backend/core/nl2sql_pipeline/predicates.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""P8 NL2SQL pipeline: predicate extraction (moved from nl2sql_legacy).
+
+``extract_conditions`` is a verbatim move of
+``nl2sql_legacy._extract_conditions_enhanced``.  All keyword tables,
+IN-predicate parsing, comparison operators, BETWEEN / LIKE / NULL /
+date / time / status rules are unchanged; the only difference is that
+``COLUMN_PATTERNS`` is now passed as a parameter instead of read from
+the instance attribute.
+"""
+import re
+from typing import Dict, List, Optional
+
+from ..nl2sql_components.boolean_conditions import extract_boolean_conditions
+
+
+def extract_conditions(
+    text: str,
+    original: str,
+    column_patterns: Dict[str, str],
+) -> list:
+    """Extract WHERE conditions with enhanced parsing including boolean expressions.
+
+    Moved verbatim from ``nl2sql_legacy._extract_conditions_enhanced``.
+    ``column_patterns`` replaces ``self.COLUMN_PATTERNS``.
+    """
+    # Use the structured boolean extractor first — it correctly handles
+    # multiple predicates connected by AND/OR while preserving precedence.
+    boolean_conditions = extract_boolean_conditions(text)
+    if boolean_conditions:
+        return boolean_conditions
+
+    conditions = []
+    numbers = re.findall(r"\d+\.?\d*", original)
+    condition_column = None
+    for pattern, column in column_patterns.items():
+        if pattern in text:
+            condition_column = column
+            break
+
+    # Handle IN/NOT IN predicate (must come before generic comparison handling)
+    in_matched_columns: set = set()
+    in_match = re.search(
+        r"\b(\w+)\s+(not\s+)?in\s*\(([^)]+)\)",
+        text,
+        re.IGNORECASE,
+    )
+    if in_match:
+        col = in_match.group(1)
+        negation = in_match.group(2) is not None
+        raw_values = in_match.group(3).strip()
+        # Parse comma-separated values, preserving quoted strings
+        values = []
+        current = ""
+        quote_char = None
+        for char in raw_values:
+            if char in ("'", '"'):
+                if quote_char and quote_char == char:
+                    quote_char = None
+                elif not quote_char:
+                    quote_char = char
+                current += char
+            elif char == "," and not quote_char:
+                if current.strip():
+                    values.append(current.strip())
+                current = ""
+            else:
+                current += char
+        if current.strip():
+            values.append(current.strip())
+
+        if values:
+            formatted_values = ", ".join(
+                f"'{v}'" if v.startswith(("'", '"')) or not re.match(r"^-?\d+(\.\d+)?$", v) else v
+                for v in values
+            )
+            operator = "NOT IN" if negation else "IN"
+            conditions.append(f"{col} {operator} ({formatted_values})")
+            in_matched_columns.add(col.lower())
+
+    comparisons = [
+        (["大于等于", "不小于", "至少", "greater than or equal to", "larger than or equal to"], ">="),
+        (["小于等于", "不大于", "最多", "less than or equal to", "smaller than or equal to"], "<="),
+        (["不等于", "不是", "不为", "not equal", "isn't", "doesn't equal"], "!="),
+        (["大于", "超过", "高于", "多于", "greater", "more than", "above", "over", ">"], ">"),
+        (["小于", "低于", "少于", "不足", "less", "less than", "below", "under", "<"], "<"),
+        (["等于", "是", "为", "equals", "equal", "="], "="),
+    ]
+    for keywords, op in comparisons:
+        if any(keyword in text for keyword in keywords) and numbers:
+            col = condition_column or "column"
+            conditions.append(f"{col} {op} {numbers[0]}")
+            break
+
+    if any(keyword in text for keyword in ["之间", "范围", "between", "from...to"]):
+        if len(numbers) >= 2:
+            col = condition_column or "column"
+            conditions.append(f"{col} BETWEEN {numbers[0]} AND {numbers[1]}")
+
+    if any(keyword in text for keyword in ["包含", "含有", "contains", "like", "includes"]):
+        match = re.search(r"[\"']([^\"']+)[\"']", original)
+        if match:
+            col = condition_column or "column"
+            conditions.append(f"{col} LIKE '%{match.group(1)}%'")
+
+    has_negative_null = any(
+        keyword in text
+        for keyword in ["非空", "不为空", "is not null", "not null", "not empty"]
+    )
+    if has_negative_null:
+        conditions.append(f"{condition_column or 'column'} IS NOT NULL")
+    elif any(keyword in text for keyword in ["为空", "空值", "is null", "null", "empty"]):
+        conditions.append(f"{condition_column or 'column'} IS NULL")
+
+    date_col = "created_at" if "created_at" in text else "date"
+    if "今天" in text or "today" in text:
+        conditions.append(f"{date_col} = CURRENT_DATE")
+    elif "昨天" in text or "yesterday" in text:
+        conditions.append(f"{date_col} = DATE_SUB(CURRENT_DATE, 1)")
+    elif "前天" in text or "day before" in text:
+        conditions.append(f"{date_col} = DATE_SUB(CURRENT_DATE, 2)")
+    elif "明天" in text or "tomorrow" in text:
+        conditions.append(f"{date_col} = DATE_ADD(CURRENT_DATE, 1)")
+
+    time_patterns = [
+        (r"(最近|过去|last|past)\s*(\d+)\s*(天|day)", "DAY"),
+        (r"(最近|过去|last|past)\s*(\d+)\s*(周|week)", "WEEK"),
+        (r"(最近|过去|last|past)\s*(\d+)\s*(月|month)", "MONTH"),
+        (r"(最近|过去|last|past)\s*(\d+)\s*(年|year)", "YEAR"),
+    ]
+    for pattern, unit in time_patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            n = match.group(2)
+            if unit == "DAY":
+                conditions.append(f"{date_col} >= DATE_SUB(CURRENT_DATE, {n})")
+            elif unit == "WEEK":
+                conditions.append(f"{date_col} >= DATE_SUB(CURRENT_DATE, {int(n) * 7})")
+            elif unit == "MONTH":
+                conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -{n})")
+            elif unit == "YEAR":
+                conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -{int(n) * 12})")
+            break
+
+    # Bare period expressions without explicit count
+    if not any(c for c in conditions if "DATE_SUB" in c or "DATE_ADD" in c or "ADD_MONTHS" in c or "CURRENT_DATE" in c):
+        if ("last week" in text or "本周" in text) and "this week" not in text and "本周" not in text:
+            conditions.append(f"{date_col} >= DATE_SUB(CURRENT_DATE, 7)")
+        if "last month" in text:
+            conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -1)")
+        if "last year" in text:
+            conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -12)")
+
+    if "本周" in text or "this week" in text:
+        conditions.append(f"WEEKOFYEAR({date_col}) = WEEKOFYEAR(CURRENT_DATE)")
+    if "本月" in text or "this month" in text:
+        conditions.append(
+            f"MONTH({date_col}) = MONTH(CURRENT_DATE) AND YEAR({date_col}) = YEAR(CURRENT_DATE)"
+        )
+    if "本年" in text or "this year" in text:
+        conditions.append(f"YEAR({date_col}) = YEAR(CURRENT_DATE)")
+
+    status_patterns = [
+        (["有效", "active", "enabled", "valid"], "status = 'active'"),
+        (["无效", "inactive", "disabled", "invalid"], "status = 'inactive'"),
+        (["已删除", "deleted", "removed"], "is_deleted = 1"),
+        (["未删除", "not deleted"], "is_deleted = 0"),
+        (["已完成", "completed", "done", "finished"], "status = 'completed'"),
+        (["未完成", "pending", "incomplete"], "status = 'pending'"),
+        (["已支付", "paid"], "status = 'paid'"),
+        (["未支付", "unpaid"], "status = 'unpaid'"),
+    ]
+    for keywords, condition in status_patterns:
+        # Skip status pattern if the column was already matched via IN predicate
+        col_match = re.match(r"^(\w+)\s*=", condition)
+        col_name = col_match.group(1).lower() if col_match else None
+        if col_name and col_name in in_matched_columns:
+            continue
+        if any(keyword in text for keyword in keywords):
+            conditions.append(condition)
+            break
+    return conditions

backend/core/nl2sql_pipeline/renderer.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""P8 NL2SQL pipeline: SQL renderer (extracted from nl2sql_legacy).
+
+``render_sql`` is the renamed, pure-function form of the legacy
+``_build_sql_enhanced`` method.  Its body is behavior-identical to the
+legacy version; it now operates on a ``QueryIR`` instead of flat
+positional args and returns the same 4-tuple
+``(sql, explanation, confidence, evidence)``.
+"""
+import re
+from typing import Dict, List, Optional, Tuple, Union
+
+from ..nl2sql_components.evidence import (
+    EVIDENCE_AGGREGATION_PRESENT,
+    EVIDENCE_COLUMNS_EXPLICIT,
+    EVIDENCE_CONDITIONS_PRESENT,
+    EVIDENCE_GROUP_BY,
+    EVIDENCE_JOIN_KNOWN,
+    EVIDENCE_LIMIT,
+    EVIDENCE_PARSE_FAIL,
+    EVIDENCE_PARSE_OK,
+    EVIDENCE_TABLE_KNOWN,
+    EvidenceItem,
+    GenerationEvidence,
+)
+from .dialect import apply_dialect_adjustments
+from .ir import QueryIR
+from .validation import validate_sql
+
+
+# ── Pure helper functions (moved verbatim from nl2sql_legacy) ───────────────
+
+def join_sql_kind(join: Dict) -> str:
+    """Return the SQL JOIN keyword for a physical join record.
+
+    A structured ``join_spec`` from the relations module wins; an
+    unqualified join or a missing spec falls back to INNER.  Physical
+    join kinds never include EXISTS/NOT EXISTS — those are relational.
+    """
+    spec = join.get("join_spec")
+    if spec is not None:
+        kind = spec.kind
+        return "INNER" if kind == "JOIN" else kind
+    join_type = join.get("type", "JOIN")
+    if join_type in ("EXISTS", "NOT EXISTS"):
+        return "INNER"
+    return "INNER" if join_type in ("JOIN", "INNER") else join_type
+
+
+def add_limit(sql: str, limit: int, dialect: str) -> str:
+    """Add LIMIT clause with dialect-specific syntax."""
+    if dialect == "oracle":
+        return f"{sql}\nFETCH FIRST {limit} ROWS ONLY"
+    if dialect == "tsql":
+        return sql.replace("SELECT", f"SELECT TOP {limit}", 1)
+    return f"{sql}\nLIMIT {limit}"
+
+
+# ── Renderer ────────────────────────────────────────────────────────────────
+
+def render_sql(ir: QueryIR) -> Tuple[Optional[str], str, float, GenerationEvidence]:
+    """Build SQL statement from the Query IR.
+
+    Fail-closed: any join entry with ``condition is None`` (an
+    unresolved/unknown relationship) immediately returns
+    ``(None, explanation, 0.0, GenerationEvidence())`` so the caller
+    observes ``success=False``.  The relationship is never silently
+    dropped.
+
+    Returns the same 4-tuple the legacy ``_build_sql_enhanced`` returns:
+    ``(sql, explanation, confidence, evidence)``.
+    """
+    for join in ir.joins:
+        if join.get("condition") is None:
+            subject = join.get("subject") or ir.table
+            pair_desc = f"{subject} ⟷ {join['table']}"
+            explanation = (
+                "Unable to safely infer the relationship between the "
+                f"table(s) involved ({pair_desc}). Please provide the "
+                "join condition or schema relationship."
+            )
+            return None, explanation, 0.0, GenerationEvidence()
+
+    operation = ir.operation
+    table = ir.table
+    columns = ir.columns
+    conditions = ir.conditions
+    aggregations = ir.aggregations
+    group_by = ir.group_by
+    ordering = ir.ordering
+    limit = ir.limit
+    joins = ir.joins
+    distinct = ir.distinct
+    dialect = ir.dialect
+
+    explanation_parts: list[str] = []
+    evidence = ir.evidence
+    evidence.items.append(EvidenceItem("base", "Base confidence for generated SQL", 0.5))
+
+    if operation == "SELECT":
+        distinct_kw = "DISTINCT " if distinct else ""
+        if aggregations:
+            if group_by:
+                select_parts = group_by + aggregations
+                select_clause = ", ".join(select_parts)
+            else:
+                select_clause = ", ".join(aggregations)
+            explanation_parts.append(f"聚合: {', '.join(aggregations)}")
+            evidence.items.append(EvidenceItem(
+                EVIDENCE_AGGREGATION_PRESENT,
+                f"Explicit aggregation requested: {', '.join(aggregations)}",
+                0.15, detail=aggregations[0],
+            ))
+        else:
+            select_clause = ", ".join(columns)
+            if columns != ["*"]:
+                explanation_parts.append(f"列: {', '.join(columns)}")
+                evidence.items.append(EvidenceItem(
+                    EVIDENCE_COLUMNS_EXPLICIT,
+                    "Explicit columns requested", 0.1,
+                    detail=columns[0],
+                ))
+        sql = f"SELECT {distinct_kw}{select_clause}\nFROM {table}"
+        explanation_parts.append(f"表: {table}")
+        if table != "table_name":
+            evidence.items.append(EvidenceItem(
+                EVIDENCE_TABLE_KNOWN,
+                f"Table resolved to known name: {table}", 0.2,
+                detail=table,
+            ))
+        for join in joins:
+            # Join conditions are only ever emitted from a resolved
+            # canonical relationship (G1). Unresolved pairs are blocked
+            # upstream by generate(); keep a structural guard so a join
+            # can never be composed with a missing condition.
+            if join.get("condition") is None:
+                continue
+            if join.get("relational"):
+                # EXISTS/NOT EXISTS: preserves row count, no duplicates
+                if join["type"] == "NOT EXISTS":
+                    subquery = f"SELECT 1\n    FROM {join['table']}\n    WHERE {join['condition']}"
+                    # Merge date conditions into subquery if present
+                    if conditions:
+                        cond_sql = conditions if isinstance(conditions, str) else " AND ".join(conditions)
+                        subquery += f"\n    AND {cond_sql}"
+                        conditions = []  # Remove from top-level conditions
+                    sql += f"\nWHERE NOT EXISTS (\n    {subquery}\n)"
+                    explanation_parts.append(f"关联: {join['table']} (NOT EXISTS)")
+                else:
+                    subquery = f"SELECT 1\n    FROM {join['table']}\n    WHERE {join['condition']}"
+                    # Merge date conditions into subquery if present
+                    if conditions:
+                        cond_sql = conditions if isinstance(conditions, str) else " AND ".join(conditions)
+                        subquery += f"\n    AND {cond_sql}"
+                        conditions = []  # Remove from top-level conditions
+                    sql += f"\nWHERE EXISTS (\n    {subquery}\n)"
+                    explanation_parts.append(f"关联: {join['table']} (EXISTS)")
+                evidence.items.append(EvidenceItem(
+                    EVIDENCE_JOIN_KNOWN,
+                    f"Known relationship: {join['subject']} → {join['table']}",
+                    0.1, detail=join["condition"],
+                ))
+            else:
+                # Physical JOIN — kind comes from the structured JoinSpec
+                # (LEFT/RIGHT/INNER/OUTER), never a first-token guess.
+                sql += f"\n{join_sql_kind(join)} JOIN {join['table']} ON {join['condition']}"
+                explanation_parts.append(f"关联: {join['table']}")
+                evidence.items.append(EvidenceItem(
+                    EVIDENCE_JOIN_KNOWN,
+                    f"Physical join: {join['table']} ON {join['condition']}",
+                    0.1, detail=join["condition"],
+                ))
+        if conditions:
+            condition_sql = conditions if isinstance(conditions, str) else " AND ".join(conditions)
+            sql += f"\nWHERE {condition_sql}"
+            count = len(conditions) if not isinstance(conditions, str) else 1
+            explanation_parts.append(f"条件: {count}个")
+            evidence.items.append(EvidenceItem(
+                EVIDENCE_CONDITIONS_PRESENT,
+                f"{count} explicit predicate(s) in WHERE clause",
+                0.1,
+            ))
+        if group_by:
+            sql += f"\nGROUP BY {', '.join(group_by)}"
+            explanation_parts.append(f"分组: {', '.join(group_by)}")
+            evidence.items.append(EvidenceItem(
+                EVIDENCE_GROUP_BY,
+                f"GROUP BY clause: {', '.join(group_by)}", 0.1,
+            ))
+        elif aggregations and columns != ["*"]:
+            group_cols = [c for c in columns if c != "*"]
+            if group_cols:
+                sql += f"\nGROUP BY {', '.join(group_cols)}"
+        if ordering:
+            sql += f"\nORDER BY {ordering[0]} {ordering[1]}"
+            explanation_parts.append(f"排序: {ordering[0]} {ordering[1]}")
+        if limit:
+            sql = add_limit(sql, limit, dialect)
+            explanation_parts.append(f"限制: {limit}条")
+            evidence.items.append(EvidenceItem(
+                EVIDENCE_LIMIT,
+                f"Explicit limit: {limit}", 0.1, detail=str(limit),
+            ))
+    elif operation == "INSERT":
+        cols = columns if columns != ["*"] else ["col1", "col2"]
+        placeholders = ", ".join(["?"] * len(cols))
+        sql = f"INSERT INTO {table} ({', '.join(cols)})\nVALUES ({placeholders})"
+        explanation_parts.append(f"插入到: {table}")
+    elif operation == "UPDATE":
+        update_cols = columns if columns != ["*"] else ["column"]
+        set_clause = ", ".join([f"{c} = ?" for c in update_cols])
+        sql = f"UPDATE {table}\nSET {set_clause}"
+        if conditions:
+            condition_sql = conditions if isinstance(conditions, str) else " AND ".join(conditions)
+            sql += f"\nWHERE {condition_sql}"
+        else:
+            sql += "\nWHERE id = ?"
+        explanation_parts.append(f"更新: {table}")
+    elif operation == "DELETE":
+        sql = f"DELETE FROM {table}"
+        if conditions:
+            condition_sql = conditions if isinstance(conditions, str) else " AND ".join(conditions)
+            sql += f"\nWHERE {condition_sql}"
+        else:
+            sql += "\nWHERE id = ?"
+        explanation_parts.append(f"删除: {table}")
+    else:
+        sql = f"-- 无法解析: {operation}"
+        # Unknown operation — clear all evidence; score will be 0.0.
+        evidence = GenerationEvidence()
+
+    sql = f"-- Generated for {dialect.upper()}\n{sql}"
+    sql = apply_dialect_adjustments(sql, dialect)
+    parse_adjustment = validate_sql(sql, dialect)
+    if parse_adjustment > 0:
+        evidence.items.append(EvidenceItem(
+            EVIDENCE_PARSE_OK,
+            "Target dialect parser accepted the generated SQL",
+            parse_adjustment,
+        ))
+    elif parse_adjustment < 0:
+        evidence.items.append(EvidenceItem(
+            EVIDENCE_PARSE_FAIL,
+            "Target dialect parser rejected the generated SQL",
+            parse_adjustment,
+        ))
+    confidence = evidence.score
+    return sql, " | ".join(explanation_parts), confidence, evidence

backend/core/nl2sql_pipeline/resolution.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""P8 NL2SQL pipeline: entity and relation resolution (moved from nl2sql_legacy).
+
+Thin function-level adapters over the existing ``nl2sql_components``
+modules.  Signatures mirror the legacy instance-method forms so the
+facade's ``super()`` overrides continue to resolve unchanged.
+"""
+from typing import Dict, List, Optional
+
+from ..nl2sql_components.mappings import COLUMN_PATTERNS, TABLE_PATTERNS
+from ..nl2sql_components.relations import (
+    extract_joins as _extract_joins_impl,
+    guess_join_key as _guess_join_key_impl,
+    has_relational_keyword as _has_relational_keyword_impl,
+)
+from ..nl2sql_components.core_extract import (
+    extract_columns as _extract_columns_impl,
+    extract_table as _extract_table_impl,
+    extract_table_subject as _extract_table_subject_impl,
+    named_tables as _named_tables_impl,
+)
+
+
+# ── Entity resolution ────────────────────────────────────────────────────────
+
+def extract_table(text: str, table_patterns: Optional[Dict[str, str]] = None) -> str:
+    """Extract table name from text (delegates to core_extract)."""
+    return _extract_table_impl(text, table_patterns or TABLE_PATTERNS)
+
+
+def extract_table_subject(
+    text: str, table_patterns: Optional[Dict[str, str]] = None
+) -> Optional[str]:
+    """Extract the subject table (first appearing in text) for D2 relational queries."""
+    return _extract_table_subject_impl(text, table_patterns or TABLE_PATTERNS)
+
+
+def named_tables(text: str, table_patterns: Optional[Dict[str, str]] = None) -> list:
+    """Return the distinct table names the text mentions."""
+    return _named_tables_impl(text, table_patterns or TABLE_PATTERNS)
+
+
+def extract_columns(
+    text: str, column_patterns: Optional[Dict[str, str]] = None
+) -> list:
+    """Extract column names from text (delegates to core_extract)."""
+    return _extract_columns_impl(text, column_patterns or COLUMN_PATTERNS)
+
+
+# ── Relation resolution ───────────────────────────────────────────────────────
+
+def extract_joins(text: str, table_patterns: Optional[Dict[str, str]] = None) -> list:
+    """Extract JOIN information from text.
+
+    Detects relational existence patterns (e.g. "users who have orders")
+    and returns structured join contexts for EXISTS-based SQL generation.
+    """
+    return _extract_joins_impl(text, table_patterns or TABLE_PATTERNS)
+
+
+def guess_join_key(table1: str, table2: str) -> Optional[str]:
+    """Guess the join key between two tables.  Returns None for unknown
+    relationships instead of guessing (fail-closed)."""
+    return _guess_join_key_impl(table1, table2)
+
+
+def has_relational_keyword(text: str) -> bool:
+    """Check if text contains relational existence keywords (D2)."""
+    return _has_relational_keyword_impl(text)

backend/core/nl2sql_pipeline/suggestions.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""P8 NL2SQL pipeline: suggestion generation (moved from nl2sql_legacy).
+
+``generate_suggestions`` is a verbatim move of
+``nl2sql_legacy._generate_suggestions``.
+"""
+
+
+def generate_suggestions(text: str, sql: str, dialect: str) -> list:
+    """Generate improvement suggestions."""
+    suggestions = []
+    if "table_name" in sql:
+        suggestions.append("💡 请指定具体的表名，如：用户表、订单表")
+    if "column >" in sql or "column <" in sql or "column =" in sql:
+        suggestions.append("💡 请指定具体的列名用于条件判断，如：年龄大于30")
+    if dialect == "hive" and "SELECT *" in sql:
+        suggestions.append("💡 Hive 建议指定具体列名以提高性能")
+    if "JOIN" not in sql and any(k in text for k in ["关联", "连接", "join", "和", "与"]):
+        suggestions.append("💡 检测到关联需求，请明确指定两个表名")
+    if "?" in sql:
+        suggestions.append("💡 请替换 ? 占位符为实际值")
+    if "GROUP BY" in sql and "HAVING" not in sql:
+        suggestions.append("💡 可以添加 HAVING 子句过滤分组结果")
+    if dialect == "hive" and "ORDER BY" in sql and "LIMIT" not in sql:
+        suggestions.append("💡 Hive 中 ORDER BY 建议配合 LIMIT 使用")
+    if "DELETE" in sql and "WHERE" not in sql:
+        suggestions.append("⚠️ DELETE 没有 WHERE 条件将删除所有数据！")
+    if "UPDATE" in sql and "WHERE" not in sql:
+        suggestions.append("⚠️ UPDATE 没有 WHERE 条件将更新所有数据！")
+    return suggestions