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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.4.1
+Version: 1.6.0
 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.1
+Current release: 1.6.0
 
 [![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.1 → sql_dialect_master-1.6.0}/README.md

@@ -2,7 +2,7 @@
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.4.1
+Current release: 1.6.0
 
 [![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.1 → sql_dialect_master-1.6.0}/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.1"
-API_VERSION = "1.4.1"
+PROJECT_VERSION = "1.6.0"
+API_VERSION = "1.6.0"
 # Frontend v2 architecture — independent of the product release version.
 FRONTEND_ARCHITECTURE_VERSION = 2
 

{sql_dialect_master-1.4.1 → sql_dialect_master-1.6.0}/backend/core/nl2sql_pipeline/orchestrator.py

@@ -98,6 +98,45 @@ _DATE_INTERVAL = re.compile(
     re.IGNORECASE,
 )
 MAX_NL2SQL_DATE_INTERVAL_DAYS = 36525
+_SCHEMA_WHOSE_PREFIX = re.compile(
+    r"\bwhose\s+"
+    r"([A-Za-z_][A-Za-z0-9_$]*|"
+    r"[A-Za-z_][A-Za-z0-9_$]*\.[A-Za-z_][A-Za-z0-9_$]*|"
+    r"[A-Za-z_][A-Za-z0-9_$]*\.[A-Za-z_][A-Za-z0-9_$]*\.[A-Za-z_][A-Za-z0-9_$]*)\s+"
+    r"(is\s+not|isn't|is|equals|<>|!=|>=|<=|=|>|<)\s*",
+    re.IGNORECASE,
+)
+_SCHEMA_WHOSE_REJECTED_VALUES = {
+    "and", "or", "not", "is", "null", "true", "false", "unknown",
+    "select", "from", "where", "group", "order", "by", "limit",
+    "current_date", "current_timestamp", "now",
+}
+_SCHEMA_WHOSE_CJK_CONNECTORS = {"和", "或", "且", "并", "与", "跟", "及"}
+_SCHEMA_JOINED_ON_PREFIX = re.compile(
+    r"\b(?:(inner|left|right)\s+)?joined\s+on\b",
+    re.IGNORECASE,
+)
+_SCHEMA_JOINED_ON_OPERAND = re.compile(
+    r"[A-Za-z_][A-Za-z0-9_$]*\.[A-Za-z_][A-Za-z0-9_$]*"
+    r"(?:\.[A-Za-z_][A-Za-z0-9_$]*)?"
+)
+_SCHEMA_JOINED_WITH_PREFIX = re.compile(
+    r"\b(?:(inner|left|right)\s+)?joined\s+with\s+"
+    r"([A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)?)\b",
+    re.IGNORECASE,
+)
+_SCHEMA_GROUP_LABEL_COLUMNS = {
+    "部门": ("department", "dept"),
+    "状态": ("status",),
+    "类型": ("type",),
+    "分类": ("category",),
+    "日期": ("date",),
+    "地区": ("region",),
+    "区域": ("region",),
+    "品牌": ("brand",),
+    "级别": ("level",),
+    "优先级": ("priority",),
+}
 
 
 class PipelineNL2SQLGenerator:
@@ -626,14 +665,20 @@ class PipelineNL2SQLGenerator:
         return [table for _, table in sorted(found.values(), key=lambda item: item[0])]
 
     def _schema_unknown_table_patterns(
-        self, text: str, schema: SchemaContext
+        self,
+        text: str,
+        schema: SchemaContext,
+        ignored_spans: tuple[tuple[int, int], ...] = (),
     ) -> list[str]:
         """Return mapped table names mentioned by the request but absent in schema."""
+        for start, end in ignored_spans:
+            text = text[:start] + " " * (end - start) + text[end:]
         unknown: list[str] = []
         for pattern, mapped in self.TABLE_PATTERNS.items():
             if pattern == "order" and re.search(r"\border\b\s+by\b", text, re.IGNORECASE):
                 continue
-            if not self._schema_text_match(text, pattern):
+            match = self._schema_text_match(text, pattern)
+            if not match:
                 continue
             if schema.table_candidates(mapped):
                 continue
@@ -642,6 +687,152 @@ class PipelineNL2SQLGenerator:
             unknown.append(mapped)
         return sorted(set(unknown))
 
+    def _schema_entity_counter_tables(self, text: str) -> set[str]:
+        """Find entity counters without treating data words as counts."""
+        return {
+            mapped for pattern, mapped in self.TABLE_PATTERNS.items()
+            if re.search(re.escape(pattern) + r"数(?!据|字|组)", text, re.IGNORECASE)
+        }
+
+    def _schema_aggregation_intent(self, text: str) -> bool:
+        return bool(re.search(
+            r"\b(?:number\s+of|count(?:\s+of)?|how\s+many|sum|average|avg|maximum|minimum|max|min)\b|"
+            r"统计|数量|多少|几个|总数|个数|条数|件数|行数|人数|记录数|"
+            r"平均|总和|汇总|最大|最小|最多|最少",
+            text,
+            re.IGNORECASE,
+        )) or bool(self._schema_entity_counter_tables(text))
+
+    def _schema_resolve_english_group_label(
+        self, text: str, schema: SchemaContext
+    ) -> tuple[SchemaTableContext, str, tuple[int, int]] | None:
+        if not self._schema_aggregation_intent(text):
+            return None
+        match = re.search(
+            r"\b(?:per|each)\s+([A-Za-z_][A-Za-z0-9_$]*)\b",
+            text,
+            re.IGNORECASE,
+        )
+        if match is None:
+            return None
+        label = match.group(1)
+        if text[match.end():].strip(" \t\r\n,.;，。；"):
+            raise SchemaValidationError("multiple schema group labels are unsupported")
+        return self._schema_resolve_group_label(
+            text, label, (match.start(), match.end()), schema
+        )
+
+    def _schema_resolve_chinese_group_label(
+        self, text: str, schema: SchemaContext
+    ) -> tuple[SchemaTableContext, str, tuple[int, int]] | None:
+        if not self._schema_aggregation_intent(text):
+            return None
+        match = re.search(
+            r"(?:每个|各个|每位)\s*([\u4e00-\u9fff]{1,8}?)"
+            r"(?=的|员工|订单|产品|客户|交易|支付|日志|记录|数量|用户|$)",
+            text,
+        )
+        if match is None:
+            return None
+        if re.search(r"每个|各个|每位", text[match.end():]):
+            raise SchemaValidationError("multiple schema group labels are unsupported")
+        return self._schema_resolve_group_label(
+            text, match.group(1), (match.start(), match.end()), schema
+        )
+
+    def _schema_resolve_group_label(
+        self,
+        text: str,
+        label: str,
+        span: tuple[int, int],
+        schema: SchemaContext,
+    ) -> tuple[SchemaTableContext, str, tuple[int, int]]:
+        """Resolve one consumed label without treating its table as a JOIN."""
+        masked = text[:span[0]] + " " * (span[1] - span[0]) + text[span[1]:]
+        mentioned = self._schema_table_mentions(masked, schema)
+        if len(mentioned) != 1:
+            raise SchemaValidationError("schema group label subject is ambiguous")
+        data_table = mentioned[0]
+        column_names = (label, *_SCHEMA_GROUP_LABEL_COLUMNS.get(label, ()))
+        column_keys = {name.casefold() for name in column_names}
+        direct_columns = {
+            column for column in data_table.columns
+            if column.casefold() in column_keys
+        }
+        if len(direct_columns) > 1:
+            raise SchemaValidationError("schema group label column is ambiguous")
+        if direct_columns:
+            return data_table, direct_columns.pop(), span
+
+        label_tables = schema.table_candidates(label)
+        if not label_tables:
+            mapped_labels = [
+                mapped for pattern, mapped in self.TABLE_PATTERNS.items()
+                if pattern.casefold() == label.casefold()
+            ]
+            candidates = [
+                candidate
+                for mapped in mapped_labels
+                for candidate in schema.table_candidates(mapped)
+            ]
+            label_tables = tuple({candidate.key: candidate for candidate in candidates}.values())
+        if len(label_tables) != 1:
+            raise SchemaValidationError("schema group label is not a unique table")
+        label_table = label_tables[0]
+        if label_table.key == data_table.key:
+            raise SchemaValidationError("schema group label cannot be the subject table")
+
+        # Only an explicitly declared data-table -> label-table relationship
+        # proves that the data table carries the grouping foreign key.  The
+        # relationship index also exposes synthetic reverse entries for join
+        # resolution, which must not be used here: accepting one would make a
+        # request such as "users per order" group users by their primary key.
+        relationships = tuple(
+            relationship
+            for relationship in schema.relationships
+            if relationship.from_table.casefold() == data_table.key
+            and relationship.to_table.casefold() == label_table.key
+        )
+        if len(relationships) == 1:
+            label_singular = (
+                label[:-1] if label.casefold().endswith("s") else label
+            )
+            table_basename = label_table.name.rsplit(".", 1)[-1]
+            table_singular = (
+                table_basename[:-1]
+                if table_basename.casefold().endswith("s")
+                else table_basename
+            )
+            allowed_foreign_keys = {
+                f"{label_singular}_id".casefold(),
+                f"{table_singular}_id".casefold(),
+                f"{table_basename}_id".casefold(),
+            }
+            from_column = relationships[0].from_column
+            if from_column.casefold() not in allowed_foreign_keys:
+                raise SchemaValidationError(
+                    "schema group label relationship has an unsupported foreign key"
+                )
+            return data_table, from_column, span
+        if len(relationships) > 1:
+            raise SchemaValidationError("schema group label relationship is ambiguous")
+
+        table_basename = label_table.name.rsplit(".", 1)[-1]
+        singular = (
+            table_basename[:-1]
+            if table_basename.casefold().endswith("s")
+            else table_basename
+        )
+        foreign_keys = [
+            column for column in data_table.columns
+            if column.casefold() == (singular + "_id").casefold()
+        ]
+        if len(foreign_keys) > 1:
+            raise SchemaValidationError("schema group label foreign key is ambiguous")
+        if foreign_keys:
+            return data_table, foreign_keys[0], span
+        raise SchemaValidationError("schema group label relationship is missing")
+
     def _schema_resolve_table(
         self,
         text: str,
@@ -668,6 +859,7 @@ class PipelineNL2SQLGenerator:
         table: SchemaTableContext,
         column_hints: Optional[List[str]],
         schema: SchemaContext,
+        suppress_quantity_token: bool = False,
     ) -> list[str]:
         if column_hints:
             resolved: list[str] = []
@@ -689,10 +881,63 @@ class PipelineNL2SQLGenerator:
                 )
             return resolved
 
-        columns = self._extract_columns(text)
+        projection_source = text
+        if suppress_quantity_token:
+            projection_source = re.sub(r"数量", " " * len("数量"), projection_source)
+        projection_text = mask_non_executable(self._schema_projection_text(projection_source))
+        candidates: list[tuple[int, int, str]] = []
+        column_names = list(table.columns)
+        for column in column_names:
+            variants = [column]
+            if not column.casefold().endswith("s"):
+                variants.append(column + "s")
+            for variant in variants:
+                pattern = re.escape(variant)
+                if not re.search(r"[\u4e00-\u9fff]", variant):
+                    pattern = rf"(?<![\w$]){pattern}(?![\w$])"
+                for match in re.finditer(pattern, projection_text, re.IGNORECASE):
+                    candidates.append((match.start(), match.end(), column))
+                qualified = re.escape(table.name) + r"\." + re.escape(variant)
+                for match in re.finditer(qualified, projection_text, re.IGNORECASE):
+                    candidates.append((match.start(), match.end(), column))
+
+        mapped_columns = self._extract_columns(projection_text)
+        if mapped_columns != ["*"]:
+            for mapped_column in mapped_columns:
+                canonical = schema.canonical_column(table, mapped_column)
+                if canonical is None:
+                    raise SchemaValidationError("mapped projection column is outside the schema")
+                aliases = [
+                    alias for alias, value in self.COLUMN_PATTERNS.items()
+                    if value.casefold() == mapped_column.casefold()
+                ] + [canonical]
+                for alias in aliases:
+                    pattern = re.escape(alias)
+                    if not re.search(r"[\u4e00-\u9fff]", alias):
+                        pattern = rf"(?<![\w$]){pattern}(?![\w$])"
+                    for match in re.finditer(pattern, projection_text, re.IGNORECASE):
+                        candidates.append((match.start(), match.end(), canonical))
+
+        selected: list[tuple[int, int, str]] = []
+        for candidate in sorted(candidates, key=lambda item: (item[0], -(item[1] - item[0]))):
+            if any(candidate[0] < existing[1] and existing[0] < candidate[1] for existing in selected):
+                continue
+            selected.append(candidate)
+        if selected:
+            deduplicated: list[str] = []
+            seen_columns: set[str] = set()
+            for _, _, column in selected:
+                key = column.casefold()
+                if key in seen_columns:
+                    continue
+                seen_columns.add(key)
+                deduplicated.append(column)
+            return deduplicated
+
+        columns = self._extract_columns(projection_text)
         if columns == ["*"]:
             for candidate in table.columns:
-                if self._schema_text_match(text, candidate):
+                if self._schema_text_match(projection_text, candidate):
                     columns.append(candidate)
             if len(columns) > 1:
                 columns.remove("*")
@@ -709,6 +954,187 @@ class PipelineNL2SQLGenerator:
             resolved.append(canonical)
         return resolved
 
+    @staticmethod
+    def _schema_projection_text(text: str) -> str:
+        """Mask explicit ordering clauses so their columns are not projected."""
+        match = re.search(
+            r"\b(?:order(?:ed)?|sort(?:ed)?)\s+by\b",
+            text,
+            re.IGNORECASE,
+        )
+        if match is None:
+            return text
+        return text[:match.start()] + " " * (len(text) - match.start())
+
+    def _schema_resolve_ordering(
+        self,
+        text: str,
+        table: SchemaTableContext,
+        schema: SchemaContext,
+    ) -> Optional[Tuple[str, str]]:
+        """Resolve one explicit schema-aware ORDER BY target."""
+        match = re.search(
+            r"\b(?:order(?:ed)?|sort(?:ed)?)\s+by\s+"
+            r"([A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)?)"
+            r"(.*)$",
+            text,
+            re.IGNORECASE,
+        )
+        if match is None:
+            return self._extract_ordering(text)
+        raw_column, tail = match.groups()
+        direction = "ASC"
+        direction_match = re.match(
+            r"\s+(ascending|descending|asc|desc|升序|降序)\b",
+            tail,
+            re.IGNORECASE,
+        )
+        if direction_match:
+            direction = "DESC" if direction_match.group(1).casefold() in {"descending", "desc", "降序"} else "ASC"
+            tail = tail[direction_match.end():]
+        if tail.strip(" \t\r\n,.;，。；"):
+            raise SchemaValidationError("multiple schema-aware ordering columns are unsupported")
+        parts = raw_column.split(".")
+        column_name = parts[-1]
+        if len(parts) > 1:
+            candidates = schema.table_candidates(".".join(parts[:-1]))
+            if len(candidates) != 1 or candidates[0].key != table.key:
+                raise SchemaValidationError("ordering column table is not the selected schema table")
+        canonical = schema.canonical_column(table, column_name)
+        if canonical is None:
+            raise SchemaValidationError("ordering column is outside the schema")
+        return canonical, direction
+
+    def _schema_resolve_count_metric(
+        self,
+        text: str,
+        table: SchemaTableContext,
+        schema: SchemaContext,
+    ) -> tuple[str, str | None] | None:
+        count_intent = bool(re.search(
+            r"统计|数量|多少|几个|总数|个数|条数|件数|行数|人数|记录数|"
+            r"\bnumber\s+of\b|\bcount(?:\s+of)?\b|\bhow\s+many\b",
+            text,
+            re.IGNORECASE,
+        ))
+        if not count_intent:
+            for mapped in self._schema_entity_counter_tables(text):
+                candidates = schema.table_candidates(mapped)
+                if len(candidates) == 1 and candidates[0].key == table.key:
+                    count_intent = True
+                    break
+        measure_table: str | None = None
+        if "库存数量" in text:
+            measure_table = "inventory"
+        elif "购买数量" in text:
+            measure_table = "orders"
+        if measure_table is not None:
+            if table.name.rsplit(".", 1)[-1].casefold() != measure_table:
+                raise SchemaValidationError("quantity measure table is not selected")
+            quantity = schema.canonical_column(table, "quantity")
+            if quantity is None:
+                raise SchemaValidationError("quantity measure is outside the schema")
+            return "sum", quantity
+        if count_intent:
+            return "count", None
+        return None
+
+    def _schema_extract_aggregations(
+        self,
+        text: str,
+        table: SchemaTableContext | None = None,
+        schema: SchemaContext | None = None,
+        count_metric: tuple[str, str | None] | None = None,
+    ) -> list[str]:
+        existing = self._extract_aggregations(text)
+        if count_metric is not None and count_metric[0] == "sum":
+            return [f"SUM({count_metric[1]})"]
+        if count_metric is not None and count_metric[0] == "count" and not any(
+            aggregation.upper().startswith("COUNT(") for aggregation in existing
+        ):
+            existing = [*existing, "COUNT(*) AS count"]
+        if table is None or schema is None or not table.has_column_metadata:
+            return existing
+
+        group_match = re.search(r"\b(?:group(?:ed)?\s+by|per|each|by)\b", text, re.IGNORECASE)
+        metric_text = text if group_match is None else text[:group_match.start()]
+        metric_candidates: list[tuple[int, str]] = []
+        for column in table.columns:
+            pattern = rf"(?<![\w$]){re.escape(column)}(?![\w$])"
+            match = re.search(pattern, metric_text, re.IGNORECASE)
+            if match:
+                metric_candidates.append((match.start(), column))
+        if metric_candidates:
+            metric = min(metric_candidates, key=lambda item: item[0])[1]
+            existing = [
+                re.sub(r"^(AVG|SUM|MAX|MIN)\([^)]*\)$", lambda m: f"{m.group(1)}({metric})", aggregation, flags=re.IGNORECASE)
+                if re.match(r"^(AVG|SUM|MAX|MIN)\(", aggregation, re.IGNORECASE)
+                else aggregation
+                for aggregation in existing
+            ]
+        return existing
+
+    def _schema_resolve_group_by(
+        self,
+        text: str,
+        table: SchemaTableContext,
+        schema: SchemaContext,
+        aggregations: list[str],
+    ) -> list[str]:
+        lowered = text.lower()
+        match = re.search(
+            r"\b(?:group\s+by|grouped\s+by)\s+"
+            r"([A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)?)(.*)$",
+            lowered,
+            re.IGNORECASE,
+        )
+        match_kind = "group"
+        if match is None and aggregations:
+            if not re.search(r"\b(?:ordered|sorted|order|sort)\s+by\b", lowered):
+                match = re.search(
+                    r"\b(?:per|each|by)\s+"
+                    r"([A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)?)(.*)$",
+                    lowered,
+                    re.IGNORECASE,
+                )
+                match_kind = "aggregation-group"
+        chinese_group_intent = bool(re.search(r"每个|各个|每位|分组|汇总|按[^\s,，。；]+(?:分组|汇总|统计)", text))
+        if match is None:
+            if chinese_group_intent:
+                raise SchemaValidationError("schema group column is not explicitly resolvable")
+            return []
+        raw_column, tail = match.groups()
+        if tail.strip(" \t\r\n,.;，。；"):
+            raise SchemaValidationError("multiple schema group columns are unsupported")
+        parts = raw_column.split(".")
+        if len(parts) > 1:
+            candidates = schema.table_candidates(".".join(parts[:-1]))
+            if len(candidates) != 1 or candidates[0].key != table.key:
+                raise SchemaValidationError("group column table is not the selected schema table")
+        canonical = schema.canonical_column(table, parts[-1])
+        if canonical is None:
+            if not table.has_column_metadata and match_kind == "group":
+                return [parts[-1]]
+            raise SchemaValidationError("group column is outside the schema")
+        return [canonical]
+
+    @staticmethod
+    def _schema_has_explicit_ordering(text: str) -> bool:
+        lowered = text.lower()
+        phrases = (
+            "order by", "ordered by", "sort by", "sorted by",
+            "ascending", "descending", "asc", "desc", "sort", "sorted",
+            "top", "highest", "lowest", "max", "min",
+            "升序", "降序", "排序", "最大", "最小", "最多", "最少",
+        )
+        for phrase in phrases:
+            if phrase.isascii():
+                if re.search(r"(?<![\w$])" + re.escape(phrase) + r"(?![\w$])", lowered):
+                    return True
+            elif phrase in text:
+                return True
+        return False
+
     def _schema_resolve_conditions(
         self,
         text: str,
@@ -736,6 +1162,325 @@ class PipelineNL2SQLGenerator:
             resolved.append(rewritten)
         return resolved
 
+    @staticmethod
+    def _schema_mask_span(
+        text: str, span: tuple[int, int]
+    ) -> str:
+        start, end = span
+        return text[:start] + " " * (end - start) + text[end:]
+
+    def _schema_resolve_whose(
+        self,
+        text: str,
+        table: SchemaTableContext,
+        schema: SchemaContext,
+    ) -> tuple[str, tuple[int, int]] | None:
+        """Resolve one schema-aware ``whose`` predicate in linear time."""
+        executable = mask_non_executable(text)
+        match = _SCHEMA_WHOSE_PREFIX.search(executable)
+        if match is None:
+            return None
+        whose_matches = list(_SCHEMA_WHOSE_PREFIX.finditer(executable))
+        if len(whose_matches) != 1:
+            raise SchemaValidationError("multiple whose predicates are unsupported")
+        original_match = _SCHEMA_WHOSE_PREFIX.match(text, match.start())
+        if original_match is None:
+            raise SchemaValidationError("whose predicate is not executable")
+        match = original_match
+
+        raw_column, raw_operator = match.groups()
+        parts = raw_column.split(".")
+        column_name = parts[-1]
+        if len(parts) > 1:
+            candidates = schema.table_candidates(".".join(parts[:-1]))
+            if len(candidates) != 1 or candidates[0].key != table.key:
+                raise SchemaValidationError("whose column table is not the selected table")
+        canonical = schema.canonical_column(table, column_name)
+        if canonical is None:
+            if table.has_column_metadata:
+                raise SchemaValidationError("whose column is outside the schema")
+            canonical = column_name
+
+        position = match.end()
+        if position >= len(text):
+            raise SchemaValidationError("whose predicate value is missing")
+        quote = text[position] if text[position] in "'\"" else None
+        value_end = position
+        if quote is not None:
+            position += 1
+            value_chars: list[str] = []
+            closed = False
+            while position < len(text):
+                character = text[position]
+                if character == "\\" and position + 1 < len(text):
+                    value_chars.extend((character, text[position + 1]))
+                    position += 2
+                    continue
+                if character == quote:
+                    if position + 1 < len(text) and text[position + 1] == quote:
+                        value_chars.append(quote)
+                        position += 2
+                        continue
+                    closed = True
+                    position += 1
+                    break
+                value_chars.append(character)
+                position += 1
+            if not closed:
+                raise SchemaValidationError("whose quoted value is not closed")
+            value = "".join(value_chars)
+            literal = "'" + value.replace("'", "''") + "'"
+            value_end = position
+        else:
+            numeric = re.match(
+                r"-?(?:\d+(?:\.\d*)?|\.\d+)(?![\w$])",
+                text[position:],
+            )
+            if numeric is not None:
+                literal = numeric.group(0)
+                value_end = position + numeric.end()
+            else:
+                null_match = re.match(r"null(?![\w$])", text[position:], re.IGNORECASE)
+                if null_match is not None:
+                    literal = "NULL"
+                    value_end = position + null_match.end()
+                else:
+                    cjk_token = re.match(r"[\u4e00-\u9fff]+", text[position:])
+                    if cjk_token is not None:
+                        value = cjk_token.group(0)
+                        if any(connector in value for connector in _SCHEMA_WHOSE_CJK_CONNECTORS):
+                            raise SchemaValidationError("whose CJK value contains a connector")
+                        literal = "'" + value.replace("'", "''") + "'"
+                        value_end = position + cjk_token.end()
+                    else:
+                        token = re.match(r"[A-Za-z_][A-Za-z0-9_$]*(?![\w$])", text[position:])
+                        if token is None:
+                            raise SchemaValidationError("whose value is not a supported literal")
+                        value = token.group(0)
+                        if value.casefold() in _SCHEMA_WHOSE_REJECTED_VALUES:
+                            raise SchemaValidationError("whose value is a reserved word")
+                        after_token = text[position + token.end():].lstrip()
+                        if after_token.startswith("("):
+                            raise SchemaValidationError("whose function values are unsupported")
+                        literal = "'" + value.replace("'", "''") + "'"
+                        value_end = position + token.end()
+
+        operator = raw_operator.casefold()
+        if literal == "NULL":
+            if operator in {"is", "is not", "isn't"}:
+                predicate = f"{canonical} IS {'NOT ' if operator != 'is' else ''}NULL"
+            else:
+                raise SchemaValidationError("comparison with NULL is unsupported")
+        else:
+            normalized = {
+                "is": "=", "equals": "=", "is not": "!=", "isn't": "!=",
+                "<>": "!=",
+            }.get(operator, raw_operator)
+            predicate = f"{canonical} {normalized} {literal}"
+
+        tail = executable[value_end:]
+        if re.search(r"\bor\b|\bwhose\b|[()]", tail, re.IGNORECASE):
+            raise SchemaValidationError("complex whose predicates are unsupported")
+        stripped_tail = tail.strip()
+        if stripped_tail and not re.match(r"^and\b", stripped_tail, re.IGNORECASE):
+            raise SchemaValidationError("unexpected text after whose predicate")
+        span = (match.start(), value_end)
+        return predicate, span
+
+    def _schema_resolve_joined_on(
+        self,
+        text: str,
+        table_hint: Optional[str],
+        schema: SchemaContext,
+    ) -> tuple[SchemaTableContext, list[dict], tuple[int, int]] | None:
+        """Resolve one schema-aware qualified equality after ``joined on``."""
+        executable = mask_non_executable(text)
+        prefixes = list(_SCHEMA_JOINED_ON_PREFIX.finditer(executable))
+        if not prefixes:
+            return None
+        if re.search(r"\bjoined\s+with\b", executable, re.IGNORECASE):
+            raise SchemaValidationError("mixed joined-on and joined-with clauses are unsupported")
+        if len(prefixes) != 1:
+            raise SchemaValidationError("multiple joined-on clauses are unsupported")
+        if re.search(r"\b(?:per|each)\b|每个|各个|每位", executable, re.IGNORECASE):
+            raise SchemaValidationError("joined-on with group labels is unsupported")
+        prefix = prefixes[0]
+        original_prefix = _SCHEMA_JOINED_ON_PREFIX.match(text, prefix.start())
+        if original_prefix is None:
+            raise SchemaValidationError("joined-on clause is not executable")
+        prefix = original_prefix
+        kind = (prefix.group(1) or "inner").upper()
+        before_mentions = self._schema_table_mentions(text[:prefix.start()], schema)
+        if table_hint:
+            subject_candidates = schema.table_candidates(table_hint)
+            if len(subject_candidates) != 1:
+                raise SchemaValidationError("joined-on subject hint is ambiguous")
+            subject = subject_candidates[0]
+        elif before_mentions:
+            subject = before_mentions[0]
+        else:
+            raise SchemaValidationError("joined-on subject is missing")
+
+        remainder = executable[prefix.end():]
+        left_match = _SCHEMA_JOINED_ON_OPERAND.match(remainder.lstrip())
+        if left_match is None:
+            raise SchemaValidationError("joined-on left endpoint is invalid")
+        left_start = prefix.end() + (len(remainder) - len(remainder.lstrip()))
+        left_raw = left_match.group(0)
+        after_left = remainder.lstrip()[left_match.end():]
+        equals = re.match(r"\s*=\s*", after_left)
+        if equals is None:
+            raise SchemaValidationError("joined-on requires one equality")
+        right_offset = left_start + left_match.end() + equals.end()
+        right_match = _SCHEMA_JOINED_ON_OPERAND.match(executable[right_offset:])
+        if right_match is None:
+            raise SchemaValidationError("joined-on right endpoint is invalid")
+        right_raw = right_match.group(0)
+        value_end = right_offset + right_match.end()
+
+        tail = executable[value_end:]
+        stripped_tail = tail.strip()
+        if stripped_tail and not re.match(r"^(?:where|whose)\b", stripped_tail, re.IGNORECASE):
+            raise SchemaValidationError("unexpected text after joined-on equality")
+
+        def resolve_endpoint(raw: str) -> tuple[SchemaTableContext, str]:
+            parts = raw.split(".")
+            table_name = ".".join(parts[:-1])
+            candidates = schema.table_candidates(table_name)
+            if len(candidates) != 1:
+                raise SchemaValidationError("joined-on table is not unique")
+            table = candidates[0]
+            column = schema.canonical_column(table, parts[-1])
+            if column is None:
+                raise SchemaValidationError("joined-on column is outside the schema")
+            return table, column
+
+        left_table, left_column = resolve_endpoint(left_raw)
+        right_table, right_column = resolve_endpoint(right_raw)
+        if left_table.key == right_table.key:
+            raise SchemaValidationError("self joined-on is unsupported")
+        endpoint_tables = {left_table.key, right_table.key}
+        if subject.key not in endpoint_tables:
+            raise SchemaValidationError("joined-on subject is not an endpoint")
+        target_keys = endpoint_tables - {subject.key}
+        if len(target_keys) != 1:
+            raise SchemaValidationError("joined-on target is ambiguous")
+        target = right_table if right_table.key in target_keys else left_table
+        mentions = self._schema_table_mentions(text, schema)
+        if {table.key for table in mentions} - endpoint_tables:
+            raise SchemaValidationError("joined-on contains an extra table")
+
+        raw_relationships = [
+            relationship for relationship in schema.relationships
+            if {
+                relationship.from_table.casefold(), relationship.to_table.casefold()
+            } == endpoint_tables
+        ]
+        if raw_relationships:
+            def matches_relationship(relationship) -> bool:
+                declared = {
+                    (relationship.from_table.casefold(), relationship.from_column.casefold()),
+                    (relationship.to_table.casefold(), relationship.to_column.casefold()),
+                }
+                supplied = {
+                    (left_table.key, left_column.casefold()),
+                    (right_table.key, right_column.casefold()),
+                }
+                return declared == supplied
+
+            if sum(matches_relationship(item) for item in raw_relationships) != 1:
+                raise SchemaValidationError("joined-on does not match a unique relationship")
+
+        condition = (
+            f"{left_table.name}.{left_column} = "
+            f"{right_table.name}.{right_column}"
+        )
+        span = (prefix.start(), value_end)
+        return subject, [{
+            "type": kind,
+            "table": target.name,
+            "subject": subject.name,
+            "condition": condition,
+            "relational": False,
+            "join_spec": JoinSpec(kind=kind, matched_text="joined on"),
+        }], span
+
+    def _schema_resolve_joined_with(
+        self,
+        text: str,
+        table_hint: Optional[str],
+        schema: SchemaContext,
+    ) -> tuple[SchemaTableContext, list[dict], tuple[int, int]] | None:
+        """Resolve one relationship-backed physical ``joined with`` clause."""
+        executable = mask_non_executable(text)
+        matches = list(_SCHEMA_JOINED_WITH_PREFIX.finditer(executable))
+        if not matches:
+            return None
+        if len(matches) != 1 or re.search(r"\bjoined\s+on\b", executable, re.IGNORECASE):
+            raise SchemaValidationError("multiple or mixed joined clauses are unsupported")
+        match = matches[0]
+        original_match = _SCHEMA_JOINED_WITH_PREFIX.match(text, match.start())
+        if original_match is None:
+            raise SchemaValidationError("joined-with clause is not executable")
+        match = original_match
+        if re.search(
+            r"\b(?:per|each|group\s+by|grouped\s+by)\b|每个|各个|每位",
+            executable,
+            re.IGNORECASE,
+        ):
+            raise SchemaValidationError("joined-with grouping is unsupported")
+
+        kind = (match.group(1) or "inner").upper()
+        target_name = match.group(2)
+        target_candidates = schema.table_candidates(target_name)
+        if len(target_candidates) != 1:
+            raise SchemaValidationError("joined-with target is not unique")
+        target = target_candidates[0]
+        before_mentions = self._schema_table_mentions(text[:match.start()], schema)
+        if table_hint:
+            subject_candidates = schema.table_candidates(table_hint)
+            if len(subject_candidates) != 1:
+                raise SchemaValidationError("joined-with subject hint is ambiguous")
+            subject = subject_candidates[0]
+        elif before_mentions:
+            subject = before_mentions[0]
+        else:
+            raise SchemaValidationError("joined-with subject is missing")
+        if self._schema_text_match(text[:match.start()], target_name):
+            raise SchemaValidationError("joined-with target is repeated before the clause")
+        before_keys = {table.key for table in before_mentions}
+        if before_keys - {subject.key, target.key}:
+            raise SchemaValidationError("joined-with contains an extra table")
+        if subject.key == target.key:
+            raise SchemaValidationError("self joined-with is unsupported")
+
+        tail = executable[match.end():]
+        stripped_tail = tail.strip()
+        if stripped_tail and not re.match(r"^(?:where|whose)\b", stripped_tail, re.IGNORECASE):
+            raise SchemaValidationError("unexpected text after joined-with target")
+        relationships = [
+            relationship for relationship in schema.relationships
+            if {
+                relationship.from_table.casefold(), relationship.to_table.casefold()
+            } == {subject.key, target.key}
+        ]
+        if len(relationships) != 1:
+            raise SchemaValidationError("joined-with relationship is not unique")
+        relationship = relationships[0]
+        condition = (
+            f"{relationship.from_table}.{relationship.from_column} = "
+            f"{relationship.to_table}.{relationship.to_column}"
+        )
+        span = (match.start(), match.end())
+        return subject, [{
+            "type": kind,
+            "table": target.name,
+            "subject": subject.name,
+            "condition": condition,
+            "relational": False,
+            "join_spec": JoinSpec(kind=kind, matched_text="joined with"),
+        }], span
+
     def _schema_resolve_joins(
         self,
         text: str,
@@ -867,35 +1612,105 @@ class PipelineNL2SQLGenerator:
     ) -> NL2SQLResult:
         """Generate through the enhanced path with strict schema resolution."""
         try:
-            unknown_tables = self._schema_unknown_table_patterns(text, schema)
+            executable_text = mask_non_executable(text)
+            joined_on_resolution = self._schema_resolve_joined_on(
+                text, table_hint, schema
+            )
+            joined_with_resolution = None
+            if joined_on_resolution is None:
+                joined_with_resolution = self._schema_resolve_joined_with(
+                    text, table_hint, schema
+                )
+            label_resolution = None
+            if joined_on_resolution is None and joined_with_resolution is None:
+                label_resolution = self._schema_resolve_english_group_label(executable_text, schema)
+                if label_resolution is None:
+                    label_resolution = self._schema_resolve_chinese_group_label(executable_text, schema)
+            ignored_label_spans = (label_resolution[2],) if label_resolution else ()
+            unknown_tables = self._schema_unknown_table_patterns(
+                text, schema, ignored_spans=ignored_label_spans
+            )
             if unknown_tables:
                 return self._schema_failure(
                     text,
                     dialect,
                     "The request references tables outside the provided schema.",
                 )
-            table_context, joins = self._schema_resolve_joins(text, table_hint, schema)
+            joined_on_span = None
+            joined_with_span = None
+            if joined_on_resolution is not None:
+                table_context, joins, joined_on_span = joined_on_resolution
+                metric_text = self._schema_mask_span(text_lower, joined_on_span)
+            elif joined_with_resolution is not None:
+                table_context, joins, joined_with_span = joined_with_resolution
+                metric_text = self._schema_mask_span(text_lower, joined_with_span)
+            elif label_resolution is not None:
+                table_context = label_resolution[0]
+                label_group_column = label_resolution[1]
+                joins = []
+                start, end = label_resolution[2]
+                metric_text = text_lower[:start] + " " * (end - start) + text_lower[end:]
+            else:
+                table_context, joins = self._schema_resolve_joins(text, table_hint, schema)
+                metric_text = text_lower
+            whose_resolution = self._schema_resolve_whose(text, table_context, schema)
+            whose_condition = None
+            condition_text = text_lower
+            condition_original = text
+            if joined_on_span is not None:
+                condition_text = self._schema_mask_span(condition_text, joined_on_span)
+                condition_original = self._schema_mask_span(condition_original, joined_on_span)
+            elif joined_with_span is not None:
+                condition_text = self._schema_mask_span(condition_text, joined_with_span)
+                condition_original = self._schema_mask_span(condition_original, joined_with_span)
+            if whose_resolution is not None:
+                whose_condition, whose_span = whose_resolution
+                metric_text = self._schema_mask_span(metric_text, whose_span)
+                condition_text = self._schema_mask_span(condition_text, whose_span)
+                condition_original = self._schema_mask_span(condition_original, whose_span)
+            count_metric = self._schema_resolve_count_metric(
+                text_lower, table_context, schema
+            )
             columns = self._schema_resolve_columns(
-                text_lower, table_context, column_hints, schema
+                metric_text,
+                table_context,
+                column_hints,
+                schema,
+                suppress_quantity_token=count_metric is not None,
             )
             conditions = self._schema_resolve_conditions(
-                text_lower,
-                self._extract_conditions_enhanced(text_lower, text),
+                condition_text,
+                self._extract_conditions_enhanced(condition_text, condition_original),
                 table_context,
                 schema,
             )
+            if whose_condition is not None:
+                conditions = [*conditions, whose_condition]
             parsed = self._parse_text(text_lower, text)
             parsed.update(analysis)
             operation = self._detect_operation(text_lower)
-            aggregations = self._extract_aggregations(text_lower)
-            group_by = self._extract_group_by(text_lower)
-            ordering = self._extract_ordering(text_lower)
+            aggregations = self._schema_extract_aggregations(
+                metric_text, table_context, schema, count_metric
+            )
+            group_by = (
+                [label_group_column]
+                if label_resolution is not None
+                else self._schema_resolve_group_by(
+                    text_lower, table_context, schema, aggregations
+                )
+            )
+            ordering = (
+                self._schema_resolve_ordering(text_lower, table_context, schema)
+                if self._schema_has_explicit_ordering(text_lower)
+                else None
+            )
             limit = self._extract_limit(text_lower)
             distinct = self._check_distinct(text_lower)
+            render_columns = ["*"] if aggregations and not group_by else columns
             sql, explanation, confidence, evidence = self._build_sql_enhanced(
                 operation,
                 table_context.name,
-                columns,
+                render_columns,
                 conditions,
                 aggregations,
                 group_by,

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.4.1
+Version: 1.6.0
 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.1
+Current release: 1.6.0
 
 [![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)