sql-dialect-master 1.1.1__tar.gz → 1.1.2__tar.gz

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.1.1
+Version: 1.1.2
 Summary: SQL Dialect Master - Multi-database SQL conversion engine
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.1.1
+Current release: 1.1.2
 
 [![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.1.1 → sql_dialect_master-1.1.2}/README.md

@@ -2,7 +2,7 @@
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.1.1
+Current release: 1.1.2
 
 [![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.1.1 → sql_dialect_master-1.1.2}/backend/api/main.py

@@ -25,6 +25,7 @@ from backend.core.config import get_dialect_api_info, settings, setup_logging
 from backend.core import metadata as meta
 from backend.core.functions_lookup import FunctionEncyclopedia
 from backend.core.nl2sql import NL2SQLGenerator
+from backend.core.nl2sql_pipeline.orchestrator import SAFE_TABLE_HINT
 from backend.core.parser import SUPPORTED_DIALECTS, SQLParser
 from backend.core.transpiler import SQLTranspiler
 from backend.core.type_mapping import TypeMapper
@@ -568,7 +569,7 @@ async def map_type(request: TypeMapRequest):
         target_dialect,
     )
     return {
-        "success": True,
+        "success": result.get("success", False),
         **result,
         "timestamp": datetime.now().isoformat()
     }
@@ -586,6 +587,17 @@ async def generate_sql(request: NL2SQLRequest):
     - "Get top 10 users by score" → SELECT * FROM users ORDER BY score DESC LIMIT 10
     """
     dialect = normalize_dialect(request.dialect)
+    # Validate table_hint at the API boundary: an illegal identifier is
+    # a client error (4xx), never an internal ValueError → 500.  The
+    # same rule backs the orchestrator's direct-caller ValueError.
+    if request.table_hint and not SAFE_TABLE_HINT.fullmatch(request.table_hint.strip()):
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "Invalid table_hint: must be a simple SQL identifier or "
+                "dotted identifier"
+            ),
+        )
     result = nl2sql_generator.generate(
         request.text,
         dialect,

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/api/rate_limit_store.py

@@ -5,10 +5,11 @@ Redis is opt-in. The in-memory backend remains the default for local/single-proc
 
 from __future__ import annotations
 
-import os
 import time
 from threading import Lock
-from typing import Protocol
+from typing import Optional, Protocol
+
+from backend.core.config import AppSettings, settings as _default_settings
 
 
 class RateLimitStore(Protocol):
@@ -95,11 +96,28 @@ class RedisRateLimitStore:
         return {"backend": "redis", "namespace": self._namespace}
 
 
-def create_rate_limit_store() -> RateLimitStore:
-    """Create the configured store; never silently downgrade Redis to memory."""
-    backend = os.getenv("SDM_RATE_LIMIT_BACKEND", "memory").strip().lower()
+def create_rate_limit_store(config: Optional[AppSettings] = None) -> RateLimitStore:
+    """Create the configured store; never silently downgrade Redis to memory.
+
+    Reads configuration from ``config``, or from the unified
+    ``backend.core.config.settings`` singleton when ``config`` is None.
+    The factory never reads raw environment variables — all deployment
+    configuration flows through AppSettings (SDM_ prefix), so backend
+    selection and the Redis URL share one validated configuration path.
+
+    The Redis URL is a SecretStr in AppSettings; its actual value is
+    read here only to construct the Redis client, and it is never
+    embedded in error messages or logs.
+    """
+    settings_obj = config if config is not None else _default_settings
+    backend = settings_obj.rate_limit_backend
     if backend == "memory":
         return InMemoryRateLimitStore()
     if backend == "redis":
-        return RedisRateLimitStore(os.getenv("SDM_REDIS_URL", ""))
-    raise ValueError("Unsupported SDM_RATE_LIMIT_BACKEND; expected 'memory' or 'redis'")
+        url = settings_obj.redis_url
+        url_value = url.get_secret_value() if url is not None else ""
+        return RedisRateLimitStore(url_value)
+    # Boundary guard for untyped callers: only reachable when a caller
+    # passes a non-AppSettings object with an unexpected backend value
+    # (typed AppSettings validation rejects it earlier).
+    raise ValueError("Unsupported rate_limit_backend; expected 'memory' or 'redis'")

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/config.py

@@ -12,9 +12,9 @@ Supports configuration via:
 import logging
 import sys
 from enum import Enum
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, Dict, List, Literal, Optional, TypedDict
 
-from pydantic import Field
+from pydantic import Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # =============================================================================
@@ -232,6 +232,15 @@ class AppSettings(BaseSettings):
     rate_limit_enabled: bool = True
     rate_limit_requests: int = 100
     rate_limit_window: int = 60
+    # Storage backend selection: strict lowercase values; no case or
+    # whitespace normalization — a Literal rejects any other spelling at
+    # settings construction instead of silently coercing it.
+    rate_limit_backend: Literal["memory", "redis"] = "memory"
+    # Redis connection URL, required only when the backend is redis.
+    # SecretStr keeps the password out of repr / logs / serialization;
+    # the store factory reads the actual value only to build the Redis
+    # client.  Default None = not configured.
+    redis_url: Optional[SecretStr] = None
     
     # NL2SQL settings
     nl2sql_confidence_threshold: float = 0.6

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/metadata.py

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

sql_dialect_master-1.1.2/backend/core/nl2sql_components/aggregations.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""NL2SQL aggregation extraction.
+
+Extracts aggregate function calls (COUNT, SUM, AVG, MAX, MIN) from
+natural-language text using keyword matching. Uses the shared
+COLUMN_PATTERNS to resolve the target column for value aggregates.
+"""
+import re
+from typing import Dict, List
+
+
+def extract_aggregations(text: str, column_patterns: Dict[str, str]) -> List[str]:
+    """Extract aggregation expressions from text.
+
+    Returns a list of SQL aggregate expressions, e.g.
+    ['COUNT(*)', 'SUM(amount)']. An empty list means no aggregation
+    was requested.
+    """
+    aggs: List[str] = []
+    text_lower = text.lower()
+    # Pick the user's named metric column, not the first pattern that
+    # happens to sit inside an aggregate keyword: the legacy first-hit
+    # walk let "average" contain "age" and produced AVG(age).
+    named_metrics = [
+        column
+        for pattern, column in column_patterns.items()
+        if pattern != "age" and pattern in text
+    ]
+    # Bare "age" is only a metric when it is not the trailing substring
+    # of "average": require a non-letter before it so "average" never
+    # self-matches, while "average age" still does.
+    if re.search(r"(?<![a-z])age", text_lower):
+        if "age" not in named_metrics:
+            named_metrics.append("age")
+    if "price" in text_lower:
+        named_metrics = [c for c in named_metrics if c != "age"]
+    agg_column = named_metrics[0] if named_metrics else None
+    col = agg_column or "amount"
+    if any(k in text for k in ["统计", "计数", "数量", "多少", "几个", "count", "total", "how many"]):
+        aggs.append("COUNT(*)")
+    if any(k in text for k in ["求和", "总和", "合计", "总计", "sum", "total of"]):
+        aggs.append(f"SUM({col})")
+    if any(k in text_lower for k in ["平均", "均值", "平均值", "average", "avg", "mean"]):
+        # "average" contains "age": the average metric is price unless
+        # the text explicitly names the age column as the target.
+        col = "price" if ("price" in text_lower and not re.search(r"(?<![a-z])age", text_lower)) else (agg_column or "amount")
+        aggs.append(f"AVG({col})")
+    if any(k in text_lower for k in ["最大", "最高", "最多", "max", "maximum", "highest", "largest"]):
+        aggs.append(f"MAX({col})")
+    if any(k in text_lower for k in ["最小", "最低", "最少", "min", "minimum", "lowest", "smallest"]):
+        aggs.append(f"MIN({col})")
+    return aggs

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/nl2sql_components/core_extract.py

@@ -38,18 +38,29 @@ def extract_table(text: str, table_patterns: Dict[str, str]) -> str:
     return "table_name"
 
 
-def extract_table_subject(text: str, table_patterns: Dict[str, str]) -> Optional[str]:
+def extract_table_subject(
+    text: str, table_patterns: Dict[str, str], relational_context: str = ""
+) -> Optional[str]:
     """Extract the subject table (first appearing in text) for D2 relational queries.
 
     For queries like 'users who have orders', returns 'users' (the subject)
     rather than 'orders' (the relation). Uses first occurrence position.
+
+    ``relational_context`` names the relation table when the caller already
+    resolved one from the relational keyword set (e.g. the CN 有订单
+    connective maps 订单 → orders).  That table must not win the subject
+    slot even when it is the earliest-matching pattern, so every candidate
+    table equal to it is excluded before the first-occurrence sort.
     """
     candidates = []
     for pattern, table in table_patterns.items():
-        if table not in candidates:
-            pos = text.find(pattern)
-            if pos != -1:
-                candidates.append((pos, table))
+        if relational_context and table == relational_context:
+            continue
+        pos = text.find(pattern)
+        if pos != -1:
+            if table in [t for _, t in candidates]:
+                continue
+            candidates.append((pos, table))
     if candidates:
         candidates.sort(key=lambda x: x[0])
         return candidates[0][1]

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/nl2sql_components/relations.py

@@ -27,6 +27,8 @@ JOIN_KEY_PATTERNS: Dict[tuple, str] = {
     ("payments", "orders"): "payments.order_id = orders.id",
     ("customers", "orders"): "customers.id = orders.customer_id",
     ("orders", "customers"): "orders.customer_id = customers.id",
+    ("customers", "payments"): "customers.id = payments.customer_id",
+    ("payments", "customers"): "payments.customer_id = customers.id",
 }
 
 # Negative relational existence keywords -> NOT EXISTS
@@ -34,6 +36,8 @@ _NOT_EXISTS_KEYWORDS = [
     "without", "not have", "no ",
     "who don't have", "who doesn't have",
     "who do not have", "who does not have",
+    # Chinese negative relational intent: "没有任何X的" / "没有X的".
+    "没有任何",
 ]
 
 # Positive relational existence keywords -> EXISTS
@@ -44,6 +48,10 @@ _EXISTS_KEYWORDS = [
     "with invoices", "with payments", "with transactions",
     "with suppliers", "with products",
     "who placed", "who made", "who created", "who submitted",
+    # Chinese positive relational intent: "有订单的" / "有X的" phrasings.
+    # "有" alone is far too broad; the 2-char forms below are specific
+    # enough to signal a relational predicate ("users who have orders").
+    "有订单", "有产品", "有客户", "有员工", "有日志",
 ]
 
 
@@ -111,6 +119,18 @@ def guess_join_key(table1: str, table2: str) -> Optional[str]:
     return JOIN_KEY_PATTERNS.get((table1, table2))
 
 
+# Chinese relational table connectives: the modifier word that names the
+# relation table.  '查询有订单的用户' → 订单 is the relation table, 用户
+# is the subject.  The modifier must sit between the existence keywords
+# (有 / 没有任何 / 没有) and the trailing 的 / end-of-phrase, so we match
+# the <modifier> token directly in the lowercased text.
+_CN_REL_TABLES = {
+    "订单": "orders", "产品": "products", "客户": "customers",
+    "员工": "employees", "日志": "logs", "发票": "invoices",
+    "支付": "payments", "交易": "transactions",
+}
+
+
 def extract_joins(
     text: str,
     table_patterns: Dict[str, str],
@@ -129,19 +149,56 @@ def extract_joins(
     joins = []
     # Collect unique tables in text-appearance order (first occurrence wins).
     # Exclude "order" when it is part of an "order by" sorting clause.
+    # EN word-boundary matching stays for ASCII patterns; CJK patterns have
+    # no word boundaries, so they match by direct occurrence — this is what
+    # lets '用户' / '订单' register inside a Chinese sentence.
     table_occurrences = []
+    text_lower = text.lower()
     for pattern, table in table_patterns.items():
         if pattern == "order" and re.search(r"\border\b\s+by\b", text, re.IGNORECASE):
             continue
-        if re.search(r"\b" + re.escape(pattern) + r"\b", text) and table not in [t for _, t in table_occurrences]:
-            table_occurrences.append((text.find(pattern), table))
+        if table in ("table", "tables", "data"):
+            # Generic aliases are not resolvable table names; including
+            # them only creates phantom multi-table requests.
+            continue
+        if pattern.isascii():
+            matched = re.search(r"\b" + re.escape(pattern) + r"\b", text, re.IGNORECASE)
+        else:
+            matched = re.search(re.escape(pattern), text)
+        if matched and table not in [t for _, t in table_occurrences]:
+            # Position = the pattern occurrence the match actually landed on.
+            # text.find() fails for ASCII patterns when case differs and for
+            # CJK patterns when an earlier raw occurrence exists; matched
+            # carries the real start index for the occurrence we used.
+            start = matched.start()
+            table_occurrences.append((start, table))
+    # Chinese relational connective: when 有/没有任何/没有 is followed by a
+    # known relation-table word, that word names the relation table even if
+    # the CJK pattern loop above did not catch it (e.g. the relation table
+    # is an EN-lexed alias).  The modifier position is strictly before the
+    # subject table position — it is the phrase "有<relation>的<subject>"
+    # — so inserting it at its own position keeps tables_found ordered by
+    # text position and picks out the subject correctly below.
+    for modifier, rel_table in _CN_REL_TABLES.items():
+        if re.search(r"(?:有|没有任何|没有)" + re.escape(modifier), text_lower):
+            if rel_table not in [t for _, t in table_occurrences]:
+                table_occurrences.append((text_lower.find(modifier), rel_table))
+            break
     tables_found = [t for _, t in sorted(table_occurrences)]
     if len(tables_found) >= 2:
         join_spec = parse_join_spec(text)
-        if any(k in text for k in _NOT_EXISTS_KEYWORDS):
+        cn_relational = any(
+            re.search(r"(?:有|没有任何|没有)" + re.escape(modifier), text)
+            for modifier in _CN_REL_TABLES
+        )
+        cn_negative = any(
+            re.search(r"(?:没有任何|没有)" + re.escape(modifier), text)
+            for modifier in _CN_REL_TABLES
+        )
+        if any(k in text for k in _NOT_EXISTS_KEYWORDS) or (cn_negative and cn_relational):
             join_type = "NOT EXISTS"
             relational = True
-        elif any(k in text for k in _EXISTS_KEYWORDS):
+        elif any(k in text for k in _EXISTS_KEYWORDS) or (cn_relational and not cn_negative):
             join_type = "EXISTS"
             relational = True
         elif join_spec is not None:
@@ -153,8 +210,26 @@ def extract_joins(
             join_type = "JOIN"
             relational = False
 
-        main_table = tables_found[0]
-        for other_table in tables_found[1:]:
+        # Chinese relational intent (有订单的用户 etc.): the subject table is
+        # the one the user named last ("the users"), and the relation table is
+        # the one named in the 有/没有 modifier (the orders).  tables_found
+        # is sorted by position, so the subject is the last entry, and the
+        # relation table is whichever was added by the CN-modifier branch.
+        # Detect: when the Chinese connective fired, the relation table is
+        # exactly the one the modifier branch appended.
+        cn_relation_table = None
+        for modifier, rel_table in _CN_REL_TABLES.items():
+            if re.search(r"(?:有|没有任何|没有)" + re.escape(modifier), text_lower):
+                cn_relation_table = rel_table
+                break
+        if cn_relation_table and len(tables_found) >= 2:
+            # Subject = the first-appearing table that is NOT the CN relation
+            # table; relation = the CN table.
+            subject_candidates = [t for t in tables_found if t != cn_relation_table]
+            main_table = subject_candidates[0] if subject_candidates else tables_found[0]
+        else:
+            main_table = tables_found[0]
+        for other_table in ([cn_relation_table] if cn_relation_table else [t for t in tables_found[1:]]):
             join_key = guess_join_key(main_table, other_table)
             record = {
                 "type": join_type,
@@ -175,6 +250,21 @@ def extract_joins(
 
 
 def has_relational_keyword(text: str) -> bool:
-    """Check if text contains any relational existence keyword."""
-    all_keywords = _NOT_EXISTS_KEYWORDS + _EXISTS_KEYWORDS
-    return any(pattern in text for pattern in all_keywords)
+    """Check if text contains any relational existence keyword.
+
+    CN table-modifier phrases (有订单 / 没有任何订单 …) are also relational
+    intent even without the EN 'have/without' phrasing.  Bare EN "with <表>"
+    is only relational when a subject-table word also names the request:
+    'find users with orders' is relational; 'find orders' alone is not.
+    """
+    all_keywords = _NOT_EXISTS_KEYWORDS + [
+        # 'with <表>' forms are gated in extract_joins; here we include
+        # them in the keyword list but let extract_joins filter by
+        # subject-table presence (see _resolve_relational_kind).
+    ] + _EXISTS_KEYWORDS
+    if any(pattern in text for pattern in all_keywords):
+        return True
+    for modifier in _CN_REL_TABLES:
+        if re.search(r"(?:有|没有任何|没有)" + re.escape(modifier), text):
+            return True
+    return False

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/nl2sql_components/templates.py

@@ -18,6 +18,11 @@ _COMPOSITION_MARKERS = (
     "group by", "grouped by", "分组", "汇总",
     "limit", "top ", "top\t", "only ", "前",
     " and ", " or ", "且", "并且", "或者", "或",
+    # Chinese relational-existence phrases: capture by the enhanced path
+    # (EXISTS/NOT EXISTS + fail-closed), never by a single-table select
+    # template that would silently drop the relationship.
+    "有订单", "有产品", "有客户", "有员工", "有日志",
+    "没有任何订单", "没有任何产品", "没有任何客户",
 )
 
 _TEMPLATE_BLOCKERS = {
@@ -93,7 +98,7 @@ DEFAULT_QUERY_TEMPLATES = [
     ),
     QueryTemplate(
         name="time_range_query",
-        pattern=r"(?:查询|获取|get|find)?\s*(?:最近|过去|last|past)\s*(\d+)\s*(天|周|月|年|days?|weeks?|months?|years?)\s*(?:的|内的)?\s*(.+)",
+        pattern=r"(?:查询|获取|get|find)?\s*(?:最近|过去|last|past)\s*(\d+)\s*(天|周|月|年|days?|weeks?|months?|years?)(?:的|内的)?\s*(.+)",
         sql_template="SELECT * FROM {table} WHERE {date_col} >= DATE_SUB(CURRENT_DATE, {interval})",
         priority=85,
     ),

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/nl2sql_pipeline/orchestrator.py

@@ -67,6 +67,13 @@ from .validation import validate_sql as _validate_sql_impl
 
 logger = logging.getLogger(__name__)
 
+# Canonical table_hint identifier rule, shared by the orchestrator (which
+# raises ValueError for direct callers) and the API boundary (which
+# converts the violation into a 4xx validation error before generation).
+SAFE_TABLE_HINT = re.compile(
+    r"[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*"
+)
+
 
 class PipelineNL2SQLGenerator:
     """NL2SQL pipeline base class.
@@ -180,13 +187,10 @@ class PipelineNL2SQLGenerator:
                 f"Unsupported dialect: {dialect}. "
                 f"Supported: {', '.join(SUPPORTED_DIALECTS)}"
             )
-        _SAFE_TABLE_HINT = re.compile(
-            r"[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*"
-        )
         normalized_table_hint = (
             table_hint.strip() if isinstance(table_hint, str) else table_hint
         )
-        if normalized_table_hint and not _SAFE_TABLE_HINT.fullmatch(normalized_table_hint):
+        if normalized_table_hint and not SAFE_TABLE_HINT.fullmatch(normalized_table_hint):
             raise ValueError(
                 "table_hint must be a simple SQL identifier or dotted identifier"
             )
@@ -258,12 +262,13 @@ class PipelineNL2SQLGenerator:
             parsed = self._parse_text(text_lower, text)
             parsed.update(analysis)
             operation = self._detect_operation(text_lower)
+            cn_rel_table = self._cn_relation_table(text_lower)
             if self._has_relational_keyword(text_lower):
                 # Relational subject: 'users who have orders where price = 5'
                 # must yield FROM users, not FROM orders.
                 table = (
                     table_hint
-                    or self._extract_table_subject(text_lower)
+                    or self._extract_table_subject(text_lower, cn_rel_table)
                     or self._extract_table(text_lower)
                 )
             else:
@@ -306,6 +311,15 @@ class PipelineNL2SQLGenerator:
         if template and self._has_relational_keyword(text_lower):
             template = None
             logger.debug("NL2SQL: Relational keyword detected, bypassing template matching")
+        # A select/simpler template that captures a request naming two
+        # tables via Chinese connectives (用户 和 发票) must route to the
+        # enhanced path too: the select_with_columns / simple_select
+        # templates would silently drop the second table's relationship
+        # instead of failing closed.
+        elif template and template.name in ("select_with_columns", "simple_select"):
+            if len(self._named_tables(text_lower)) >= 2:
+                template = None
+                logger.debug("NL2SQL: multi-table select captured by select template, bypassing")
         if template:
             result = self._generate_from_template(
                 template, match_groups, analysis, dialect,
@@ -336,8 +350,20 @@ class PipelineNL2SQLGenerator:
         # tables is a relational/join request; it only succeeds when every
         # pair between the mentioned tables has a canonical relationship.
         named_tables = self._named_tables(text_lower)
+        cn_rel_table = self._cn_relation_table(text_lower)
         if len(named_tables) >= 2:
-            table = table_hint or named_tables[0]
+            # Relational subject-table resolution: when the request carries
+            # a relational connective (D2/CN 有<relation>的<subject>), the
+            # outer FROM is the subject table, not the relation table the
+            # connective names.
+            table = (
+                table_hint
+                or (
+                    self._extract_table_subject(text_lower, cn_rel_table)
+                    if self._has_relational_keyword(text_lower)
+                    else named_tables[0]
+                )
+            )
             unresolved = [j for j in joins if j.get("condition") is None]
             if unresolved:
                 pair_desc = " ⟷ ".join(
@@ -362,8 +388,13 @@ class PipelineNL2SQLGenerator:
                     ],
                 )
         else:
+            cn_rel_table = self._cn_relation_table(text_lower)
             if self._has_relational_keyword(text_lower):
-                table = table_hint or self._extract_table_subject(text_lower) or "table_name"
+                table = (
+                    table_hint
+                    or self._extract_table_subject(text_lower, cn_rel_table)
+                    or "table_name"
+                )
             else:
                 table = table_hint or self._extract_table(text_lower)
 
@@ -412,12 +443,19 @@ class PipelineNL2SQLGenerator:
         """
         return _pipeline_extract_table(text, self.TABLE_PATTERNS)
 
-    def _extract_table_subject(self, text: str) -> Optional[str]:
+    def _extract_table_subject(
+        self, text: str, relational_context: str = ""
+    ) -> Optional[str]:
         """Extract the subject table (first appearing in text) for D2 relational queries.
 
-        Delegates to ``nl2sql_pipeline.resolution.extract_table_subject``.
+        Delegates to ``nl2sql_pipeline.resolution.extract_table_subject``;
+        ``relational_context`` excludes the already-resolved relation table
+        from the subject slot so '查询有订单的用户' returns 'users', not
+        'orders'.
         """
-        return _pipeline_extract_table_subject(text, self.TABLE_PATTERNS)
+        return _pipeline_extract_table_subject(
+            text, self.TABLE_PATTERNS, relational_context
+        )
 
     def _named_tables(self, text: str) -> list:
         """Return the distinct table names the text mentions.
@@ -477,6 +515,16 @@ class PipelineNL2SQLGenerator:
         """
         return _pipeline_extract_joins(text, self.TABLE_PATTERNS)
 
+    def _cn_relation_table(self, text: str) -> str:
+        """Return the CN relational connective's table (orders, products, ...)
+        when present in ``text``; otherwise ""."""
+        import re as _re
+        from ..nl2sql_components.relations import _CN_REL_TABLES
+        for modifier, rel_table in _CN_REL_TABLES.items():
+            if _re.search(r"(?:有|没有任何|没有)" + _re.escape(modifier), text):
+                return rel_table
+        return ""
+
     def _guess_join_key(self, table1: str, table2: str) -> Optional[str]:
         """Guess the join key between two tables.
 

{sql_dialect_master-1.1.1 → sql_dialect_master-1.1.2}/backend/core/nl2sql_pipeline/predicates.py

@@ -86,8 +86,68 @@ def extract_conditions(
         (["小于", "低于", "少于", "不足", "less", "less than", "below", "under", "<"], "<"),
         (["等于", "是", "为", "equals", "equal", "="], "="),
     ]
+    # For each operator word, the threshold is the number that
+    # immediately follows it in the original text (not numbers[0] —
+    # '前10条金额大于100' must bind 100 to 大于, not 10).  Multi-char
+    # operator words are tried in longest-first order so that e.g.
+    # 大于等于 binds its own value before the 大于 row fires on the same
+    # text — the legacy row order let the shorter 大于 substring steal
+    # an 大于等于 match and emit ">" instead of ">=".
+    #
+    # The primary value bind (operator word → number directly after it)
+    # is the canonical form.  When that bind fails but an operator word
+    # is still present (e.g. 'greater than 5' — number follows 'than',
+    # not 'greater'), a fallback binds the column before the operator
+    # word to the first number after it.  This keeps the legacy
+    # operator-word + numbers[0] behavior for English phrases while
+    # correcting the Chinese case where the operator word sits between
+    # the column and the threshold number.
     for keywords, op in comparisons:
-        if any(keyword in text for keyword in keywords) and numbers:
+        bound_value = None
+        matched_keyword = None
+        # Primary bind: the number that immediately follows the operator
+        # 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:
+                continue
+            m = re.search(
+                re.escape(keyword) + r"\s*(\d+(?:\.\d+)?)",
+                original,
+            )
+            if m:
+                bound_value = m.group(1)
+                matched_keyword = keyword
+                break
+        # Second bind: the number at the END of the operator phrase
+        # (English "greater than 100" / "greater than or equal to 100"
+        # — the value follows "than"/"to", not the operator's head word).
+        # The Top-N count that precedes the whole phrase (numbers[0] =
+        # "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:
+                    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,
+                    re.IGNORECASE,
+                )
+                if m:
+                    bound_value = m.group(1)
+                    matched_keyword = keyword
+                    break
+        if matched_keyword is not None and bound_value is None and numbers:
+            bound_value = numbers[0]
+        if bound_value is not None:
+            col = condition_column or "column"
+            conditions.append(f"{col} {op} {bound_value}")
+            break
+        # 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:
             col = condition_column or "column"
             conditions.append(f"{col} {op} {numbers[0]}")
             break