sql-dialect-master 1.4.0__tar.gz → 1.4.1__tar.gz

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.4.0
+Version: 1.4.1
 Summary: SQL Dialect Master - Multi-database SQL conversion engine
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -38,7 +38,7 @@ Dynamic: license-file
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.4.0
+Current release: 1.4.1
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/README.md

@@ -2,7 +2,7 @@
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.4.0
+Current release: 1.4.1
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/backend/core/metadata.py

@@ -17,8 +17,8 @@ Design rules:
 from __future__ import annotations
 
 # ── Release version facts (sole source of truth) ────────────────────────
-PROJECT_VERSION = "1.4.0"
-API_VERSION = "1.4.0"
+PROJECT_VERSION = "1.4.1"
+API_VERSION = "1.4.1"
 # Frontend v2 architecture — independent of the product release version.
 FRONTEND_ARCHITECTURE_VERSION = 2
 

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/backend/core/nl2sql_components/boolean_conditions.py

@@ -7,39 +7,41 @@ user-supplied parentheses.
 import re
 from typing import List, Optional, Tuple
 
+from ..p1_sql_scanner import mask_non_executable
+
 
 _COMPARISON_PATTERNS = (
     re.compile(
         r"(?<![A-Za-z0-9_])(price|quantity|amount|age|score|rating|views|clicks)\s+"
         r"(greater(?:\s+than)?|more\s+than|above|over|less(?:\s+than)?|"
         r"below|under|equal(?:\s+to)?|equals)\s+"
-        r"([0-9]+(?:\.[0-9]+)?)",
+        r"(-?[0-9]+(?:\.[0-9]+)?)",
         re.IGNORECASE,
     ),
     re.compile(
         r"(?<![A-Za-z0-9_])(price|quantity|amount|age|score|rating|views|clicks)\s*"
-        r"(>=|<=|!=|=|>|<)\s*([0-9]+(?:\.[0-9]+)?)",
+        r"(>=|<=|!=|<>|=|>|<)\s*(-?[0-9]+(?:\.[0-9]+)?)",
         re.IGNORECASE,
     ),
     re.compile(
         r"(价格|数量|金额|年龄|得分|评分|浏览量|点击量)\s*"
         r"(大于等于|小于等于|不等于|大于|小于|超过|低于|等于)\s*"
-        r"([0-9]+(?:\.[0-9]+)?)"
+        r"(-?[0-9]+(?:\.[0-9]+)?)"
     ),
 )
 
 _RANGE_PATTERN = re.compile(
     r"(?<![A-Za-z0-9_])(price|quantity|amount|age|score|rating|views|clicks)\s+"
-    r"(?:between\s+([0-9]+(?:\.[0-9]+)?)\s+and\s+([0-9]+(?:\.[0-9]+)?)|"
-    r"in\s+(?:the\s+)?range\s+([0-9]+(?:\.[0-9]+)?)\s*(?:to|-)\s*"
-    r"([0-9]+(?:\.[0-9]+)?))",
+    r"(?:between\s+(-?[0-9]+(?:\.[0-9]+)?)\s+and\s+(-?[0-9]+(?:\.[0-9]+)?)|"
+    r"in\s+(?:the\s+)?range\s+(-?[0-9]+(?:\.[0-9]+)?)\s*(?:to|-)\s*"
+    r"(-?[0-9]+(?:\.[0-9]+)?))",
     re.IGNORECASE,
 )
 
 _CN_RANGE_PATTERN = re.compile(
     r"(价格|数量|金额|年龄|得分|评分|浏览量|点击量)\s*"
-    r"(?:在|介于)\s*([0-9]+(?:\.[0-9]+)?)\s*(?:和|到|至|-)\s*"
-    r"([0-9]+(?:\.[0-9]+)?)\s*(?:之间|范围内|以内)?"
+    r"(?:在|介于)\s*(-?[0-9]+(?:\.[0-9]+)?)\s*(?:和|到|至|-)\s*"
+    r"(-?[0-9]+(?:\.[0-9]+)?)\s*(?:之间|范围内|以内)?"
 )
 
 _TEXT_PATTERN = re.compile(
@@ -101,6 +103,29 @@ _STATUS_CONDITIONS = {
     "未支付": "status = 'unpaid'",
 }
 
+_STATUS_VALUES = {
+    "active": "active",
+    "inactive": "inactive",
+    "enabled": "active",
+    "disabled": "inactive",
+    "valid": "active",
+    "invalid": "inactive",
+    "completed": "completed",
+    "done": "completed",
+    "pending": "pending",
+    "paid": "paid",
+    "unpaid": "unpaid",
+    "有效": "active",
+    "无效": "inactive",
+    "已完成": "completed",
+    "未完成": "pending",
+    "已支付": "paid",
+    "未支付": "unpaid",
+}
+_STATUS_VALUE_PATTERN = "(?:" + "|".join(
+    sorted((re.escape(value) for value in _STATUS_VALUES), key=len, reverse=True)
+) + ")"
+
 _CN_COLUMNS = {
     "价格": "price",
     "数量": "quantity",
@@ -168,15 +193,16 @@ def _format_set_values(raw_values: str) -> str:
 
 def _comparison_matches(text: str) -> List[Tuple[int, int, str]]:
     matches: List[Tuple[int, int, str]] = []
+    executable = mask_non_executable(text)
 
     for pattern in _COMPARISON_PATTERNS:
-        for match in pattern.finditer(text):
+        for match in pattern.finditer(executable):
             first, raw_operator, value = match.groups()
             column = _CN_COLUMNS.get(first, first)
             matches.append((match.start(), match.end(), f"{column} {_normalize_operator(raw_operator)} {value}"))
 
     for pattern in (_RANGE_PATTERN, _CN_RANGE_PATTERN):
-        for match in pattern.finditer(text):
+        for match in pattern.finditer(executable):
             groups = match.groups()
             if len(groups) == 5:
                 first, low1, high1, low2, high2 = groups
@@ -193,7 +219,7 @@ def _comparison_matches(text: str) -> List[Tuple[int, int, str]]:
             matches.append((match.start(), match.end(), _text_sql(column, value)))
 
     for pattern in (_NULL_PATTERN, _CN_NULL_PATTERN):
-        for match in pattern.finditer(text):
+        for match in pattern.finditer(executable):
             first, raw_predicate = match.groups()
             column = _CN_COLUMNS.get(first, first)
             normalized = raw_predicate.replace(" ", "").lower()
@@ -229,9 +255,7 @@ def _comparison_matches(text: str) -> List[Tuple[int, int, str]]:
             operator = "NOT IN" if operator_text == "不在" else "IN"
             matches.append((match.start(), value_end, f"{_CN_SET_COLUMNS[column]} {operator} ({values})"))
 
-    for match in _STATUS_PATTERN.finditer(text):
-        status = match.group(1).lower()
-        matches.append((match.start(), match.end(), _STATUS_CONDITIONS[status]))
+    matches.extend(_status_matches(text))
 
     matches.sort(key=lambda item: (item[0], item[1]))
     deduped: List[Tuple[int, int, str]] = []
@@ -242,6 +266,86 @@ def _comparison_matches(text: str) -> List[Tuple[int, int, str]]:
     return deduped
 
 
+def _status_matches(text: str) -> List[Tuple[int, int, str]]:
+    """Extract status predicates without matching quoted values."""
+    executable = mask_non_executable(text)
+    matches: list[Tuple[int, int, str]] = []
+    explicit_patterns = [
+        (
+            re.compile(
+                rf"\bstatus\s*(?:is\s+not|isn't|not|!=|<>)\s*({_STATUS_VALUE_PATTERN})\b",
+                re.IGNORECASE,
+            ),
+            "!=",
+        ),
+        (
+            re.compile(rf"\bstatus\s*(?:is|=)\s*({_STATUS_VALUE_PATTERN})\b", re.IGNORECASE),
+            "=",
+        ),
+        (
+            re.compile(rf"\bstatus\s+({_STATUS_VALUE_PATTERN})\b", re.IGNORECASE),
+            "=",
+        ),
+        (
+            re.compile(rf"状态\s*(?:不是|不为|!=|<>)\s*({_STATUS_VALUE_PATTERN})"),
+            "!=",
+        ),
+        (
+            re.compile(rf"状态\s*(?:为|是|=)\s*({_STATUS_VALUE_PATTERN})"),
+            "=",
+        ),
+    ]
+    for pattern, operator in explicit_patterns:
+        for match in pattern.finditer(executable):
+            raw_value = match.group(1)
+            canonical = _STATUS_VALUES[raw_value.casefold() if raw_value.isascii() else raw_value]
+            matches.append((match.start(), match.end(), f"status {operator} '{canonical}'"))
+
+    occupied = [(start, end) for start, end, _ in matches]
+    text_spans = [
+        (match.start(), match.end())
+        for pattern in (_TEXT_PATTERN, _CN_TEXT_PATTERN)
+        for match in pattern.finditer(executable)
+    ]
+    for raw_value, canonical in sorted(_STATUS_VALUES.items(), key=lambda item: -len(item[0])):
+        if raw_value.isascii():
+            pattern = re.compile(rf"(?<![\w$]){re.escape(raw_value)}(?![\w$])", re.IGNORECASE)
+        else:
+            pattern = re.compile(re.escape(raw_value))
+        for match in pattern.finditer(executable):
+            if any(start <= match.start() < end or match.start() <= start < match.end() for start, end in occupied):
+                continue
+            if any(start <= match.start() < end for start, end in text_spans):
+                continue
+            prefix = executable[:match.start()]
+            negative = bool(
+                re.search(r"(?:\b(?:not|except|excluding)\s*)$", prefix, re.IGNORECASE)
+                or re.search(r"(?:不是|不为|非)\s*$", prefix)
+            )
+            operator = "!=" if negative else "="
+            matches.append((match.start(), match.end(), f"status {operator} '{canonical}'"))
+            occupied.append((match.start(), match.end()))
+
+    deleted_patterns = [
+        (
+            re.compile(r"(?:未删除|没有删除|不是删除|非删除|\bnot\s+deleted\b)", re.IGNORECASE),
+            "is_deleted = 0",
+        ),
+        (re.compile(r"(?:已删除|\bdeleted\b|\bremoved\b)", re.IGNORECASE), "is_deleted = 1"),
+    ]
+    for pattern, condition in deleted_patterns:
+        for match in pattern.finditer(executable):
+            if any(start <= match.start() < end or match.start() <= start < match.end() for start, end, _ in matches):
+                continue
+            matches.append((match.start(), match.end(), condition))
+    return matches
+
+
+def extract_status_conditions(text: str) -> list[str]:
+    """Return standalone status predicates for the single-condition path."""
+    return [condition for _, _, condition in _status_matches(text)]
+
+
 def extract_boolean_conditions(text: str) -> Optional[List[str]]:
     """Return one boolean SQL expression preserving connector precedence/grouping."""
     matches = _comparison_matches(text)

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/backend/core/nl2sql_components/core_extract.py

@@ -38,6 +38,15 @@ def detect_operation(text: str, keywords: Dict[str, str]) -> str:
     Defaults to SELECT.
     """
     intent_text = mask_non_executable(text)
+    # Deletion-state phrases describe a SELECT predicate. Mask only the
+    # phrase so an independent leading "删除" in e.g. "删除已删除用户"
+    # remains a genuine DELETE intent.
+    intent_text = re.sub(
+        r"(?:已删除|未删除|没有删除|不是删除|非删除|already\s+deleted|not\s+deleted)",
+        lambda match: " " * len(match.group(0)),
+        intent_text,
+        flags=re.IGNORECASE,
+    )
     for keyword, op in keywords.items():
         if _pattern_match(intent_text, keyword) and op in ["SELECT", "INSERT", "UPDATE", "DELETE"]:
             return op

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/backend/core/nl2sql_pipeline/predicates.py

@@ -11,7 +11,79 @@ the instance attribute.
 import re
 from typing import Dict, List, Optional
 
-from ..nl2sql_components.boolean_conditions import extract_boolean_conditions
+from ..nl2sql_components.boolean_conditions import (
+    extract_boolean_conditions,
+    extract_status_conditions,
+)
+from ..p1_sql_scanner import mask_non_executable
+
+_QUOTED_COMPARISON_PREFIX = re.compile(
+    r"(?<![\w$])([A-Za-z_][A-Za-z0-9_$]*)\s*"
+    r"(is\s+not|isn't|not|is|<>|!=|>=|<=|=|>|<)\s*",
+    re.IGNORECASE,
+)
+
+
+def _column_for_text(text: str, column_patterns: Dict[str, str]) -> Optional[str]:
+    for pattern, column in sorted(column_patterns.items(), key=lambda item: -len(item[0])):
+        expression = re.escape(pattern)
+        if not re.search(r"[\u4e00-\u9fff]", pattern):
+            expression = rf"(?<![\w$]){expression}(?![\w$])"
+        if re.search(expression, text, re.IGNORECASE):
+            return column
+    return None
+
+
+def _quoted_comparisons(
+    original: str, column_patterns: Dict[str, str]
+) -> list[str]:
+    quoted = []
+    executable = mask_non_executable(original)
+    known_columns = {value.casefold(): value for value in column_patterns.values()}
+    for match in _QUOTED_COMPARISON_PREFIX.finditer(original):
+        if executable[match.start():match.end()] != original[match.start():match.end()]:
+            continue
+        position = match.end()
+        if position >= len(original) or original[position] not in "'\"":
+            continue
+        quote = original[position]
+        position += 1
+        value_chars: list[str] = []
+        closed = False
+        while position < len(original):
+            character = original[position]
+            if character == "\\" and position + 1 < len(original):
+                value_chars.extend((character, original[position + 1]))
+                position += 2
+                continue
+            if character == quote:
+                if position + 1 < len(original) and original[position + 1] == quote:
+                    value_chars.append(quote)
+                    position += 2
+                    continue
+                closed = True
+                position += 1
+                break
+            value_chars.append(character)
+            position += 1
+        if not closed:
+            continue
+        raw_column, operator = match.groups()
+        value = "".join(value_chars)
+        column = known_columns.get(raw_column.casefold(), raw_column)
+        if quote == "'":
+            literal = quote + value.replace("'", "''") + quote
+        else:
+            literal = "'" + value.replace("'", "''") + "'"
+        normalized_operator = {
+            "is": "=",
+            "isn't": "!=",
+            "is not": "!=",
+            "not": "!=",
+            "<>": "!=",
+        }.get(operator.casefold(), operator)
+        quoted.append(f"{column} {normalized_operator} {literal}")
+    return quoted
 
 
 def extract_conditions(
@@ -30,13 +102,11 @@ def extract_conditions(
     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
+    conditions = _quoted_comparisons(original, column_patterns)
+    executable_original = mask_non_executable(original)
+    executable_text = mask_non_executable(text)
+    numbers = re.findall(r"-?\d+(?:\.\d*)?", executable_original)
+    condition_column = _column_for_text(executable_text, column_patterns)
 
     # Handle IN/NOT IN predicate (must come before generic comparison handling)
     in_matched_columns: set = set()
@@ -79,9 +149,9 @@ def extract_conditions(
             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 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", "="], "="),
@@ -109,11 +179,11 @@ def extract_conditions(
         # word itself (Chinese-style adjacency, e.g. '大于100').
         # Longest keyword first so '大于等于' never yields to '大于'.
         for keyword in sorted(keywords, key=len, reverse=True):
-            if keyword not in original:
+            if keyword not in executable_original:
                 continue
             m = re.search(
-                re.escape(keyword) + r"\s*(\d+(?:\.\d+)?)",
-                original,
+                re.escape(keyword) + r"\s*(-?\d+(?:\.\d*)?)",
+                executable_original,
             )
             if m:
                 bound_value = m.group(1)
@@ -126,12 +196,12 @@ def extract_conditions(
         # "10" in "top 10 …") must never win this slot.
         if bound_value is None:
             for keyword in sorted(keywords, key=len, reverse=True):
-                if keyword not in original:
+                if keyword not in executable_original:
                     continue
                 m = re.search(
                     re.escape(keyword)
-                    + r"(?:\s+than\s+|\s+or\s+equal\s+to\s+|\s+than\s+or\s+equal\s+to\s+)?(\d+(?:\.\d+)?)",
-                    original,
+                    + r"(?:\s+than\s+|\s+or\s+equal\s+to\s+|\s+than\s+or\s+equal\s+to\s+)?(-?\d+(?:\.\d*)?)",
+                    executable_original,
                     re.IGNORECASE,
                 )
                 if m:
@@ -147,19 +217,43 @@ def extract_conditions(
         # Fallback: operator word present but no number is directly or
         # tail-adjacent to it — bind the column named before the operator
         # word to the first available number.
-        if any(k in original for k in keywords) and numbers:
+        if any(k in executable_original for k 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 any(keyword in executable_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"]):
+    if any(keyword in executable_text for keyword in ["包含", "含有", "contains", "like", "includes"]):
+        text_match = re.search(
+            r"(?<![\w$])([A-Za-z_][A-Za-z0-9_$]*)\s+"
+            r"(?:contains|containing|includes|including)\s+"
+            r"(?:the\s+)?([^,;，。；]+?)(?=\s+(?:and|or)\b|[,;，。；]|$)",
+            original,
+            re.IGNORECASE,
+        )
+        cn_text_match = re.search(
+            r"(名称|名字|标题|描述|分类|品牌)\s*(?:包含|含有|包括)\s*([^且并或者和，,。；]+)",
+            original,
+        )
         match = re.search(r"[\"']([^\"']+)[\"']", original)
-        if match:
+        if text_match:
+            raw_column, raw_value = text_match.groups()
+            column = next(
+                (value for value in column_patterns.values() if value.casefold() == raw_column.casefold()),
+                raw_column,
+            )
+            value = raw_value.strip().strip("'\"")
+            if value:
+                conditions.append(f"{column} LIKE '%{value.replace(chr(39), chr(39) * 2)}%'")
+        elif cn_text_match:
+            raw_column, raw_value = cn_text_match.groups()
+            aliases = {"名称": "name", "名字": "name", "标题": "title", "描述": "description", "分类": "category", "品牌": "brand"}
+            conditions.append(f"{aliases[raw_column]} LIKE '%{raw_value.strip().replace(chr(39), chr(39) * 2)}%'")
+        elif match:
             col = condition_column or "column"
             conditions.append(f"{col} LIKE '%{match.group(1)}%'")
 
@@ -172,14 +266,14 @@ def extract_conditions(
     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:
+    date_col = "created_at" if "created_at" in executable_text else "date"
+    if "今天" in executable_text or "today" in executable_text:
         conditions.append(f"{date_col} = CURRENT_DATE")
-    elif "昨天" in text or "yesterday" in text:
+    elif "昨天" in executable_text or "yesterday" in executable_text:
         conditions.append(f"{date_col} = DATE_SUB(CURRENT_DATE, 1)")
-    elif "前天" in text or "day before" in text:
+    elif "前天" in executable_text or "day before" in executable_text:
         conditions.append(f"{date_col} = DATE_SUB(CURRENT_DATE, 2)")
-    elif "明天" in text or "tomorrow" in text:
+    elif "明天" in executable_text or "tomorrow" in executable_text:
         conditions.append(f"{date_col} = DATE_ADD(CURRENT_DATE, 1)")
 
     time_patterns = [
@@ -189,7 +283,7 @@ def extract_conditions(
         (r"(最近|过去|last|past)\s*(\d+)\s*(年|year)", "YEAR"),
     ]
     for pattern, unit in time_patterns:
-        match = re.search(pattern, text, re.IGNORECASE)
+        match = re.search(pattern, executable_text, re.IGNORECASE)
         if match:
             n = match.group(2)
             if unit == "DAY":
@@ -204,39 +298,24 @@ def extract_conditions(
 
     # 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:
+        if ("last week" in executable_text or "本周" in executable_text) and "this week" not in executable_text and "本周" not in executable_text:
             conditions.append(f"{date_col} >= DATE_SUB(CURRENT_DATE, 7)")
-        if "last month" in text:
+        if "last month" in executable_text:
             conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -1)")
-        if "last year" in text:
+        if "last year" in executable_text:
             conditions.append(f"{date_col} >= ADD_MONTHS(CURRENT_DATE, -12)")
 
-    if "本周" in text or "this week" in text:
+    if "本周" in executable_text or "this week" in executable_text:
         conditions.append(f"WEEKOFYEAR({date_col}) = WEEKOFYEAR(CURRENT_DATE)")
-    if "本月" in text or "this month" in text:
+    if "本月" in executable_text or "this month" in executable_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:
+    if "本年" in executable_text or "this year" in executable_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
+    status_conditions = extract_status_conditions(text)
+    for status_condition in status_conditions:
+        if status_condition.split(" ", 1)[0] not in in_matched_columns:
+            conditions.append(status_condition)
     return conditions

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/backend/core/nl2sql_pipeline/templates.py

@@ -316,17 +316,6 @@ def generate_from_template(
             # never re-append them here as a second WHERE.
             if template.name == "top_n_query" and "DATE_SUB" not in c and "ADD_MONTHS" not in c and "DATE_ADD" not in c:
                 continue
-            if not any(
-                kw in text_lower
-                for kw in [
-                    "today", "yesterday", "tomorrow", "last", "past",
-                    "本周", "本月", "本年", "今天", "昨天", "明天"
-                ]
-            ) and c in [
-                "status = 'active'", "status = 'inactive'",
-                "is_deleted = 1", "is_deleted = 0"
-            ]:
-                continue
             merged_conditions.append(c)
         if merged_conditions:
             if "WHERE" in sql.upper():

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sql-dialect-master"
-version = "1.4.0"
+version = "1.4.1"
 description = "SQL Dialect Master - Multi-database SQL conversion engine"
 readme = "README.md"
 requires-python = ">=3.11"

{sql_dialect_master-1.4.0 → sql_dialect_master-1.4.1}/sql_dialect_master.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.4.0
+Version: 1.4.1
 Summary: SQL Dialect Master - Multi-database SQL conversion engine
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -38,7 +38,7 @@ Dynamic: license-file
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.4.0
+Current release: 1.4.1
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)