sql-dialect-master 1.5.0__tar.gz → 1.7.0__tar.gz

{sql_dialect_master-1.5.0 → sql_dialect_master-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.5.0
+Version: 1.7.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.5.0
+Current release: 1.7.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.5.0 → sql_dialect_master-1.7.0}/README.md

@@ -2,7 +2,7 @@
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.5.0
+Current release: 1.7.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.5.0 → sql_dialect_master-1.7.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.5.0"
-API_VERSION = "1.5.0"
+PROJECT_VERSION = "1.7.0"
+API_VERSION = "1.7.0"
 # Frontend v2 architecture — independent of the product release version.
 FRONTEND_ARCHITECTURE_VERSION = 2
 

{sql_dialect_master-1.5.0 → sql_dialect_master-1.7.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_DIAGNOSTIC_VALUES = {
+    "active", "inactive", "enabled", "disabled", "valid", "invalid",
+    "completed", "pending", "paid", "unpaid", "done", "true", "false",
+}
+_SCHEMA_DIAGNOSTIC_KEYWORDS = {
+    "and", "or", "not", "is", "where", "with", "by", "group", "grouped",
+    "order", "ordered", "sort", "sorted", "asc", "desc", "ascending",
+    "descending", "users", "user", "show", "list", "find", "display",
+}
+_SCHEMA_DIAGNOSTIC_COLUMN_ALLOWLIST = {
+    "password", "nickname", "token", "hash", "bio", "avatar",
+}
 _SCHEMA_GROUP_LABEL_COLUMNS = {
     "部门": ("department", "dept"),
     "状态": ("status",),
@@ -1135,6 +1174,453 @@ 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_diagnostic_suggestions(
+        self,
+        text: str,
+        table: SchemaTableContext,
+        schema: SchemaContext,
+        columns: list[str],
+        existing: list,
+    ) -> list:
+        """Return high-confidence unmapped-column suggestions for schema success."""
+        if not table.has_column_metadata:
+            return list(existing)
+        masked = mask_non_executable(text)
+        schema_tables = {candidate.key for candidate in schema.tables}
+        table_aliases = {
+            pattern.casefold() for pattern in self.TABLE_PATTERNS
+        } | {
+            mapped.casefold() for mapped in self.TABLE_PATTERNS.values()
+        }
+        schema_columns = {column.casefold() for column in table.columns}
+        mapped_aliases = {
+            alias.casefold(): canonical
+            for alias, canonical in self.COLUMN_PATTERNS.items()
+        }
+        warnings: list[tuple[int, str]] = []
+        seen: set[str] = set()
+
+        def add_warning(position: int, token: str, *, projection: bool = False) -> None:
+            key = token.casefold()
+            if key in seen or key in schema_columns:
+                return
+            canonical = mapped_aliases.get(key)
+            if canonical is not None and canonical.casefold() in schema_columns:
+                return
+            message = (
+                f'Possible projection term "{token}" was not resolved against the selected schema table.'
+                if projection else
+                f'Possible unmapped column reference: "{token}". '
+                "Provide it in column_hints if it is a schema column."
+            )
+            seen.add(key)
+            warnings.append((position, message))
+
+        # Strong identifier contexts: `with token` and `by snake_case`.
+        for match in re.finditer(
+            r"\b(?:with|by)\s+([A-Za-z_][A-Za-z0-9_$]*)",
+            masked,
+            re.IGNORECASE,
+        ):
+            token = match.group(1)
+            lowered = token.casefold()
+            if lowered in _SCHEMA_DIAGNOSTIC_KEYWORDS | _SCHEMA_DIAGNOSTIC_VALUES:
+                continue
+            if schema.table_candidates(token) or lowered in schema_tables:
+                continue
+            if lowered in table_aliases:
+                continue
+            if schema.canonical_column(table, token) is not None:
+                continue
+            if lowered in mapped_aliases and mapped_aliases[lowered].casefold() in schema_columns:
+                continue
+            if match.group(0).casefold().startswith("by ") and "_" not in token:
+                continue
+            add_warning(match.start(1), token)
+
+        # Explicit projection conjunctions: only mapped aliases after a
+        # show/list/display marker, before any predicate/clause boundary.
+        projection_marker = re.search(r"\b(?:show|list|display|select)\b", masked, re.IGNORECASE)
+        if projection_marker:
+            boundary = re.search(
+                r"\b(?:where|whose|order(?:ed)?\s+by|sort(?:ed)?\s+by|group(?:ed)?\s+by)\b",
+                masked[projection_marker.end():],
+                re.IGNORECASE,
+            )
+            projection_end = (
+                projection_marker.end() + boundary.start()
+                if boundary is not None else len(masked)
+            )
+            for alias, canonical in sorted(self.COLUMN_PATTERNS.items(), key=lambda item: -len(item[0])):
+                if canonical.casefold() in schema_columns:
+                    continue
+                aliases = [alias]
+                if alias.isascii() and not alias.casefold().endswith("s"):
+                    aliases.append(alias + "s")
+                for candidate_alias in aliases:
+                    expression = re.escape(candidate_alias)
+                    if not re.search(r"[\u4e00-\u9fff]", candidate_alias):
+                        expression = rf"(?<![\w$]){expression}(?![\w$])"
+                    for match in re.finditer(expression, masked[projection_marker.end():projection_end], re.IGNORECASE):
+                        add_warning(
+                            projection_marker.end() + match.start(),
+                            alias,
+                            projection=True,
+                        )
+            projection_slice = masked[projection_marker.end():projection_end]
+            for token_match in re.finditer(
+                r"[A-Za-z_][A-Za-z0-9_$]*", projection_slice
+            ):
+                token = token_match.group(0)
+                lowered = token.casefold()
+                if (
+                    lowered in _SCHEMA_DIAGNOSTIC_KEYWORDS
+                    or lowered in _SCHEMA_DIAGNOSTIC_VALUES
+                    or lowered in table_aliases
+                    or lowered in schema_tables
+                    or lowered in schema_columns
+                ):
+                    continue
+                canonical = mapped_aliases.get(lowered)
+                if canonical is not None and canonical.casefold() in schema_columns:
+                    continue
+                if canonical is None and (
+                    "_" not in token and lowered not in _SCHEMA_DIAGNOSTIC_COLUMN_ALLOWLIST
+                ):
+                    continue
+                add_warning(
+                    projection_marker.end() + token_match.start(),
+                    canonical or token,
+                    projection=True,
+                )
+
+        warnings.sort(key=lambda item: item[0])
+        diagnostic_messages = [message for _, message in warnings[:3]]
+        combined: list = []
+        for suggestion in [*existing, *diagnostic_messages]:
+            if suggestion not in combined:
+                combined.append(suggestion)
+        return combined[:3]
+
     def _schema_resolve_joins(
         self,
         text: str,
@@ -1267,9 +1753,19 @@ class PipelineNL2SQLGenerator:
         """Generate through the enhanced path with strict schema resolution."""
         try:
             executable_text = mask_non_executable(text)
-            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)
+            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
@@ -1280,7 +1776,15 @@ class PipelineNL2SQLGenerator:
                     dialect,
                     "The request references tables outside the provided schema.",
                 )
-            if label_resolution is not None:
+            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 = []
@@ -1289,6 +1793,21 @@ class PipelineNL2SQLGenerator:
             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
             )
@@ -1300,11 +1819,13 @@ class PipelineNL2SQLGenerator:
                 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)
@@ -1353,7 +1874,16 @@ class PipelineNL2SQLGenerator:
                 ),
                 parsed_elements=parsed,
             ))
-            return self._schema_finalize(result, schema)
+            finalized = self._schema_finalize(result, schema)
+            if finalized.success and finalized.schema_used:
+                finalized.suggestions = self._schema_diagnostic_suggestions(
+                    text,
+                    table_context,
+                    schema,
+                    columns,
+                    list(finalized.suggestions),
+                )
+            return finalized
         except (SchemaValidationError, ValueError):
             return self._schema_failure(
                 text,

{sql_dialect_master-1.5.0 → sql_dialect_master-1.7.0}/pyproject.toml

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

{sql_dialect_master-1.5.0 → sql_dialect_master-1.7.0}/sql_dialect_master.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.5.0
+Version: 1.7.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.5.0
+Current release: 1.7.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)