@roll-agent/octopus-agent 0.0.10 → 0.1.0

package/src/octopus_skill/sql_generator.py

@@ -5,6 +5,8 @@ import re
 from dataclasses import dataclass
 from typing import Any
 
+from .schema_context_retriever import _schema_enums as merged_schema_enums
+
 
 class SqlGenerationError(RuntimeError):
     pass
@@ -18,6 +20,7 @@ class GeneratedSql:
     used_columns: list[str] | None = None
     used_joins: list[str] | None = None
     metric_refs: list[str] | None = None
+    clarification: dict[str, Any] | None = None
 
 
 @dataclass(frozen=True)
@@ -26,12 +29,14 @@ class TimeRange:
     alias: str
     start: str
     end: str
+    table_name: str = ""
 
 
 @dataclass(frozen=True)
 class FieldRef:
     name: str
     alias: str
+    table_name: str = ""
 
 
 @dataclass(frozen=True)
@@ -40,109 +45,29 @@ class SchemaValidationIssue:
     message: str
 
 
-@dataclass
-class RuleBasedSqlGenerator:
-    default_limit: int
-    max_limit: int
-
-    def generate(
-        self,
-        *,
-        question: str,
-        schema: dict[str, Any],
-    ) -> GeneratedSql:
-        table_names = _table_names(schema)
-        lowered = question.lower()
-
-        if _is_monthly_recruiting_conversion_query(question):
-            return _generate_monthly_recruiting_conversion_sql(question, schema, self.default_limit)
-        if is_recruiting_match_effect_query(question):
-            return _generate_recruiting_match_effect_sql(question, schema, self.default_limit)
-        if _is_recruiting_supply_multi_metric_query(question):
-            return _generate_recruiting_supply_metric_sql(question, schema, self.default_limit)
-        if _is_work_order_detail_query(question):
-            return _generate_work_order_detail_sql(question, schema, self.default_limit)
-        if _is_multi_metric_query(question):
-            raise SqlGenerationError("Multi-metric query requires schema-driven metric generation")
-
-        if ("品牌" in question or "brand" in lowered) and "brand" in table_names and _is_entity_lookup_query(question, "品牌"):
-            brand_filter = _extract_brand_filter(question)
-            brand_where = "b.is_delete = 0"
-            if brand_filter is not None:
-                _operator, brand_name = brand_filter
-                brand_where = f"b.is_delete = 0 AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
-            sql = (
-                "SELECT b.id AS 品牌ID, b.name AS 品牌名称 "
-                "FROM brand b "
-                f"WHERE {brand_where} "
-                f"LIMIT {self.default_limit}"
-            )
-            return GeneratedSql(sql, ["brand"], [])
-
-        if ("项目" in question or "project" in lowered) and "sponge_project" in table_names and _is_entity_lookup_query(question, "项目"):
-            project_name = _extract_project_name(question)
-            project_where = "p.is_delete = 0"
-            if project_name is not None:
-                project_where = f"p.is_delete = 0 AND p.name LIKE '%{_escape_sql_string(project_name)}%'"
-            sql = (
-                "SELECT p.id AS 项目ID, p.name AS 项目名称 "
-                "FROM sponge_project p "
-                f"WHERE {project_where} "
-                f"LIMIT {self.default_limit}"
-            )
-            return GeneratedSql(sql, ["sponge_project"], [])
+@dataclass(frozen=True)
+class LowQualitySqlIssue:
+    code: str
+    message: str
 
-        if _is_recruiting_job_question(question) and _requires_recruiting_detail_joins(question):
-            return _generate_recruiting_detail_sql(question, schema, self.default_limit)
 
-        if _is_recruiting_remaining_signup_query(question):
-            raise SqlGenerationError("Remaining signup metrics require schema-driven metric generation")
+_SELECT_AS_ALIAS_PATTERN = (
+    r"\s+as\s+(`[^`]+`|\"[^\"]+\"|'[^']+'|\w+)\s*$"
+)
 
-        location = _extract_location_for_recruiting_job_question(question)
-        if location and _has_recruiting_location_tables(table_names):
-            escaped_location = _escape_sql_string(location)
-            from_and_where = _append_job_time_range_condition(
-                _append_job_name_condition(_recruiting_location_from_and_where(escaped_location), question),
-                question,
-                schema,
-            )
-            if _question_requests_count(question):
-                sql = f"SELECT COUNT(DISTINCT jbi.id) AS 在招岗位数量 {from_and_where} LIMIT {self.default_limit}"
-            else:
-                select_items = _job_basic_select_items(question, schema)
-                order_by = _job_order_by(question, schema)
-                sql = (
-                    f"SELECT DISTINCT {select_items} "
-                    f"{from_and_where} "
-                    f"{order_by} "
-                    f"LIMIT {self.default_limit}"
-                )
-            return GeneratedSql(
-                sql,
-                ["job_basic_info", "job_address", "job_store", "store", "province", "city", "region"],
-                [],
-            )
+_FORBIDDEN_DML_KEYWORDS = re.compile(
+    r"\b(insert|update|delete|drop|alter|create|truncate)\b",
+    flags=re.IGNORECASE,
+)
 
-        if _is_recruiting_job_question(question) and _has_recruiting_tables(table_names):
-            from_and_where = _append_job_time_range_condition(
-                _append_job_name_condition(_recruiting_from_and_where(), question),
-                question,
-                schema,
-            )
-            if _question_requests_count(question):
-                sql = f"SELECT COUNT(DISTINCT jbi.id) AS 在招岗位数量 {from_and_where} LIMIT {self.default_limit}"
-            else:
-                select_items = _job_basic_select_items(question, schema)
-                order_by = _job_order_by(question, schema)
-                sql = (
-                    f"SELECT DISTINCT {select_items} "
-                    f"{from_and_where} "
-                    f"{order_by} "
-                    f"LIMIT {self.default_limit}"
-                )
-            return GeneratedSql(sql, ["job_basic_info"], [])
 
-        raise SqlGenerationError("No safe SQL template matched the question")
+def _sql_without_string_literals(sql: str) -> str:
+    return re.sub(r"'([^']|'')*'", "''", sql)
+
+
+def contains_forbidden_dml_keyword(sql: str) -> bool:
+    stripped = _sql_without_string_literals(sql.strip())
+    return _FORBIDDEN_DML_KEYWORDS.search(stripped) is not None
 
 
 def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
@@ -151,7 +76,7 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError("SQL must be SELECT only")
     if ";" in normalized.rstrip(";"):
         raise SqlGenerationError("SQL must be a single statement")
-    if re.search(r"\b(insert|update|delete|drop|alter|create|truncate)\b", normalized):
+    if contains_forbidden_dml_keyword(sql):
         raise SqlGenerationError("SQL contains a forbidden keyword")
     if re.search(r"\b(password|token|secret|credential|private_key)\b", normalized):
         raise SqlGenerationError("SQL contains a sensitive field")
@@ -160,8 +85,10 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
     if ":scope." in normalized:
         raise SqlGenerationError("SQL must not contain scope placeholders")
     _enforce_text_filters_use_like(sql)
+    _enforce_join_on_uses_equality_keys(sql)
     _enforce_chinese_select_aliases(sql)
     _enforce_no_null_placeholder_select_items(sql)
+    _enforce_no_tautological_join_conditions(sql)
     limit = re.search(r"\blimit\s+(\d+)\b", normalized)
     if limit is None:
         raise SqlGenerationError("SQL must contain LIMIT")
@@ -169,6 +96,226 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError(f"SQL LIMIT must not exceed {max_limit}")
 
 
+def build_schema_validation_error(
+    sql: str,
+    issues: list[SchemaValidationIssue],
+    schema: dict[str, Any],
+    *,
+    attempt: int | None = None,
+    max_attempts: int | None = None,
+) -> dict[str, Any]:
+    """Build a repair payload listing every schema violation and column hints."""
+    schema_issues = [{"code": issue.code, "message": issue.message} for issue in issues]
+    codes = {issue.code for issue in issues}
+    if len(codes) == 1:
+        code = next(iter(codes))
+    else:
+        code = "SCHEMA_VALIDATION"
+    if len(issues) == 1:
+        message = issues[0].message
+    elif issues:
+        message = f"共 {len(issues)} 项 schema 校验失败：{issues[0].message}"
+    else:
+        message = "schema 校验失败"
+    payload: dict[str, Any] = {
+        "code": code,
+        "message": message,
+        "originalSql": sql,
+        "schemaIssues": schema_issues,
+    }
+    unknown_refs = _unknown_column_refs_from_issues(issues)
+    if unknown_refs:
+        payload["suggestedColumns"] = suggest_columns_for_unknown(unknown_refs, schema)
+    if any(issue.code == "MISSING_TABLE_REFERENCE" for issue in issues):
+        payload["tableReferenceRepairHint"] = (
+            "SQL 引用了未在 FROM/JOIN 中声明的表名或别名。"
+            "如果该字段确实需要参与查询，必须按 schema relations / joins 补 JOIN；"
+            "如果不需要该表，则删除对应 SELECT/WHERE/ON/GROUP/ORDER 条件。"
+        )
+    if any(issue.code == "INVALID_JOIN" for issue in issues):
+        payload["joinRepairHint"] = (
+            "禁止用 ON 1=0 / ON 1=1 / ON false / ON true 规避 JOIN 校验；"
+            "必须按 schemaContext.exampleGuidance、exampleJoinPatterns 与 structureHints 重建真实 JOIN。"
+        )
+        payload["suggestedJoinPatterns"] = suggest_join_patterns_for_schema(schema)
+    if attempt is not None:
+        payload["attempt"] = attempt
+    if max_attempts is not None:
+        payload["maxAttempts"] = max_attempts
+    return payload
+
+
+def build_execute_unknown_column_error(
+    sql: str,
+    column_ref: str,
+    schema: dict[str, Any],
+    *,
+    attempt: int | None = None,
+    max_attempts: int | None = None,
+) -> dict[str, Any]:
+    """Build a repair payload when execute_sql reports a missing column."""
+    table_name, column_name = _split_sql_column_ref(column_ref)
+    if table_name and column_name:
+        message = f"SQL 使用了数据库中不存在的列：{table_name}.{column_name}"
+        issue = SchemaValidationIssue(code="UNKNOWN_COLUMN", message=message)
+    else:
+        message = f"SQL 使用了数据库中不存在的列：{column_ref}"
+        issue = SchemaValidationIssue(code="UNKNOWN_COLUMN", message=message)
+    return build_schema_validation_error(
+        sql,
+        [issue],
+        schema,
+        attempt=attempt,
+        max_attempts=max_attempts,
+    )
+
+
+def _split_sql_column_ref(column_ref: str) -> tuple[str, str]:
+    cleaned = column_ref.strip().strip("`")
+    if "." not in cleaned:
+        return "", cleaned
+    table_name, column_name = cleaned.rsplit(".", 1)
+    return table_name, column_name
+
+
+def _unknown_column_refs_from_issues(issues: list[SchemaValidationIssue]) -> list[tuple[str, str]]:
+    refs: list[tuple[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+    for issue in issues:
+        if issue.code != "UNKNOWN_COLUMN":
+            continue
+        match = re.search(
+            r"不存在的列：([A-Za-z_][\w]*)\.([A-Za-z_][\w]*)",
+            issue.message,
+        )
+        if not match:
+            continue
+        key = (match.group(1).lower(), match.group(2).lower())
+        if key in seen:
+            continue
+        seen.add(key)
+        refs.append(key)
+    return refs
+
+
+def suggest_columns_for_unknown(
+    missing: list[tuple[str, str]],
+    schema: dict[str, Any],
+) -> list[dict[str, str]]:
+    """Find same column name on other tables when SQL references a non-existent column."""
+    column_map = _schema_table_column_map(schema)
+    suggestions: list[dict[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+    for wrong_table, column in missing:
+        for table, columns in sorted(column_map.items()):
+            if table == wrong_table or column not in columns:
+                continue
+            key = (table, column)
+            if key in seen:
+                continue
+            seen.add(key)
+            suggestions.append(
+                {
+                    "table": table,
+                    "column": column,
+                    "message": f"列 {column} 存在于 {table}，不存在于 {wrong_table}",
+                }
+            )
+    return suggestions
+
+
+def build_sql_rule_validation_error(
+    sql: str,
+    exc: SqlGenerationError,
+    *,
+    max_limit: int,
+    attempt: int | None = None,
+    max_attempts: int | None = None,
+) -> dict[str, Any]:
+    """Build a repair payload with the failing SQL and concrete violating SELECT items."""
+    message = str(exc)
+    payload: dict[str, Any] = {
+        "code": "SQL_RULE_VIOLATION",
+        "message": message,
+        "originalSql": sql,
+        "violatingColumns": list_sql_rule_violating_items(sql, message, max_limit=max_limit),
+    }
+    if attempt is not None:
+        payload["attempt"] = attempt
+    if max_attempts is not None:
+        payload["maxAttempts"] = max_attempts
+    return payload
+
+
+def list_sql_rule_violating_items(sql: str, message: str, *, max_limit: int) -> list[str]:
+    lowered = message.lower()
+    if "chinese alias" in lowered:
+        return _list_missing_chinese_alias_select_items(sql)
+    if "null placeholders" in lowered:
+        return _list_null_placeholder_select_items(sql)
+    if "sensitive field" in lowered:
+        return _list_sensitive_select_items(sql)
+    if "must be select only" in lowered:
+        return ["(entire statement is not a single SELECT)"]
+    if "must contain limit" in lowered:
+        return ["(missing LIMIT clause)"]
+    if "must not exceed" in lowered and "limit" in lowered:
+        return ["(LIMIT exceeds allowed maximum)"]
+    if "scope placeholders" in lowered:
+        return re.findall(r":scope\.\w+", sql, flags=re.IGNORECASE)
+    if "like" in lowered:
+        return _list_text_filter_violations(sql)
+    return []
+
+
+def _list_missing_chinese_alias_select_items(sql: str) -> list[str]:
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return ["(missing top-level FROM clause)"]
+    violations: list[str] = []
+    for item in _split_top_level_select_items(select_list):
+        cleaned = item.strip()
+        if not cleaned:
+            continue
+        alias_match = re.search(
+            _SELECT_AS_ALIAS_PATTERN,
+            cleaned,
+            flags=re.IGNORECASE,
+        )
+        if alias_match is None:
+            violations.append(cleaned)
+            continue
+        alias = alias_match.group(1).strip("`\"'")
+        if re.search(r"[\u4e00-\u9fff]", alias) is None:
+            violations.append(cleaned)
+    return violations
+
+
+def _list_null_placeholder_select_items(sql: str) -> list[str]:
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return []
+    return [
+        item.strip()
+        for item in _split_top_level_select_items(select_list)
+        if item.strip() and _is_null_placeholder_expression(_select_expression_without_alias(item))
+    ]
+
+
+def _list_sensitive_select_items(sql: str) -> list[str]:
+    select_clause = _top_level_select_clause(sql)
+    if select_clause is None:
+        return []
+    return [item.strip() for item in _split_select_items(select_clause) if _select_item_contains_sensitive_field(item)]
+
+
+def _list_text_filter_violations(sql: str) -> list[str]:
+    return re.findall(
+        r"(?i)(?:\b[\w.]+\b)\s*=\s*'[^']*(?:名称|状态|品牌|城市|项目|门店|供应商|工单)[^']*'",
+        sql,
+    )
+
+
 SENSITIVE_FIELD_NAMES = {
     "phone",
     "mobile",
@@ -282,195 +429,1758 @@ def _select_item_contains_sensitive_field(item: str) -> bool:
     return False
 
 
-def _enforce_text_filters_use_like(sql: str) -> None:
-    for match in re.finditer(
-        r"\b(?:where|and|or|having)\s*\(?\s*(?:[a-zA-Z_][a-zA-Z0-9_]*\.)?"
-        r"(?P<column>[a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*'(?P<value>[^']*)'",
-        sql,
-        flags=re.IGNORECASE,
-    ):
-        column = match.group("column").lower()
+_TEXT_EQUALITY_FILTER_RE = re.compile(
+    r"(?P<prefix>\b(?:WHERE|AND|OR|HAVING)\s+\(?\s*)"
+    r"(?P<column>(?:[a-zA-Z_][A-Za-z0-9_]*\.)?[a-zA-Z_][A-Za-z0-9_]*)"
+    r"\s*=\s*'(?P<value>[^']*)'",
+    flags=re.IGNORECASE,
+)
+
+
+def normalize_text_filters_to_like(sql: str) -> str:
+    """Rewrite name/status text equality filters to LIKE before rule enforcement."""
+
+    def replace(match: re.Match[str]) -> str:
+        column = match.group("column")
+        column_name = column.rsplit(".", 1)[-1].lower()
         value = match.group("value").strip()
-        if _is_name_filter_column(column) or (_is_status_text_filter_column(column) and not _is_numeric_literal(value)):
-            raise SqlGenerationError("SQL text filters must use LIKE")
+        if not _should_normalize_text_filter_to_like(column_name, value):
+            return match.group(0)
+        like_value = value if value.startswith("%") and value.endswith("%") else f"%{value.strip('%')}%"
+        return f"{match.group('prefix')}{column} LIKE '{like_value}'"
 
+    return _TEXT_EQUALITY_FILTER_RE.sub(replace, sql)
 
-def _is_name_filter_column(column: str) -> bool:
-    return column == "name" or column == "job_name" or column.endswith("_name")
+
+def normalize_chinese_select_aliases(sql: str, schema: dict[str, Any] | None) -> str:
+    """Add or replace SELECT aliases with Chinese labels from schema column comments."""
+    if not schema or not sql.strip():
+        return sql
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return sql
+
+    table_aliases = _sql_table_aliases(sql)
+    used_labels: set[str] = set()
+    new_items: list[str] = []
+    changed = False
+    for item in _split_top_level_select_items(select_list):
+        cleaned = item.strip()
+        if not cleaned:
+            new_items.append(cleaned)
+            continue
+        if _select_item_has_chinese_alias(cleaned):
+            alias = _extract_select_alias(cleaned)
+            if alias:
+                used_labels.add(alias)
+            new_items.append(cleaned)
+            continue
+        expr = _select_expression_without_alias(cleaned)
+        label = _infer_chinese_select_alias(expr, table_aliases=table_aliases, schema=schema)
+        if label is None or re.search(r"[\u4e00-\u9fff]", label) is None:
+            new_items.append(cleaned)
+            continue
+        label = _dedupe_chinese_alias(label, used_labels)
+        used_labels.add(label)
+        new_items.append(f"{expr} AS {label}")
+        changed = True
+    if not changed:
+        return sql
+    return _replace_top_level_select_list(sql, ", ".join(new_items))
 
 
-def _is_status_text_filter_column(column: str) -> bool:
-    return column in {"status", "state"} or column.endswith("_status") or column.endswith("_state")
+def question_requests_id_field(question: str) -> bool:
+    lowered = question.lower()
+    return "id" in lowered or "编号" in question or "主键" in question
 
 
-def _is_numeric_literal(value: str) -> bool:
-    return bool(re.fullmatch(r"-?\d+(?:\.\d+)?", value))
+def strip_identifier_columns_from_select(sql: str, question: str) -> str:
+    """Drop bare id / *_id columns from SELECT unless the question explicitly asks for ids."""
+    if question_requests_id_field(question):
+        return sql
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return sql
+    table_aliases = _sql_table_aliases(sql)
+    kept: list[str] = []
+    for item in _split_top_level_select_items(select_list):
+        cleaned = item.strip()
+        if not cleaned:
+            continue
+        expr = _select_expression_without_alias(cleaned)
+        if _select_expr_is_identifier_column(expr, table_aliases):
+            continue
+        kept.append(cleaned)
+    if not kept or len(kept) == len(_split_top_level_select_items(select_list)):
+        return sql
+    return _replace_top_level_select_list(sql, ", ".join(kept))
 
 
-def is_low_quality_sql_for_question(question: str, sql: str) -> bool:
-    normalized = re.sub(r"\s+", " ", sql.strip().lower())
-    if _is_business_query(question) and _is_single_entity_lookup_sql(sql):
-        return True
-    brand_filter = _extract_brand_filter(question)
-    if brand_filter is not None and _sql_references_brand_table(sql) and not _sql_contains_brand_name_filter(sql, brand_filter[1]):
-        return True
-    project_name = _extract_project_name(question)
-    if project_name is not None and _sql_references_table(sql, "sponge_project") and not _sql_contains_name_filter(sql, project_name):
+def apply_enum_case_to_select(sql: str, schema: dict[str, Any] | None) -> str:
+    """Wrap enum-backed scalar columns in CASE WHEN so SELECT shows Chinese labels."""
+    if not schema or not sql.strip():
+        return sql
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return sql
+    enums_by_field = {
+        str(entry.get("field") or ""): entry.get("values")
+        for entry in merged_schema_enums(schema)
+        if isinstance(entry, dict) and entry.get("field")
+    }
+    table_aliases = _sql_table_aliases(sql)
+    used_labels: set[str] = set()
+    new_items: list[str] = []
+    changed = False
+    for item in _split_top_level_select_items(select_list):
+        cleaned = item.strip()
+        if not cleaned:
+            new_items.append(cleaned)
+            continue
+        if re.match(r"case\s+", _select_expression_without_alias(cleaned), flags=re.IGNORECASE):
+            alias = _extract_select_alias(cleaned)
+            if alias:
+                used_labels.add(alias)
+            new_items.append(cleaned)
+            continue
+        expr = _select_expression_without_alias(cleaned)
+        case_expr = _enum_case_expression_for_select_item(
+            expr,
+            table_aliases=table_aliases,
+            enums_by_field=enums_by_field,
+            schema=schema,
+            used_labels=used_labels,
+            existing_alias=_extract_select_alias(cleaned),
+        )
+        if case_expr is None:
+            alias = _extract_select_alias(cleaned)
+            if alias:
+                used_labels.add(alias)
+            new_items.append(cleaned)
+            continue
+        used_labels.add(_extract_select_alias(case_expr) or "")
+        new_items.append(case_expr)
+        changed = True
+    if not changed:
+        return sql
+    return _replace_top_level_select_list(sql, ", ".join(new_items))
+
+
+def suggest_join_patterns_for_schema(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    suggestions: list[dict[str, Any]] = []
+    for example in _schema_examples(schema):
+        if not isinstance(example, dict):
+            continue
+        join_pattern = example.get("joinPattern")
+        if not isinstance(join_pattern, dict):
+            continue
+        item: dict[str, Any] = {"joinPattern": join_pattern}
+        for key in ("id", "intent", "notes", "questionExamples"):
+            value = example.get(key)
+            if value:
+                item[key] = value
+        suggestions.append(item)
+    return suggestions[:6]
+
+
+def finalize_generated_sql(
+    sql: str,
+    question: str,
+    *,
+    schema: dict[str, Any] | None = None,
+) -> str:
+    normalized = normalize_text_filters_to_like(sql)
+    normalized = strip_identifier_columns_from_select(normalized, question)
+    normalized = apply_enum_case_to_select(normalized, schema)
+    normalized = normalize_chinese_select_aliases(normalized, schema)
+    return normalized
+
+
+def _select_expr_is_identifier_column(expr: str, table_aliases: dict[str, str]) -> bool:
+    normalized = expr.strip()
+    match = re.fullmatch(r"([a-zA-Z_][\w]*)\.([a-zA-Z_][\w]*)", normalized)
+    if match is None:
+        return normalized.lower() in {"id"} or normalized.lower().endswith("_id")
+    alias, column = match.group(1).lower(), match.group(2).lower()
+    if column == "id" or column.endswith("_id"):
         return True
-    job_name = _extract_job_name_filter(question)
-    if job_name is not None and _sql_references_table(sql, "job_basic_info") and not _sql_contains_job_name_filter(sql, job_name):
+    table = table_aliases.get(alias)
+    if table and (column == "id" or column.endswith("_id")):
         return True
-    if _is_work_order_detail_query(question):
-        if "mvp_applied_jobs_by_helped_account" not in normalized:
-            return True
-        if re.search(r"\bfrom\s+brand\b", normalized) and "mvp_applied_jobs_by_helped_account" not in normalized:
-            return True
-        if _has_work_order_job_id_to_job_pk_join(normalized):
-            return True
-        if "面试成功" in question and "interview_pass_status" in normalized:
-            return True
     return False
 
 
-def validate_sql_against_schema(sql: str, schema: dict[str, Any]) -> list[SchemaValidationIssue]:
-    issues: list[SchemaValidationIssue] = []
-    table_aliases = _sql_table_aliases(sql)
-    schema_tables = _table_names(schema)
-    for table in table_aliases.values():
-        if table not in schema_tables:
-            issues.append(
-                SchemaValidationIssue(
-                    code="UNKNOWN_TABLE",
-                    message=f"SQL 使用了 schema 中不存在的表：{table}",
-                )
-            )
-
-    if {"mvp_applied_jobs_by_helped_account", "job_basic_info"} <= set(table_aliases.values()):
-        join_pairs = _sql_equality_pairs(sql, table_aliases)
-        allowed_pairs = _schema_allowed_join_pairs(schema)
-        work_order_job_pairs = {
-            pair
-            for pair in join_pairs
-            if {pair[0][0], pair[1][0]} == {"mvp_applied_jobs_by_helped_account", "job_basic_info"}
-            and (pair[0][1] == "job_id" or pair[1][1] == "job_id")
-        }
-        if not any(pair in allowed_pairs for pair in work_order_job_pairs):
-            issues.append(
-                SchemaValidationIssue(
-                    code="JOIN_NOT_IN_SCHEMA",
-                    message="报名工单和岗位表必须使用 schema 声明的 mvp_applied_jobs_by_helped_account.job_id = job_basic_info.job_id 关联。",
-                )
-            )
-    return issues
+def _enum_case_expression_for_select_item(
+    expr: str,
+    *,
+    table_aliases: dict[str, str],
+    enums_by_field: dict[str, Any],
+    schema: dict[str, Any],
+    used_labels: set[str],
+    existing_alias: str | None,
+) -> str | None:
+    match = re.fullmatch(r"([a-zA-Z_][\w]*)\.([a-zA-Z_][\w]*)", expr.strip())
+    if match is None:
+        return None
+    alias, column = match.group(1), match.group(2)
+    table = table_aliases.get(alias.lower())
+    if table is None:
+        return None
+    values = enums_by_field.get(f"{table}.{column}")
+    if not isinstance(values, list) or not values:
+        return None
+    when_parts: list[str] = []
+    for item in values:
+        if not isinstance(item, dict):
+            continue
+        value = item.get("value")
+        label = str(item.get("label") or "").strip()
+        if value is None or not label:
+            continue
+        literal = repr(str(value)) if isinstance(value, str) else str(value)
+        when_parts.append(f"WHEN {expr} = {literal} THEN {_sql_string_literal(label)}")
+    if not when_parts:
+        return None
+    alias_label = existing_alias or _chinese_label_for_column(schema, table, column) or column
+    alias_label = _dedupe_chinese_alias(alias_label, used_labels)
+    return f"CASE {' '.join(when_parts)} ELSE CAST({expr} AS CHAR) END AS {alias_label}"
 
 
-def _has_work_order_job_id_to_job_pk_join(normalized_sql: str) -> bool:
-    table_aliases = _sql_table_aliases(normalized_sql)
-    pairs = _sql_equality_pairs(normalized_sql, table_aliases)
-    return any(
-        {left[0], right[0]} == {"mvp_applied_jobs_by_helped_account", "job_basic_info"}
-        and (
-            (left[0] == "mvp_applied_jobs_by_helped_account" and left[1] == "job_id" and right[1] == "id")
-            or (right[0] == "mvp_applied_jobs_by_helped_account" and right[1] == "job_id" and left[1] == "id")
-        )
-        for left, right in pairs
-    )
+def _sql_string_literal(value: str) -> str:
+    return "'" + value.replace("'", "''") + "'"
 
 
-def _sql_table_aliases(sql: str) -> dict[str, str]:
-    aliases: dict[str, str] = {}
-    for match in re.finditer(
-        r"\b(?:from|join)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\s+(?:as\s+)?([a-zA-Z_][a-zA-Z0-9_]*))?",
+def _enforce_no_tautological_join_conditions(sql: str) -> None:
+    if re.search(
+        r"\b(?:left|right|inner|full|cross)?\s*join\b[\s\S]*?\bon\s+(?:1\s*=\s*0|0\s*=\s*1|1\s*=\s*1|true|false)\b",
         sql,
         flags=re.IGNORECASE,
     ):
-        table = match.group(1).lower()
-        alias = (match.group(2) or table).lower()
-        if alias in {"on", "where", "left", "right", "inner", "outer", "join"}:
-            alias = table
-        aliases[alias] = table
-        aliases[table] = table
-    return aliases
+        raise SqlGenerationError(
+            "SQL JOIN must not use tautological ON conditions such as ON 1=0 or ON 1=1; "
+            "use schema exampleJoinPatterns and structureHints to build real joins"
+        )
 
 
-def _sql_equality_pairs(sql: str, table_aliases: dict[str, str]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
-    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
-    for match in re.finditer(
-        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b",
-        sql,
-        flags=re.IGNORECASE,
-    ):
-        left_alias, left_column, right_alias, right_column = (part.lower() for part in match.groups())
-        left_table = table_aliases.get(left_alias)
-        right_table = table_aliases.get(right_alias)
-        if left_table is None or right_table is None:
+_JOIN_ON_START_RE = re.compile(
+    r"\b(?:(?:left|right|inner|full|cross)\s+)?join\s+(?:\([^)]+\)|[a-zA-Z_][\w]*(?:\s+(?:as\s+)?[a-zA-Z_][\w]*)?)\s+on\s+",
+    re.IGNORECASE,
+)
+_JOIN_ON_END_RE = re.compile(
+    r"\b(where|group\s+by|order\s+by|limit|(?:left|right|inner|full|cross)\s+join)\b",
+    re.IGNORECASE,
+)
+_CROSS_TABLE_EQUALITY_RE = re.compile(
+    r"(?:"
+    r"\b[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*"
+    r"(?:cast\s*\(\s*[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*\s+as\s+\w+\s*\)"
+    r"|[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)"
+    r"|"
+    r"cast\s*\(\s*[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*\s+as\s+\w+\s*\)\s*=\s*"
+    r"[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)",
+    re.IGNORECASE,
+)
+
+
+def _iter_join_on_clauses(sql: str) -> list[str]:
+    clauses: list[str] = []
+    for match in _JOIN_ON_START_RE.finditer(sql):
+        rest = sql[match.end() :]
+        end_match = _JOIN_ON_END_RE.search(rest)
+        end = end_match.start() if end_match else len(rest)
+        clause = rest[:end].strip()
+        if clause:
+            clauses.append(clause)
+    return clauses
+
+
+def _list_join_on_violations(sql: str) -> list[str]:
+    violations: list[str] = []
+    for on_clause in _iter_join_on_clauses(sql):
+        preview = re.sub(r"\s+", " ", on_clause).strip()[:120]
+        if re.search(r"\blike\b", on_clause, re.IGNORECASE):
+            violations.append(
+                "JOIN ON 禁止写 LIKE 筛选，请按 schema relations 写主表与关联表的等值键，"
+                f"把实体筛选放到 WHERE：{preview}"
+            )
             continue
-        pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
-    return pairs
+        if re.search(r"\bin\s*\(", on_clause, re.IGNORECASE):
+            violations.append(
+                "JOIN ON 禁止写 IN 筛选，请按 schema relations 写主表与关联表的等值键，"
+                f"把实体筛选放到 WHERE：{preview}"
+            )
+            continue
+        if _CROSS_TABLE_EQUALITY_RE.search(on_clause) is None:
+            violations.append(
+                "JOIN ON 必须使用主表与关联表的等值关联（如 store.organization_id = sponge_project.id），"
+                f"不能只有筛选条件：{preview}"
+            )
+    return violations
 
 
-def _schema_allowed_join_pairs(schema: dict[str, Any]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
-    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
-    joins = schema.get("joins", [])
-    if isinstance(joins, list):
-        for join in joins:
-            if not isinstance(join, dict):
-                continue
-            left_table = str(join.get("leftTable") or join.get("from") or "").lower()
-            left_column = str(join.get("leftColumn") or join.get("fromColumn") or "").lower()
-            right_table = str(join.get("rightTable") or join.get("to") or "").lower()
-            right_column = str(join.get("rightColumn") or join.get("toColumn") or "").lower()
-            if left_table and left_column and right_table and right_column:
-                pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
-    for section_name in ("metrics", "glossary", "examples"):
-        section = schema.get(section_name, [])
-        if isinstance(section, list):
-            for item in section:
-                if isinstance(item, dict):
-                    pairs.update(_join_pairs_from_text(str(item)))
-    return pairs
+def _enforce_join_on_uses_equality_keys(sql: str) -> None:
+    violations = _list_join_on_violations(sql)
+    if violations:
+        raise SqlGenerationError(violations[0])
 
 
-def _join_pairs_from_text(text: str) -> set[tuple[tuple[str, str], tuple[str, str]]]:
-    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
-    for match in re.finditer(
-        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b",
-        text,
+def _select_item_has_chinese_alias(item: str) -> bool:
+    alias = _extract_select_alias(item)
+    return alias is not None and re.search(r"[\u4e00-\u9fff]", alias) is not None
+
+
+def _extract_select_alias(item: str) -> str | None:
+    alias_match = re.search(
+        _SELECT_AS_ALIAS_PATTERN,
+        item.strip(),
         flags=re.IGNORECASE,
-    ):
-        left_table, left_column, right_table, right_column = (part.lower() for part in match.groups())
-        pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
-    return pairs
+    )
+    if alias_match is None:
+        return None
+    return alias_match.group(1).strip("`\"'")
 
 
-def _canonical_join_pair(
-    left: tuple[str, str],
-    right: tuple[str, str],
-) -> tuple[tuple[str, str], tuple[str, str]]:
-    return tuple(sorted((left, right)))  # type: ignore[return-value]
+def _dedupe_chinese_alias(label: str, used: set[str]) -> str:
+    if label not in used:
+        return label
+    index = 2
+    while f"{label}{index}" in used:
+        index += 1
+    return f"{label}{index}"
 
 
-def question_has_time_range(question: str) -> bool:
-    return _extract_time_range(question) is not None
+def _infer_chinese_select_alias(
+    expr: str,
+    *,
+    table_aliases: dict[str, str],
+    schema: dict[str, Any],
+) -> str | None:
+    normalized = expr.strip()
+    if not normalized:
+        return None
 
+    aggregate_match = re.match(r"(count|sum|avg|min|max)\s*\(", normalized, flags=re.IGNORECASE)
+    if aggregate_match is not None:
+        labels = {
+            "count": "数量",
+            "sum": "合计",
+            "avg": "平均值",
+            "min": "最小值",
+            "max": "最大值",
+        }
+        return labels.get(aggregate_match.group(1).lower())
 
-def sql_satisfies_time_range(sql: str, question: str, schema: dict[str, Any] | None = None) -> bool:
-    time_range = _extract_time_range(question, schema)
-    if time_range is None:
-        return True
-    normalized = sql.lower()
-    field_pattern = rf"(?:\b\w+\.)?{re.escape(time_range.field.lower())}\b"
-    if re.search(field_pattern, normalized) is None:
-        return False
-    if time_range.start[:10] in sql and time_range.end[:10] in sql:
-        return True
-    year = time_range.start[:4]
-    month = str(int(time_range.start[5:7]))
-    padded_month = time_range.start[5:7]
-    return bool(
-        re.search(rf"\byear\s*\([^)]*{re.escape(time_range.field)}[^)]*\)\s*=\s*{year}\b", normalized)
-        and re.search(rf"\bmonth\s*\([^)]*{re.escape(time_range.field)}[^)]*\)\s*=\s*(?:{month}|{padded_month})\b", normalized)
+    if re.match(r"case\s+", normalized, flags=re.IGNORECASE):
+        return "结果"
+
+    qualified_match = re.search(
+        r"(?:([a-zA-Z_][a-zA-Z0-9_]*)\.)?([a-zA-Z_][a-zA-Z0-9_]*)\s*$",
+        normalized,
     )
+    if qualified_match is not None:
+        alias_part, column_name = qualified_match.group(1), qualified_match.group(2)
+        if alias_part is not None:
+            table_name = table_aliases.get(alias_part.lower())
+            if table_name is not None:
+                return _chinese_label_for_column(schema, table_name, column_name)
+        return _chinese_label_for_bare_column(schema, table_aliases, column_name)
+    return None
+
+
+def _chinese_label_for_column(schema: dict[str, Any], table_name: str, column_name: str) -> str | None:
+    for column in _table_columns(schema, table_name):
+        name = str(column.get("columnName") or column.get("name") or "")
+        if name.lower() != column_name.lower():
+            continue
+        label = _column_alias(name, str(column.get("comment") or ""))
+        if re.search(r"[\u4e00-\u9fff]", label):
+            return label
+    return None
+
+
+def _chinese_label_for_bare_column(
+    schema: dict[str, Any],
+    table_aliases: dict[str, str],
+    column_name: str,
+) -> str | None:
+    labels = [
+        label
+        for table_name in set(table_aliases.values())
+        if (label := _chinese_label_for_column(schema, table_name, column_name)) is not None
+    ]
+    if len(labels) == 1:
+        return labels[0]
+    return None
+
+
+def _replace_top_level_select_list(sql: str, select_list: str) -> str:
+    stripped = sql.strip().rstrip(";")
+    match = re.match(r"select\s+(?:distinct\s+)?", stripped, flags=re.IGNORECASE)
+    if match is None:
+        return sql
+    start = match.end()
+    from_index = _find_top_level_keyword(stripped, "from", start=start)
+    if from_index is None:
+        return sql
+    prefix = stripped[:start].rstrip()
+    suffix = stripped[from_index:].lstrip()
+    return f"{prefix} {select_list} {suffix}"
+
+
+def _should_normalize_text_filter_to_like(column_name: str, value: str) -> bool:
+    if not value or _is_numeric_literal(value):
+        return False
+    return _is_name_filter_column(column_name) or _is_status_text_filter_column(column_name)
+
+
+def _enforce_text_filters_use_like(sql: str) -> None:
+    for match in _TEXT_EQUALITY_FILTER_RE.finditer(sql):
+        column = match.group("column").rsplit(".", 1)[-1].lower()
+        value = match.group("value").strip()
+        if _should_normalize_text_filter_to_like(column, value):
+            raise SqlGenerationError("SQL text filters must use LIKE")
+
+
+def _is_name_filter_column(column: str) -> bool:
+    return column == "name" or column == "job_name" or column.endswith("_name")
+
+
+def _is_status_text_filter_column(column: str) -> bool:
+    return column in {"status", "state"} or column.endswith("_status") or column.endswith("_state")
+
+
+def _is_numeric_literal(value: str) -> bool:
+    return bool(re.fullmatch(r"-?\d+(?:\.\d+)?", value))
+
+
+def is_low_quality_sql_for_question(question: str, sql: str, *, schema: dict[str, Any] | None = None) -> bool:
+    return low_quality_sql_issue_for_question(question, sql, schema=schema) is not None
+
+
+def low_quality_sql_issue_for_question(question: str, sql: str, *, schema: dict[str, Any] | None = None) -> LowQualitySqlIssue | None:
+    if schema is None:
+        return None
+    from .schema_context_retriever import match_concepts_for_question
+
+    matched_concepts = match_concepts_for_question(_schema_concepts(schema), question)
+    normalized = sql.strip().lower()
+    for concept in matched_concepts:
+        checks = concept.get("sqlQualityChecks")
+        if not _concept_quality_check_applies(concept, question):
+            continue
+        time_range_issue = _concept_time_range_field_issue(question, sql, concept)
+        if time_range_issue is not None:
+            return time_range_issue
+        if not isinstance(checks, dict):
+            continue
+        for table_name in checks.get("requireTables") or []:
+            table = str(table_name or "").strip().lower()
+            if table and table not in normalized:
+                message = str(checks.get("message") or f"SQL 必须引用 schema 要求的表：{table_name}")
+                return LowQualitySqlIssue(code="SCHEMA_SQL_QUALITY", message=message)
+    aggregate_issue = _aggregate_sql_quality_issue(question, sql)
+    if aggregate_issue is not None:
+        return aggregate_issue
+    return None
+
+
+def _concept_time_range_field_issue(
+    question: str,
+    sql: str,
+    concept: dict[str, Any],
+) -> LowQualitySqlIssue | None:
+    qualified = str(concept.get("timeRangeField") or "").strip()
+    if "." not in qualified or _extract_time_bounds(question) is None:
+        return None
+    table_name, field_name = qualified.rsplit(".", 1)
+    time_range = TimeRange(field=field_name, alias="时间范围", start="", end="", table_name=table_name)
+    if not _sql_has_time_filter_for_range(sql, time_range):
+        return LowQualitySqlIssue(
+            code="SCHEMA_TIME_RANGE_FIELD_REQUIRED",
+            message=(
+                f"用户问题包含时间范围，且 schema concept 指定时间字段为 {qualified}；"
+                "SQL 必须使用该字段过滤时间范围，不要改用关联维表的同名时间字段。"
+            ),
+        )
+    unexpected = _unexpected_time_filter_fields(sql, expected_field=qualified)
+    if unexpected:
+        return LowQualitySqlIssue(
+            code="SCHEMA_TIME_RANGE_FIELD_REQUIRED",
+            message=(
+                f"用户问题包含时间范围，且 schema concept 指定时间字段为 {qualified}；"
+                f"SQL 不应同时使用 {'、'.join(unexpected)} 过滤时间范围。"
+            ),
+        )
+    return None
+
+
+def _sql_has_time_filter_for_range(sql: str, time_range: TimeRange) -> bool:
+    where_index = _find_top_level_keyword(sql, "where", start=0)
+    if where_index is None:
+        return False
+    clause_start = where_index + len("where")
+    clause_end = _where_filter_insert_pos(sql[clause_start:])
+    if clause_end < len(sql[clause_start:]):
+        clause_end += clause_start
+    else:
+        clause_end = len(sql)
+    for predicate in _split_top_level_and_predicates(sql[clause_start:clause_end].strip()):
+        if _is_time_range_predicate(predicate, sql=sql, time_range=time_range):
+            return True
+    return False
+
+
+def _unexpected_time_filter_fields(sql: str, *, expected_field: str) -> list[str]:
+    expected_table, expected_column = expected_field.lower().rsplit(".", 1)
+    aliases = _sql_table_aliases(sql)
+    unexpected: list[str] = []
+    seen: set[str] = set()
+    where_index = _find_top_level_keyword(sql, "where", start=0)
+    if where_index is None:
+        return []
+    clause_start = where_index + len("where")
+    clause_end = _where_filter_insert_pos(sql[clause_start:])
+    if clause_end < len(sql[clause_start:]):
+        clause_end += clause_start
+    else:
+        clause_end = len(sql)
+    for predicate in _split_top_level_and_predicates(sql[clause_start:clause_end].strip()):
+        if re.search(r"'20\d{2}-\d{1,2}-\d{1,2}", predicate) is None:
+            continue
+        if re.search(r"(?:\bbetween\b|>=|>|<=|<|=)", predicate, flags=re.IGNORECASE) is None:
+            continue
+        for match in re.finditer(r"\b([a-zA-Z_][\w]*)\.([a-zA-Z_][\w]*)\b", predicate):
+            qualifier = match.group(1).lower()
+            column = match.group(2).lower()
+            if column != expected_column:
+                continue
+            table = aliases.get(qualifier, qualifier)
+            qualified = f"{table}.{column}"
+            if qualified == f"{expected_table}.{expected_column}" or qualified in seen:
+                continue
+            seen.add(qualified)
+            unexpected.append(qualified)
+    return unexpected
+
+
+def _aggregate_sql_quality_issue(question: str, sql: str) -> LowQualitySqlIssue | None:
+    if not _question_requires_aggregate_sql(question):
+        return None
+    normalized = sql.lower()
+    if re.search(r"\b(count|sum|avg|min|max)\s*\(", normalized):
+        return None
+    return LowQualitySqlIssue(
+        code="AGGREGATE_SQL_REQUIRED",
+        message="用户问题要求统计数量/最多值及对应维度，SQL 必须使用 COUNT/SUM/AVG/MIN/MAX 等聚合函数，不能只返回明细行。",
+    )
+
+
+def _question_requires_aggregate_sql(question: str) -> bool:
+    if not re.search(r"(计数|统计|数量|个数|总数|多少)", question):
+        return False
+    return bool(re.search(r"(最多|最少|最大|最小|排行|排名|对应|按.+?统计|根据.+?计数)", question))
+
+
+def _concept_quality_check_applies(concept: dict[str, Any], question: str) -> bool:
+    question_text = _compact_quality_match_text(question)
+    if not question_text:
+        return False
+    for example in concept.get("negativeExamples") or []:
+        if _quality_phrase_matches(question_text, example):
+            return False
+    for example in concept.get("positiveExamples") or []:
+        if _quality_phrase_matches(question_text, example):
+            return True
+    for example in concept.get("questionExamples") or []:
+        if _quality_phrase_matches(question_text, example):
+            return True
+    for key in ("comment", "description", "intent", "name", "term"):
+        if _quality_phrase_matches(question_text, concept.get(key)):
+            return True
+    return False
+
+
+def _quality_phrase_matches(question_text: str, phrase: Any) -> bool:
+    phrase_text = _compact_quality_match_text(str(phrase or ""))
+    return len(phrase_text) >= 2 and phrase_text in question_text
+
+
+def _compact_quality_match_text(text: str) -> str:
+    normalized = text.translate(str.maketrans("０１２３４５６７８９", "0123456789")).lower()
+    return "".join(re.findall(r"[a-z0-9\u4e00-\u9fff]+", normalized))
+
+
+def _sql_select_metric_aliases(sql: str) -> list[str]:
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return []
+    aliases: list[str] = []
+    for item in _split_top_level_select_items(select_list):
+        alias_match = re.search(
+            r"\s+as\s+(`[^`]+`|\"[^\"]+\"|'[^']+'|[\u4e00-\u9fff][\w\u4e00-\u9fff]*)\s*$",
+            item.strip(),
+            flags=re.IGNORECASE,
+        )
+        if alias_match is not None:
+            aliases.append(alias_match.group(1).strip("`\"'"))
+    return aliases
+
+
+def _replace_primary_metric_alias(sql: str, alias: str) -> str:
+    select_list = _top_level_select_list(sql)
+    if select_list is None:
+        return sql
+    items = _split_top_level_select_items(select_list)
+    if not items:
+        return sql
+    last_item = items[-1].strip()
+    updated_last = re.sub(
+        r"\s+as\s+(`[^`]+`|\"[^\"]+\"|'[^']+'|[\u4e00-\u9fff][\w\u4e00-\u9fff]*)\s*$",
+        f" AS {alias}",
+        last_item,
+        count=1,
+        flags=re.IGNORECASE,
+    )
+    if updated_last == last_item:
+        return sql
+    items[-1] = updated_last
+    rebuilt_select = ", ".join(items)
+    return re.sub(
+        r"(?is)\bselect\b(.*?)\bfrom\b",
+        lambda match: f"SELECT {rebuilt_select} FROM",
+        sql,
+        count=1,
+    )
+
+
+def _schema_enums(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    enums = schema.get("enums")
+    if isinstance(enums, list):
+        return [enum for enum in enums if isinstance(enum, dict)]
+    structure = schema.get("structure")
+    concepts = structure.get("concepts") if isinstance(structure, dict) else None
+    if not isinstance(concepts, list):
+        return []
+    by_field: dict[str, dict[Any, str]] = {}
+    for concept in concepts:
+        if not isinstance(concept, dict):
+            continue
+        enum_refs = concept.get("enumRefs")
+        if not isinstance(enum_refs, list):
+            continue
+        label_parts = [
+            str(concept.get("comment") or ""),
+            str(concept.get("name") or ""),
+            str(concept.get("description") or ""),
+        ]
+        for enum_ref in enum_refs:
+            if not isinstance(enum_ref, dict):
+                continue
+            field_name = str(enum_ref.get("field") or "")
+            if not field_name or "value" not in enum_ref:
+                continue
+            label = " / ".join(part for part in label_parts + [str(enum_ref.get("meaning") or "")] if part)
+            by_field.setdefault(field_name, {})[enum_ref["value"]] = label
+    return [
+        {"field": field_name, "values": [{"value": value, "label": label} for value, label in values.items()]}
+        for field_name, values in by_field.items()
+    ]
+
+
+def _enum_label_terms(label: str) -> set[str]:
+    terms = {label.strip()}
+    terms.update(part.strip() for part in re.split(r"[/、,，;；\s]+", label) if part.strip())
+    return {term for term in terms if term}
+
+
+def validate_sql_against_schema(sql: str, schema: dict[str, Any]) -> list[SchemaValidationIssue]:
+    issues: list[SchemaValidationIssue] = []
+    for subquery in _sql_derived_subqueries(sql).values():
+        issues.extend(validate_sql_against_schema(subquery, schema))
+    table_aliases = _sql_table_aliases(sql)
+    derived_columns = _sql_derived_subquery_aliases(sql)
+    schema_tables = _schema_table_column_map(schema)
+    for alias, columns in derived_columns.items():
+        schema_tables[alias] = columns
+    for table in set(table_aliases.values()):
+        if table in derived_columns:
+            continue
+        if table not in schema_tables:
+            issues.append(
+                SchemaValidationIssue(
+                    code="UNKNOWN_TABLE",
+                    message=f"SQL 使用了 schema 中不存在的表：{table}",
+                )
+            )
+    issues.extend(_schema_missing_table_reference_issues(sql, table_aliases))
+    issues.extend(_schema_unknown_column_issues(sql, table_aliases, schema_tables))
+    for message in _list_join_on_violations(sql):
+        issues.append(SchemaValidationIssue(code="JOIN_ON_FILTER", message=message))
+    if not any(issue.code == "UNKNOWN_TABLE" for issue in issues):
+        issues.extend(_schema_invalid_join_issues(sql, table_aliases, schema))
+    return issues
+
+
+def _schema_table_column_map(schema: dict[str, Any]) -> dict[str, set[str]]:
+    column_map: dict[str, set[str]] = {}
+    tables = schema.get("tables")
+    if not isinstance(tables, list):
+        nested_schema = schema.get("schema")
+        if isinstance(nested_schema, dict) and isinstance(nested_schema.get("tables"), list):
+            tables = nested_schema["tables"]
+        else:
+            tables = []
+    for table in tables:
+        if not isinstance(table, dict):
+            continue
+        name = table.get("name") or table.get("tableName")
+        if not name:
+            continue
+        table_key = str(name).lower()
+        columns = table.get("columns")
+        if not isinstance(columns, list):
+            continue
+        column_map[table_key] = {
+            str(column.get("columnName") or column.get("name") or "").lower()
+            for column in columns
+            if isinstance(column, dict) and (column.get("columnName") or column.get("name"))
+        }
+    return column_map
+
+
+def _schema_missing_table_reference_issues(
+    sql: str,
+    table_aliases: dict[str, str],
+) -> list[SchemaValidationIssue]:
+    declared = set(table_aliases)
+    issues: list[SchemaValidationIssue] = []
+    seen: set[tuple[str, str]] = set()
+    for alias, column in _sql_qualified_column_refs(sql):
+        if alias in declared:
+            continue
+        key = (alias, column)
+        if key in seen:
+            continue
+        seen.add(key)
+        issues.append(
+            SchemaValidationIssue(
+                code="MISSING_TABLE_REFERENCE",
+                message=(
+                    "SQL 引用了未在 FROM/JOIN 中声明的表或别名："
+                    f"{alias}.{column}；如果需要该字段必须先 JOIN 对应表，否则删除该引用。"
+                ),
+            )
+        )
+    return issues
+
+
+def _schema_unknown_column_issues(
+    sql: str,
+    table_aliases: dict[str, str],
+    schema_tables: dict[str, set[str]],
+) -> list[SchemaValidationIssue]:
+    issues: list[SchemaValidationIssue] = []
+    seen: set[tuple[str, str]] = set()
+    for alias, column in _sql_qualified_column_refs(sql):
+        table = table_aliases.get(alias)
+        if table is None or table not in schema_tables:
+            continue
+        key = (table, column)
+        if key in seen:
+            continue
+        seen.add(key)
+        if column not in schema_tables[table]:
+            issues.append(
+                SchemaValidationIssue(
+                    code="UNKNOWN_COLUMN",
+                    message=f"SQL 使用了 schema 中不存在的列：{table}.{column}",
+                )
+            )
+    return issues
+
+
+def _schema_invalid_join_issues(
+    sql: str,
+    table_aliases: dict[str, str],
+    schema: dict[str, Any],
+) -> list[SchemaValidationIssue]:
+    allowed_pairs = _schema_allowed_join_pairs(schema)
+    if not allowed_pairs:
+        return []
+    issues: list[SchemaValidationIssue] = []
+    seen: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    for pair in _sql_equality_pairs(sql, table_aliases):
+        if pair in seen:
+            continue
+        seen.add(pair)
+        if pair in allowed_pairs:
+            continue
+        left, right = pair
+        issues.append(
+            SchemaValidationIssue(
+                code="INVALID_JOIN",
+                message=(
+                    "SQL JOIN 使用了 schema relations / joinPattern 未定义的关联："
+                    f"{left[0]}.{left[1]} = {right[0]}.{right[1]}"
+                ),
+            )
+        )
+    return issues
+
+
+def _sql_qualified_column_refs(sql: str) -> list[tuple[str, str]]:
+    refs: list[tuple[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+    derived_spans = _sql_derived_subquery_spans(sql)
+    for match in re.finditer(
+        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.((?:[a-zA-Z_][a-zA-Z0-9_]*\.)*[a-zA-Z_][a-zA-Z0-9_]*)\b",
+        sql,
+        flags=re.IGNORECASE,
+    ):
+        if _position_in_spans(match.start(), derived_spans):
+            continue
+        alias = match.group(1).lower()
+        column_path = match.group(2).lower()
+        column = column_path.rsplit(".", 1)[-1]
+        key = (alias, column)
+        if key in seen:
+            continue
+        seen.add(key)
+        refs.append(key)
+    return refs
+
+
+def _sql_table_aliases(sql: str) -> dict[str, str]:
+    aliases = dict(_sql_top_level_table_aliases(sql))
+    for alias in _sql_derived_subquery_aliases(sql):
+        aliases[alias] = alias
+    return aliases
+
+
+def _sql_top_level_table_aliases(sql: str) -> dict[str, str]:
+    aliases: dict[str, str] = {}
+    depth = 0
+    quote: str | None = None
+    index = 0
+    length = len(sql)
+    while index < length:
+        char = sql[index]
+        if quote is not None:
+            if char == quote:
+                quote = None
+            elif char == "\\":
+                index += 1
+            index += 1
+            continue
+        if char in ("'", '"', "`"):
+            quote = char
+            index += 1
+            continue
+        if char == "(":
+            depth += 1
+            index += 1
+            continue
+        if char == ")":
+            depth = max(0, depth - 1)
+            index += 1
+            continue
+        if depth == 0:
+            match = re.match(
+                r"(?i)(?:from|join)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\s+(?:as\s+)?([a-zA-Z_][a-zA-Z0-9_]*))?",
+                sql[index:],
+            )
+            if match:
+                table = match.group(1).lower()
+                alias = (match.group(2) or table).lower()
+                if alias in {"on", "where", "left", "right", "inner", "outer", "join"}:
+                    alias = table
+                aliases[alias] = table
+                aliases[table] = table
+                index += match.end()
+                continue
+        index += 1
+    return aliases
+
+
+def _sql_derived_subquery_aliases(sql: str) -> dict[str, set[str]]:
+    return {
+        alias: _extract_subquery_output_columns(subquery)
+        for alias, subquery in _sql_derived_subqueries(sql).items()
+    }
+
+
+def _sql_derived_subqueries(sql: str) -> dict[str, str]:
+    derived: dict[str, str] = {}
+    for alias, subquery_start, subquery_end in _sql_derived_subquery_matches(sql):
+        derived[alias] = sql[subquery_start + 1 : subquery_end]
+    return derived
+
+
+def _sql_derived_subquery_spans(sql: str) -> list[tuple[int, int]]:
+    return [
+        (subquery_start + 1, subquery_end)
+        for _alias, subquery_start, subquery_end in _sql_derived_subquery_matches(sql)
+    ]
+
+
+def _sql_derived_subquery_matches(sql: str) -> list[tuple[str, int, int]]:
+    matches: list[tuple[str, int, int]] = []
+    for match in re.finditer(
+        r"\)\s*(?:as\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s+on\b",
+        sql,
+        flags=re.IGNORECASE,
+    ):
+        alias = match.group(1).lower()
+        if alias in {"on", "where", "left", "right", "inner", "outer", "join", "select"}:
+            continue
+        subquery_start = _find_matching_open_paren(sql, match.start())
+        if subquery_start is None:
+            continue
+        matches.append((alias, subquery_start, match.start()))
+    return matches
+
+
+def _position_in_spans(position: int, spans: list[tuple[int, int]]) -> bool:
+    return any(start <= position < end for start, end in spans)
+
+
+def _find_matching_open_paren(sql: str, close_index: int) -> int | None:
+    depth = 0
+    for index in range(close_index, -1, -1):
+        char = sql[index]
+        if char == ")":
+            depth += 1
+        elif char == "(":
+            depth -= 1
+            if depth == 0:
+                return index
+    return None
+
+
+def _extract_subquery_output_columns(subquery: str) -> set[str]:
+    select_match = re.search(r"\bselect\b(.*?)\bfrom\b", subquery, flags=re.IGNORECASE | re.DOTALL)
+    if select_match is None:
+        return set()
+    columns: set[str] = set()
+    for expr in _split_select_items(select_match.group(1)):
+        cleaned = expr.strip()
+        if not cleaned:
+            continue
+        alias_match = re.search(r"\bas\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*$", cleaned, flags=re.IGNORECASE)
+        if alias_match:
+            columns.add(alias_match.group(1).lower())
+            continue
+        qualified_match = re.match(
+            r"^([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)$",
+            cleaned,
+            flags=re.IGNORECASE,
+        )
+        if qualified_match:
+            columns.add(qualified_match.group(2).lower())
+            continue
+        bare_match = re.match(r"^([a-zA-Z_][a-zA-Z0-9_]*)$", cleaned, flags=re.IGNORECASE)
+        if bare_match:
+            columns.add(bare_match.group(1).lower())
+    return columns
+
+
+def _sql_equality_pairs(sql: str, table_aliases: dict[str, str]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    derived_spans = _sql_derived_subquery_spans(sql)
+    for match in re.finditer(
+        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b",
+        sql,
+        flags=re.IGNORECASE,
+    ):
+        if _position_in_spans(match.start(), derived_spans):
+            continue
+        left_alias, left_column, right_alias, right_column = (part.lower() for part in match.groups())
+        left_table = table_aliases.get(left_alias)
+        right_table = table_aliases.get(right_alias)
+        if left_table is None or right_table is None:
+            continue
+        pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
+    return pairs
+
+
+def _schema_allowed_join_pairs(schema: dict[str, Any]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    relations = _schema_relations(schema)
+    if isinstance(relations, list):
+        for relation in relations:
+            if not isinstance(relation, dict):
+                continue
+            left_table, left_column = _relation_left(relation)
+            right_table, right_column = _relation_right(relation)
+            if left_table and left_column and right_table and right_column:
+                pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
+    for section in (_schema_metrics(schema), _schema_business_terms(schema), _schema_concepts(schema), _schema_examples(schema)):
+        if isinstance(section, list):
+            for item in section:
+                if isinstance(item, dict):
+                    pairs.update(_join_pairs_from_text(str(item)))
+    pairs.update(_schema_example_join_pattern_pairs(schema))
+    pairs.update(_schema_work_order_failure_reason_join_pairs(schema))
+    pairs.update(_schema_inferred_foreign_key_join_pairs(schema))
+    return pairs
+
+
+def _schema_inferred_foreign_key_join_pairs(
+    schema: dict[str, Any],
+) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    """Allow `{ref_table}_id` columns to join `{ref_table}.id` when no explicit relation exists."""
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    table_names = {
+        str(table.get("tableName") or table.get("name") or "")
+        for table in schema.get("tables") or []
+        if isinstance(table, dict) and (table.get("tableName") or table.get("name"))
+    }
+    for table in schema.get("tables") or []:
+        if not isinstance(table, dict):
+            continue
+        table_name = str(table.get("tableName") or table.get("name") or "")
+        if not table_name:
+            continue
+        for column in table.get("columns") or []:
+            if not isinstance(column, dict):
+                continue
+            column_name = str(column.get("columnName") or column.get("name") or "")
+            if not column_name.endswith("_id") or column_name == "id":
+                continue
+            ref_table = column_name[:-3]
+            if ref_table not in table_names:
+                continue
+            pairs.add(_canonical_join_pair((table_name, column_name), (ref_table, "id")))
+    return pairs
+
+
+def _schema_work_order_failure_reason_join_pairs(
+    schema: dict[str, Any],
+) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    mappings = _schema_structure(schema).get("workOrderFailureReasonMappings")
+    if not isinstance(mappings, list):
+        return pairs
+    for mapping in mappings:
+        if not isinstance(mapping, dict):
+            continue
+        reason_join = mapping.get("reasonJoin")
+        if isinstance(reason_join, str) and reason_join.strip():
+            pairs.update(_join_pairs_from_text(reason_join))
+    unpivot = _schema_structure(schema).get("workOrderFailureReasonUnpivot")
+    if isinstance(unpivot, dict):
+        base_table = str(unpivot.get("baseTable") or "mvp_applied_jobs_by_helped_account")
+        for branch in unpivot.get("branches") or []:
+            if not isinstance(branch, dict):
+                continue
+            reason_field = str(branch.get("reasonField") or "")
+            if reason_field:
+                pairs.add(
+                    _canonical_join_pair(
+                        ("failure_reasons", "id"),
+                        (base_table, reason_field),
+                    )
+                )
+    return pairs
+
+
+def _schema_example_join_pattern_pairs(schema: dict[str, Any]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    example = schema.get("example")
+    examples: list[Any] = []
+    if isinstance(example, dict) and isinstance(example.get("examples"), list):
+        examples = example["examples"]
+    examples.extend(_schema_examples(schema))
+    for item in examples:
+        if not isinstance(item, dict):
+            continue
+        join_pattern = item.get("joinPattern")
+        if isinstance(join_pattern, dict):
+            pairs.update(_join_pattern_equality_pairs(join_pattern))
+    return pairs
+
+
+def _join_pattern_equality_pairs(join_pattern: dict[str, Any]) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    aliases = _parse_table_alias_clause(str(join_pattern.get("from") or ""))
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    joins = join_pattern.get("joins")
+    if not isinstance(joins, list):
+        return pairs
+    for join in joins:
+        if not isinstance(join, dict):
+            continue
+        aliases.update(_parse_table_alias_clause(str(join.get("table") or "")))
+        on_conditions = join.get("on")
+        if not isinstance(on_conditions, list):
+            continue
+        for condition in on_conditions:
+            pairs.update(_join_pairs_from_on_text(str(condition), aliases))
+    return pairs
+
+
+def _parse_table_alias_clause(clause: str) -> dict[str, str]:
+    cleaned = clause.strip()
+    if not cleaned:
+        return {}
+    match = re.match(
+        r"^([a-zA-Z_][a-zA-Z0-9_]*)(?:\s+(?:as\s+)?([a-zA-Z_][a-zA-Z0-9_]*))?$",
+        cleaned,
+        flags=re.IGNORECASE,
+    )
+    if match is None:
+        return {}
+    table = match.group(1).lower()
+    alias = (match.group(2) or table).lower()
+    return {alias: table, table: table}
+
+
+def _join_pairs_from_on_text(
+    on: str,
+    aliases: dict[str, str],
+) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    for match in re.finditer(
+        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b",
+        on,
+        flags=re.IGNORECASE,
+    ):
+        left_alias, left_column, right_alias, right_column = (part.lower() for part in match.groups())
+        left_table = aliases.get(left_alias)
+        right_table = aliases.get(right_alias)
+        if left_table is None or right_table is None:
+            continue
+        pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
+    return pairs
+
+
+def _schema_structure(schema: dict[str, Any]) -> dict[str, Any]:
+    structure = schema.get("structure")
+    return structure if isinstance(structure, dict) else {}
+
+
+def _schema_relations(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    relations = _schema_structure(schema).get("relations")
+    if isinstance(relations, list):
+        return [relation for relation in relations if isinstance(relation, dict)]
+    joins = schema.get("joins")
+    if isinstance(joins, list):
+        return [join for join in joins if isinstance(join, dict)]
+    return []
+
+
+def _schema_metrics(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    metrics = _schema_structure(schema).get("metrics")
+    if isinstance(metrics, list):
+        return [metric for metric in metrics if isinstance(metric, dict)]
+    legacy_metrics = schema.get("metrics")
+    if isinstance(legacy_metrics, list):
+        return [metric for metric in legacy_metrics if isinstance(metric, dict)]
+    return []
+
+
+def _schema_business_terms(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    business_terms = _schema_structure(schema).get("businessTerms")
+    if isinstance(business_terms, list):
+        return [term for term in business_terms if isinstance(term, dict)]
+    legacy_glossary = schema.get("glossary")
+    if isinstance(legacy_glossary, list):
+        return [term for term in legacy_glossary if isinstance(term, dict)]
+    return []
+
+
+def _schema_concepts(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    concepts = _schema_structure(schema).get("concepts")
+    if isinstance(concepts, list):
+        return [concept for concept in concepts if isinstance(concept, dict)]
+    return []
+
+
+def _schema_examples(schema: dict[str, Any]) -> list[dict[str, Any]]:
+    example = schema.get("example")
+    if isinstance(example, dict) and isinstance(example.get("examples"), list):
+        return [item for item in example["examples"] if isinstance(item, dict)]
+    legacy_examples = schema.get("examples")
+    if isinstance(legacy_examples, list):
+        return [item for item in legacy_examples if isinstance(item, dict)]
+    return []
+
+
+def _relation_left(relation: dict[str, Any]) -> tuple[str, str]:
+    table = str(relation.get("leftTable") or "").lower()
+    column = str(relation.get("leftColumn") or relation.get("fromColumn") or "").lower()
+    if table:
+        return table, column
+    return _split_field_ref(str(relation.get("from") or "").lower())
+
+
+def _relation_right(relation: dict[str, Any]) -> tuple[str, str]:
+    table = str(relation.get("rightTable") or "").lower()
+    column = str(relation.get("rightColumn") or relation.get("toColumn") or "").lower()
+    if table:
+        return table, column
+    return _split_field_ref(str(relation.get("to") or "").lower())
+
+
+def _split_field_ref(value: str) -> tuple[str, str]:
+    if "." not in value:
+        return value, ""
+    return tuple(value.split(".", 1))  # type: ignore[return-value]
+
+
+def _join_pairs_from_text(text: str) -> set[tuple[tuple[str, str], tuple[str, str]]]:
+    pairs: set[tuple[tuple[str, str], tuple[str, str]]] = set()
+    for match in re.finditer(
+        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b",
+        text,
+        flags=re.IGNORECASE,
+    ):
+        left_table, left_column, right_table, right_column = (part.lower() for part in match.groups())
+        pairs.add(_canonical_join_pair((left_table, left_column), (right_table, right_column)))
+    return pairs
+
+
+def _canonical_join_pair(
+    left: tuple[str, str],
+    right: tuple[str, str],
+) -> tuple[tuple[str, str], tuple[str, str]]:
+    return tuple(sorted((left, right)))  # type: ignore[return-value]
+
+
+def question_has_time_range(question: str) -> bool:
+    return _extract_time_range(question) is not None
+
+
+def extract_time_range(question: str, schema: dict[str, Any] | None = None) -> TimeRange | None:
+    """Parse a question time window; month/day without year defaults to the current year."""
+    return _extract_time_range(question, schema)
+
+
+def time_range_from_query_plan(query_plan: dict[str, Any] | None) -> TimeRange | None:
+    """Extract a confirmed time window from query-plan filters."""
+    if not isinstance(query_plan, dict):
+        return None
+    start_value = ""
+    end_value = ""
+    field_name = ""
+    for flt in query_plan.get("filters") or []:
+        if not isinstance(flt, dict):
+            continue
+        if str(flt.get("source") or "") != "question.timeRange":
+            continue
+        operator = str(flt.get("operator") or "").strip()
+        value = str(flt.get("value") or "").strip()
+        field = str(flt.get("field") or "").strip()
+        if operator == ">=":
+            start_value = value
+            field_name = field or field_name
+        elif operator == "<":
+            end_value = value
+            field_name = field or field_name
+    if not start_value or not end_value or not field_name:
+        return None
+    table_name, column = field_name.split(".", 1) if "." in field_name else ("", field_name)
+    return TimeRange(
+        field=column,
+        alias="时间范围",
+        start=start_value,
+        end=end_value,
+        table_name=table_name,
+    )
+
+
+def resolve_time_range(
+    question: str,
+    schema: dict[str, Any] | None = None,
+    *,
+    query_plan: dict[str, Any] | None = None,
+) -> TimeRange | None:
+    plan_range = time_range_from_query_plan(query_plan)
+    if plan_range is not None:
+        return plan_range
+    return extract_time_range(question, schema)
+
+
+def time_range_plan_filters(
+    question: str,
+    schema: dict[str, Any] | None,
+    *,
+    concepts: list[dict[str, Any]] | None = None,
+) -> list[dict[str, str]]:
+    """Build query-plan filters for an extracted time range."""
+    time_range = resolve_time_range_for_question(question, schema, concepts=concepts)
+    if time_range is None:
+        return []
+    qualified_field = (
+        f"{time_range.table_name}.{time_range.field}"
+        if time_range.table_name
+        else time_range.field
+    )
+    label = time_range.alias or "时间范围"
+    return [
+        {
+            "field": qualified_field,
+            "operator": ">=",
+            "value": time_range.start[:10],
+            "description": f"{label}起",
+            "source": "question.timeRange",
+        },
+        {
+            "field": qualified_field,
+            "operator": "<",
+            "value": time_range.end[:10],
+            "description": f"{label}止",
+            "source": "question.timeRange",
+        },
+    ]
+
+
+_FILLED_JOB_PERIOD_CONCEPT = "filled_job_by_period"
+
+
+def _query_plan_has_matched_concept(query_plan: dict[str, Any], concept_name: str) -> bool:
+    for concept in query_plan.get("matchedConcepts") or []:
+        if isinstance(concept, dict) and str(concept.get("name") or "") == concept_name:
+            return True
+    return False
+
+
+def _uses_subquery_period_time_range(sql: str, query_plan: dict[str, Any] | None) -> bool:
+    if isinstance(query_plan, dict) and _query_plan_has_matched_concept(
+        query_plan,
+        _FILLED_JOB_PERIOD_CONCEPT,
+    ):
+        return True
+    return "period_active_apply_count" in sql.lower()
+
+
+def _period_time_bounds(time_range: TimeRange) -> tuple[str, str]:
+    start = time_range.start
+    end = time_range.end
+    if len(start) <= 10:
+        start = f"{start[:10]} 00:00:00"
+    if len(end) <= 10:
+        end = f"{end[:10]} 00:00:00"
+    return start, end
+
+
+def _apply_subquery_period_time_range(sql: str, time_range: TimeRange) -> str:
+    """Apply confirmed time bounds inside apply_stat CASE WHEN, not outer WHERE."""
+    stripped = _remove_time_range_filters_from_sql(
+        sql.rstrip().rstrip(";"),
+        time_range,
+        allow_any_alias=True,
+    )
+    period_start, period_end = _period_time_bounds(time_range)
+    result = stripped
+    for old, new in (
+        ("'<period_start>'", f"'{period_start}'"),
+        ("'<period_end>'", f"'{period_end}'"),
+        ("<period_start>", f"'{period_start}'"),
+        ("<period_end>", f"'{period_end}'"),
+    ):
+        result = result.replace(old, new)
+    field_pattern = rf"(?:\w+\.)?{re.escape(time_range.field)}"
+    time_expr = (
+        r"(?:date_add\s*\(\s*curdate\s*\(\s*\)\s*,\s*interval\s+\d+\s+day\s*\)"
+        r"|curdate\s*\(\s*\)|current_date(?:\s*\(\s*\))?|'[^']+')"
+    )
+    return re.sub(
+        rf"(?is)(case\s+when\s+{field_pattern}\s*>=\s*){time_expr}(\s+and\s+{field_pattern}\s*<\s*){time_expr}(\s+then)",
+        lambda match: f"{match.group(1)}'{period_start}'{match.group(2)}'{period_end}'{match.group(3)}",
+        result,
+    )
+
+
+def apply_time_range_filters_from_plan(sql: str, query_plan: dict[str, Any] | None) -> str:
+    """Force generated SQL to use the confirmed query-plan time filters."""
+    if not isinstance(query_plan, dict):
+        return sql
+    time_range = time_range_from_query_plan(query_plan)
+    if time_range is None:
+        return sql
+    stripped = _remove_time_range_filters_from_sql(sql.rstrip().rstrip(";"), time_range)
+    if _uses_subquery_period_time_range(stripped, query_plan):
+        return _apply_subquery_period_time_range(stripped, time_range)
+    qualified_field = _time_range_sql_qualified_field(stripped, time_range)
+    extra = (
+        f"{qualified_field} >= '{time_range.start[:10]}' "
+        f"AND {qualified_field} < '{time_range.end[:10]}'"
+    )
+    insert_pos = _where_filter_insert_pos(stripped)
+    head = stripped[:insert_pos].rstrip()
+    tail = stripped[insert_pos:].lstrip()
+    if _find_top_level_keyword(head, "where", start=0) is not None:
+        return f"{head} AND {extra} {tail}".strip()
+    return f"{head} WHERE {extra} {tail}".strip()
+
+
+def apply_time_range_filters_from_question(
+    sql: str,
+    question: str,
+    schema: dict[str, Any] | None,
+) -> str:
+    """Force a question-level time range into SQL when queryPlan missed it."""
+    time_range = resolve_time_range_for_sql(question, schema, sql)
+    if time_range is None:
+        return sql
+    query_plan = {
+        "filters": [
+            {
+                "field": _qualified_time_range_field(time_range),
+                "operator": ">=",
+                "value": time_range.start[:10],
+                "source": "question.timeRange",
+            },
+            {
+                "field": _qualified_time_range_field(time_range),
+                "operator": "<",
+                "value": time_range.end[:10],
+                "source": "question.timeRange",
+            },
+        ]
+    }
+    return apply_time_range_filters_from_plan(sql, query_plan)
+
+
+def resolve_time_range_for_sql(
+    question: str,
+    schema: dict[str, Any] | None,
+    sql: str,
+) -> TimeRange | None:
+    if not schema:
+        return None
+    from .schema_context_retriever import match_concepts_for_question
+
+    concepts = match_concepts_for_question(_schema_concepts(schema), question)
+    sql_schema = _schema_limited_to_sql_tables(schema, sql)
+    return resolve_time_range_for_question(question, sql_schema or schema, concepts=concepts)
+
+
+def _qualified_time_range_field(time_range: TimeRange) -> str:
+    if time_range.table_name:
+        return f"{time_range.table_name}.{time_range.field}"
+    return time_range.field
+
+
+def _where_filter_insert_pos(sql: str) -> int:
+    positions = [
+        pos
+        for keyword in ("group by", "order by", "limit")
+        if (pos := _find_top_level_keyword(sql, keyword, start=0)) is not None
+    ]
+    return min(positions) if positions else len(sql)
+
+
+def _remove_time_range_filters_from_sql(
+    sql: str,
+    time_range: TimeRange,
+    *,
+    allow_any_alias: bool = False,
+) -> str:
+    where_index = _find_top_level_keyword(sql, "where", start=0)
+    if where_index is None:
+        return sql
+    clause_start = where_index + len("where")
+    clause_end = _where_filter_insert_pos(sql[clause_start:])
+    if clause_end < len(sql[clause_start:]):
+        clause_end += clause_start
+    else:
+        clause_end = len(sql)
+    where_body = sql[clause_start:clause_end].strip()
+    if not where_body:
+        return sql
+    predicates = _split_top_level_and_predicates(where_body)
+    kept = [
+        predicate.strip()
+        for predicate in predicates
+        if predicate.strip()
+        and not _is_time_range_predicate(
+            predicate,
+            sql=sql,
+            time_range=time_range,
+            allow_any_alias=allow_any_alias,
+        )
+    ]
+    prefix = sql[:where_index].rstrip()
+    suffix = sql[clause_end:].lstrip()
+    if not kept:
+        return f"{prefix} {suffix}".strip()
+    return f"{prefix} WHERE {' AND '.join(kept)} {suffix}".strip()
+
+
+def _split_top_level_and_predicates(where_body: str) -> list[str]:
+    predicates: list[str] = []
+    depth = 0
+    quote: str | None = None
+    start = 0
+    index = 0
+    while index < len(where_body):
+        char = where_body[index]
+        if quote is not None:
+            if char == quote:
+                quote = None
+            elif char == "\\":
+                index += 1
+            index += 1
+            continue
+        if char in ("'", '"', "`"):
+            quote = char
+            index += 1
+            continue
+        if char == "(":
+            depth += 1
+            index += 1
+            continue
+        if char == ")":
+            depth = max(0, depth - 1)
+            index += 1
+            continue
+        if depth == 0 and where_body[index : index + 3].lower() == "and":
+            before = where_body[index - 1] if index > 0 else " "
+            after_index = index + 3
+            after = where_body[after_index] if after_index < len(where_body) else " "
+            if not (before.isalnum() or before == "_") and not (after.isalnum() or after == "_"):
+                predicates.append(where_body[start:index])
+                start = after_index
+                index = after_index
+                continue
+        index += 1
+    predicates.append(where_body[start:])
+    return predicates
+
+
+def _is_time_range_predicate(
+    predicate: str,
+    *,
+    sql: str,
+    time_range: TimeRange,
+    allow_any_alias: bool = False,
+) -> bool:
+    field_pattern = _time_range_sql_field_pattern(sql, time_range, allow_any_alias=allow_any_alias)
+    if re.search(field_pattern, predicate, flags=re.IGNORECASE) is None:
+        return False
+    if re.search(r"'20\d{2}-\d{1,2}-\d{1,2}(?:\s+\d{1,2}:\d{2}:\d{2})?'", predicate) is None:
+        return False
+    return bool(re.search(r"(?:\bbetween\b|>=|>|<=|<|=)", predicate, flags=re.IGNORECASE))
+
+
+def _time_range_sql_field_pattern(
+    sql: str,
+    time_range: TimeRange,
+    *,
+    allow_any_alias: bool = False,
+) -> str:
+    field = re.escape(time_range.field.lower())
+    if allow_any_alias or not time_range.table_name:
+        return rf"(?:\b\w+\.)?{field}\b"
+    aliases = [
+        re.escape(alias)
+        for alias, table in _sql_table_aliases(sql).items()
+        if table == time_range.table_name.lower()
+    ]
+    aliases.append(re.escape(time_range.table_name.lower()))
+    qualifier = "|".join(sorted(set(aliases), key=len, reverse=True))
+    return rf"\b(?:{qualifier})\.{field}\b"
+
+
+def _time_range_sql_qualified_field(sql: str, time_range: TimeRange) -> str:
+    if not time_range.table_name:
+        return time_range.field
+    aliases = _sql_top_level_table_aliases(sql)
+    alias_candidates = [
+        alias
+        for alias, table in aliases.items()
+        if table == time_range.table_name.lower() and alias != time_range.table_name.lower()
+    ]
+    if alias_candidates:
+        return f"{sorted(alias_candidates, key=len)[0]}.{time_range.field}"
+    return f"{time_range.table_name}.{time_range.field}"
+
+
+def sql_missing_query_plan_filters(sql: str, query_plan: dict[str, Any] | None) -> list[str]:
+    """Return table.column LIKE filters from query_plan that are absent in sql."""
+    if not isinstance(query_plan, dict):
+        return []
+    missing: list[str] = []
+    normalized_sql = sql.lower()
+    grouped_filters: dict[str, list[dict[str, Any]]] = {}
+    for flt in query_plan.get("filters") or []:
+        if not isinstance(flt, dict):
+            continue
+        if str(flt.get("operator") or "").upper() != "LIKE":
+            continue
+        logical_group = str(flt.get("logicalGroup") or "").strip()
+        if logical_group:
+            grouped_filters.setdefault(logical_group, []).append(flt)
+        field = str(flt.get("field") or "").strip()
+        if "." not in field:
+            continue
+        table, column = field.split(".", 1)
+        value = str(flt.get("value") or "").strip().strip("%")
+        if not value:
+            continue
+        table_l = table.lower()
+        column_l = column.lower()
+        table_present = bool(re.search(rf"\b{re.escape(table_l)}\b", normalized_sql))
+        column_present = bool(re.search(rf"\b{re.escape(column_l)}\b", normalized_sql))
+        value_present = value.lower() in normalized_sql
+        if not table_present or not column_present or not value_present:
+            missing.append(f"{field} LIKE {flt.get('value')}")
+    for group_name, filters in grouped_filters.items():
+        if len(filters) <= 1:
+            continue
+        group_missing = [
+            f"{flt.get('field')} LIKE {flt.get('value')}"
+            for flt in filters
+            if f"{flt.get('field')} LIKE {flt.get('value')}" in missing
+        ]
+        if group_missing:
+            continue
+        if not _or_group_filters_connected_by_or(normalized_sql, filters):
+            missing.append(f"{group_name} requires OR between matched entities")
+    return missing
+
+
+def sql_satisfies_query_plan_filters(sql: str, query_plan: dict[str, Any] | None) -> bool:
+    return not sql_missing_query_plan_filters(sql, query_plan)
+
+
+def _or_group_filters_connected_by_or(normalized_sql: str, filters: list[dict[str, Any]]) -> bool:
+    if not re.search(r"\bor\b", normalized_sql):
+        return False
+    positions: list[int] = []
+    for flt in filters:
+        value = str(flt.get("value") or "").strip().strip("%").lower()
+        if not value:
+            continue
+        found = normalized_sql.find(value)
+        if found >= 0:
+            positions.append(found)
+    if len(positions) < 2:
+        return True
+    start, end = min(positions), max(positions)
+    between = normalized_sql[start:end]
+    return bool(re.search(r"\bor\b", between))
+
+
+def sql_missing_query_plan_select_fields(sql: str, query_plan: dict[str, Any] | None) -> list[str]:
+    """Return required SELECT display fields from query_plan that are absent in sql."""
+    if not isinstance(query_plan, dict):
+        return []
+    select_clause = _select_clause(sql).lower()
+    if not select_clause:
+        return []
+    missing: list[str] = []
+    for item in query_plan.get("fields") or []:
+        if not isinstance(item, dict):
+            continue
+        if item.get("required") is not True and str(item.get("source") or "") != "search_entities":
+            continue
+        table = str(item.get("table") or "").strip()
+        field = str(item.get("field") or "").strip()
+        description = str(item.get("description") or "").strip()
+        if not table or not field:
+            continue
+        qualified = f"{table}.{field}".lower()
+        description_present = bool(description and description.lower() in select_clause)
+        qualified_present = qualified in select_clause
+        if not description_present and not qualified_present:
+            missing.append(f"{qualified} AS {description or field}")
+    return missing
+
+
+def sql_satisfies_query_plan_select_fields(sql: str, query_plan: dict[str, Any] | None) -> bool:
+    return not sql_missing_query_plan_select_fields(sql, query_plan)
+
+
+def _select_clause(sql: str) -> str:
+    match = re.search(r"\bselect\b(?P<select>.*?)\bfrom\b", sql, flags=re.IGNORECASE | re.DOTALL)
+    return match.group("select") if match else ""
+
+
+def sql_satisfies_time_range(
+    sql: str,
+    question: str,
+    schema: dict[str, Any] | None = None,
+    *,
+    query_plan: dict[str, Any] | None = None,
+) -> bool:
+    time_range = resolve_time_range(question, schema, query_plan=query_plan)
+    if time_range is None:
+        return True
+    normalized = sql.lower()
+    field_pattern = rf"(?:\b\w+\.)?{re.escape(time_range.field.lower())}\b"
+    if re.search(field_pattern, normalized) is None:
+        return False
+    if time_range.start[:10] in sql and time_range.end[:10] in sql:
+        return True
+    end_date = _parse_date(time_range.end[:10])
+    if end_date is not None:
+        inclusive_end = (end_date - timedelta(days=1)).isoformat()
+        if time_range.start[:10] in sql and inclusive_end in sql:
+            return True
+    year = time_range.start[:4]
+    month = str(int(time_range.start[5:7]))
+    padded_month = time_range.start[5:7]
+    return bool(
+        re.search(rf"\byear\s*\([^)]*{re.escape(time_range.field)}[^)]*\)\s*=\s*{year}\b", normalized)
+        and re.search(rf"\bmonth\s*\([^)]*{re.escape(time_range.field)}[^)]*\)\s*=\s*(?:{month}|{padded_month})\b", normalized)
+    )
+
+
+def _schema_limited_to_sql_tables(schema: dict[str, Any], sql: str) -> dict[str, Any] | None:
+    used_tables = _sql_referenced_table_names(sql)
+    if not used_tables:
+        return None
+    tables = schema.get("tables", [])
+    if not isinstance(tables, list):
+        return None
+    matched_tables = []
+    for table in tables:
+        if not isinstance(table, dict):
+            continue
+        table_name = str(table.get("tableName") or table.get("name") or "").lower()
+        if table_name in used_tables:
+            matched_tables.append(table)
+    if not matched_tables:
+        return None
+    limited = dict(schema)
+    limited["tables"] = matched_tables
+    return limited
+
+
+def _sql_referenced_table_names(sql: str) -> set[str]:
+    normalized = _strip_sql_string_literals(sql)
+    names: set[str] = set()
+    for match in re.finditer(
+        r"\b(?:from|join)\s+([a-zA-Z_][a-zA-Z0-9_]*)\b",
+        normalized,
+        flags=re.IGNORECASE,
+    ):
+        names.add(match.group(1).lower())
+    return names
+
+
+def _strip_sql_string_literals(sql: str) -> str:
+    result: list[str] = []
+    quote: str | None = None
+    index = 0
+    while index < len(sql):
+        char = sql[index]
+        if quote is not None:
+            if char == quote:
+                quote = None
+            result.append(" ")
+            index += 1
+            continue
+        if char in ("'", '"'):
+            quote = char
+            result.append(" ")
+            index += 1
+            continue
+        result.append(char)
+        index += 1
+    return "".join(result)
 
 
 def _table_names(schema: dict[str, Any]) -> set[str]:
@@ -495,463 +2205,11 @@ def _table_columns(schema: dict[str, Any], table_name: str) -> list[dict[str, An
         if not isinstance(table, dict):
             continue
         name = table.get("name") or table.get("tableName")
-        if name == table_name and isinstance(table.get("columns"), list):
+        if str(name).lower() == str(table_name).lower() and isinstance(table.get("columns"), list):
             return [column for column in table["columns"] if isinstance(column, dict)]
     return []
 
 
-def _generate_recruiting_detail_sql(question: str, schema: dict[str, Any], default_limit: int) -> GeneratedSql:
-    table_names = _table_names(schema)
-    if "job_basic_info" not in table_names:
-        raise SqlGenerationError("job_basic_info is required for recruiting detail query")
-
-    select_items = _recruiting_detail_select_items(question, schema)
-    city_brand_filter = _extract_city_brand_filter(question)
-    location = _extract_location_for_recruiting_job_question(question)
-    brand_name = _extract_brand_name(question)
-    city_only_location = False
-    if city_brand_filter is not None:
-        location = city_brand_filter[0]
-        city_only_location = True
-        if brand_name is None:
-            brand_name = city_brand_filter[1]
-    location = location if location and _has_recruiting_location_tables(table_names) else None
-    brand_name = brand_name if brand_name and "brand" in table_names else None
-    from_and_where = _append_job_time_range_condition(
-        _recruiting_detail_from_and_where(table_names, location, brand_name, city_only_location),
-        question,
-        schema,
-    )
-    order_by = _job_order_by(question, schema)
-    sql = f"SELECT DISTINCT {', '.join(select_items)} {from_and_where} {order_by} LIMIT {default_limit}"
-    tables = [
-        table
-        for table in ("job_basic_info", "job_address", "job_store", "store", "province", "city", "region", "brand", "job_salary", "job_hiring_requirement")
-        if table in table_names
-    ]
-    return GeneratedSql(sql, tables, [])
-
-
-def _generate_work_order_detail_sql(question: str, schema: dict[str, Any], default_limit: int) -> GeneratedSql:
-    example = _find_work_order_detail_example(schema)
-    if example is None:
-        raise SqlGenerationError("Work order detail query requires a schema example")
-    brand_name = _extract_brand_name(question)
-    if brand_name is None:
-        raise SqlGenerationError("Work order detail query requires a brand name")
-    sql = str(example.get("sql") or "")
-    if not sql:
-        raise SqlGenerationError("Work order detail schema example has no SQL")
-    sql = re.sub(
-        r"b\.name\s*(?:=|LIKE)\s*'%?[^']*%?'",
-        f"b.name LIKE '%{_escape_sql_string(brand_name)}%'",
-        sql,
-        count=1,
-        flags=re.IGNORECASE,
-    )
-    tables = [str(table) for table in example.get("tables", []) if table]
-    return GeneratedSql(sql, tables, [])
-
-
-def _find_work_order_detail_example(schema: dict[str, Any]) -> dict[str, Any] | None:
-    examples = schema.get("examples", [])
-    if not isinstance(examples, list):
-        return None
-    for example in examples:
-        if not isinstance(example, dict):
-            continue
-        text = f"{example.get('question') or ''} {example.get('sql') or ''}"
-        if (
-            "mvp_applied_jobs_by_helped_account" in text
-            and "account_name" in text
-            and "work_order_status" in text
-            and "报名" in text
-            and "候选人状态" in text
-        ):
-            return example
-    return None
-
-
-def _generate_recruiting_supply_metric_sql(question: str, schema: dict[str, Any], default_limit: int) -> GeneratedSql:
-    table_names = _table_names(schema)
-    required = {"job_basic_info", "job_store", "store"}
-    if not required <= table_names:
-        raise SqlGenerationError("Recruiting supply metrics require job_basic_info, job_store and store")
-
-    select_items: list[str] = []
-    group_by: list[str] = []
-    joins = [
-        "FROM job_basic_info jbi",
-        "LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0",
-        "LEFT JOIN store s ON s.id = js.store_id AND s.delete_at IS NULL",
-    ]
-    tables = ["job_basic_info", "job_store", "store"]
-
-    if "品牌" in question and "brand" in table_names and _has_column(schema, "job_basic_info", "brand_id"):
-        joins.append("LEFT JOIN brand b ON b.id = jbi.brand_id")
-        select_items.extend(["b.id AS 品牌ID", "b.name AS 品牌名称"])
-        group_by.extend(["b.id", "b.name"])
-        tables.append("brand")
-    if "项目" in question and "sponge_project" in table_names and _has_column(schema, "job_basic_info", "organization_id"):
-        joins.append("LEFT JOIN sponge_project p ON p.id = jbi.organization_id")
-        select_items.extend(["p.id AS 项目ID", "p.name AS 项目名称"])
-        group_by.extend(["p.id", "p.name"])
-        tables.append("sponge_project")
-    if "城市" in question and "city" in table_names and _has_column(schema, "store", "city_id"):
-        joins.append("LEFT JOIN city c ON c.id = s.city_id")
-        select_items.extend(["c.id AS 城市ID", "c.name AS 城市名称"])
-        group_by.extend(["c.id", "c.name"])
-        tables.append("city")
-    if "区域" in question and "region" in table_names and _has_column(schema, "store", "region_id"):
-        joins.append("LEFT JOIN region r ON r.id = s.region_id")
-        select_items.extend(["r.id AS 区域ID", "r.name AS 区域名称"])
-        group_by.extend(["r.id", "r.name"])
-        tables.append("region")
-
-    if not select_items:
-        raise SqlGenerationError("Recruiting supply metric query requires at least one grouping dimension")
-    select_items.extend(
-        [
-            "COUNT(DISTINCT jbi.id) AS 在招岗位数",
-            "SUM(COALESCE(js.requirement_num, 0)) AS 招聘人数",
-            "COUNT(DISTINCT js.store_id) AS 招聘门店数",
-        ]
-    )
-    from_and_where = _append_job_time_range_condition(" ".join(joins) + " WHERE jbi.is_deleted = 0 AND jbi.status = 1", question, schema)
-    sql = (
-        f"SELECT {', '.join(select_items)} {from_and_where} "
-        f"GROUP BY {', '.join(group_by)} "
-        "ORDER BY 在招岗位数 DESC "
-        f"LIMIT {default_limit}"
-    )
-    return GeneratedSql(sql, list(dict.fromkeys(tables)), [])
-
-
-def _generate_monthly_recruiting_conversion_sql(question: str, schema: dict[str, Any], default_limit: int) -> GeneratedSql:
-    table_names = _table_names(schema)
-    required = {"mvp_applied_jobs_by_helped_account", "job_basic_info", "brand", "sponge_project"}
-    if not required <= table_names:
-        raise SqlGenerationError("Monthly recruiting conversion requires work order, job, brand and project tables")
-    year_bounds = _extract_year_bounds(question)
-    if year_bounds is None:
-        raise SqlGenerationError("Monthly recruiting conversion query requires a year range")
-    start, end = year_bounds
-    has_store = "store" in table_names
-    store_join = "LEFT JOIN store st ON st.id = wo.store_id AND st.delete_at IS NULL" if has_store else ""
-    brand_expr = "COALESCE(jbi.brand_id, st.brand_id)" if has_store else "jbi.brand_id"
-    project_expr = "COALESCE(jbi.organization_id, st.organization_id)" if has_store else "jbi.organization_id"
-    tables = ["mvp_applied_jobs_by_helped_account", "job_basic_info", "brand", "sponge_project"]
-    if has_store:
-        tables.append("store")
-
-    signup_sql = _monthly_conversion_event_sql(
-        start=start,
-        end=end,
-        date_field="wo.sign_up_time",
-        brand_expr=brand_expr,
-        project_expr=project_expr,
-        store_join=store_join,
-        signup_value=1,
-        onboard_value=0,
-        extra_condition="",
-    )
-    onboard_sql = _monthly_conversion_event_sql(
-        start=start,
-        end=end,
-        date_field="wo.on_work_time",
-        brand_expr=brand_expr,
-        project_expr=project_expr,
-        store_join=store_join,
-        signup_value=0,
-        onboard_value=1,
-        extra_condition="AND wo.on_work_status = 1",
-    )
-    sql = (
-        "SELECT monthly.月份 AS 月份, b.id AS 品牌ID, b.name AS 品牌名称, "
-        "p.id AS 项目ID, p.name AS 项目名称, "
-        "SUM(monthly.报名人数) AS 报名人数, "
-        "SUM(monthly.入职人数) AS 入职人数, "
-        "ROUND(SUM(monthly.入职人数) / NULLIF(SUM(monthly.报名人数), 0), 4) AS 报名转化率, "
-        "ROUND(SUM(monthly.入职人数) / NULLIF(SUM(monthly.报名人数), 0), 4) AS 入职转化率 "
-        f"FROM (({signup_sql}) UNION ALL ({onboard_sql})) monthly "
-        "LEFT JOIN brand b ON b.id = monthly.brand_id "
-        "LEFT JOIN sponge_project p ON p.id = monthly.project_id "
-        "GROUP BY monthly.月份, b.id, b.name, p.id, p.name "
-        "ORDER BY monthly.月份 ASC, 报名人数 DESC, 入职人数 DESC "
-        f"LIMIT {default_limit}"
-    )
-    return GeneratedSql(sql, tables, [])
-
-
-def _monthly_conversion_event_sql(
-    *,
-    start: str,
-    end: str,
-    date_field: str,
-    brand_expr: str,
-    project_expr: str,
-    store_join: str,
-    signup_value: int,
-    onboard_value: int,
-    extra_condition: str,
-) -> str:
-    return (
-        f"SELECT DATE_FORMAT({date_field}, '%Y-%m') AS 月份, "
-        f"{brand_expr} AS brand_id, {project_expr} AS project_id, "
-        f"COUNT(DISTINCT wo.id) * {signup_value} AS 报名人数, "
-        f"COUNT(DISTINCT wo.id) * {onboard_value} AS 入职人数 "
-        "FROM mvp_applied_jobs_by_helped_account wo "
-        "JOIN job_basic_info jbi ON jbi.job_id = wo.job_id AND jbi.is_deleted = 0 "
-        f"{store_join} "
-        f"WHERE wo.delete_at IS NULL AND {date_field} >= '{start}' AND {date_field} < '{end}' "
-        f"{extra_condition} "
-        f"GROUP BY DATE_FORMAT({date_field}, '%Y-%m'), {brand_expr}, {project_expr}"
-    )
-
-
-def _generate_recruiting_match_effect_sql(question: str, schema: dict[str, Any], default_limit: int) -> GeneratedSql:
-    table_names = _table_names(schema)
-    required = {
-        "job_basic_info",
-        "job_store",
-        "store",
-        "brand",
-        "sponge_project",
-        "city",
-        "mvp_applied_jobs_by_helped_account",
-    }
-    if not required <= table_names:
-        raise SqlGenerationError("Recruiting match effect requires job, store, brand, project, city and work order tables")
-
-    time_bounds = _extract_time_bounds(question)
-    if time_bounds is None:
-        raise SqlGenerationError("Recruiting match effect query requires a time range")
-    start, end = time_bounds
-    candidate_expr = "wo.c_helped_account_id"
-    signup_join = ""
-    signup_city = "st.city_id"
-    tables = [
-        "job_basic_info",
-        "job_store",
-        "store",
-        "brand",
-        "sponge_project",
-        "city",
-        "mvp_applied_jobs_by_helped_account",
-    ]
-    if "sign_up" in table_names:
-        signup_join = "LEFT JOIN sign_up su ON su.id = wo.sign_up_id AND su.delete_at IS NULL"
-        candidate_expr = "COALESCE(wo.c_helped_account_id, su.resume_id)"
-        signup_city = "COALESCE(st.city_id, su.city_id)"
-        tables.append("sign_up")
-
-    supply_dimension_sql = _match_effect_supply_dimension_sql(start, end)
-    match_dimension_sql = _match_effect_match_dimension_sql(start, end, signup_join, signup_city)
-    supply_metric_sql = _match_effect_supply_metric_sql(start, end)
-    match_metric_sql = _match_effect_match_metric_sql(start, end, signup_join, signup_city, candidate_expr)
-
-    sql = (
-        "SELECT b.id AS 品牌ID, b.name AS 品牌名称, p.id AS 项目ID, p.name AS 项目名称, "
-        "c.id AS 城市ID, c.name AS 城市名称, "
-        "COALESCE(supply.在招岗位数, 0) AS 在招岗位数, "
-        "COALESCE(supply.招聘人数, 0) AS 招聘人数, "
-        "COALESCE(supply.招聘门店数, 0) AS 招聘门店数, "
-        "COALESCE(match_data.报名人数, 0) AS 报名人数, "
-        "COALESCE(match_data.入职人数, 0) AS 入职人数, "
-        "COALESCE(match_data.候选人数, 0) AS 候选人数, "
-        "COALESCE(match_data.报名人数, 0) - COALESCE(match_data.入职人数, 0) AS 报名入职差, "
-        "ROUND(COALESCE(match_data.报名人数, 0) / NULLIF(COALESCE(supply.在招岗位数, 0), 0), 2) AS 岗位报名比, "
-        "ROUND(COALESCE(match_data.候选人数, 0) / NULLIF(COALESCE(supply.在招岗位数, 0), 0), 2) AS 候选岗位比, "
-        "COALESCE(NULLIF(CONCAT_WS('、', "
-        "IF(COALESCE(match_data.报名人数, 0) > COALESCE(match_data.入职人数, 0), '报名多但入职少', NULL), "
-        "IF(COALESCE(supply.在招岗位数, 0) > COALESCE(match_data.报名人数, 0), '在招多但报名少', NULL), "
-        "IF(COALESCE(match_data.候选人数, 0) > COALESCE(supply.在招岗位数, 0), '候选人多但岗位少', NULL)"
-        "), ''), '正常') AS 问题类型 "
-        f"FROM (({supply_dimension_sql}) UNION ({match_dimension_sql})) dimension_base "
-        "LEFT JOIN brand b ON b.id = dimension_base.brand_id "
-        "LEFT JOIN sponge_project p ON p.id = dimension_base.project_id "
-        "LEFT JOIN city c ON c.id = dimension_base.city_id "
-        f"LEFT JOIN ({supply_metric_sql}) supply ON supply.brand_id <=> dimension_base.brand_id "
-        "AND supply.project_id <=> dimension_base.project_id AND supply.city_id <=> dimension_base.city_id "
-        f"LEFT JOIN ({match_metric_sql}) match_data ON match_data.brand_id <=> dimension_base.brand_id "
-        "AND match_data.project_id <=> dimension_base.project_id AND match_data.city_id <=> dimension_base.city_id "
-        "WHERE COALESCE(match_data.报名人数, 0) > COALESCE(match_data.入职人数, 0) "
-        "OR COALESCE(supply.在招岗位数, 0) > COALESCE(match_data.报名人数, 0) "
-        "OR COALESCE(match_data.候选人数, 0) > COALESCE(supply.在招岗位数, 0) "
-        "ORDER BY 报名入职差 DESC, 在招岗位数 DESC, 候选岗位比 DESC "
-        f"LIMIT {default_limit}"
-    )
-    return GeneratedSql(sql, list(dict.fromkeys(tables)), [])
-
-
-def _match_effect_supply_dimension_sql(start: str, end: str) -> str:
-    return (
-        "SELECT jbi.brand_id AS brand_id, jbi.organization_id AS project_id, st.city_id AS city_id "
-        "FROM job_basic_info jbi "
-        "LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0 "
-        "LEFT JOIN store st ON st.id = js.store_id AND st.delete_at IS NULL "
-        "WHERE jbi.is_deleted = 0 AND jbi.status = 1 "
-        f"AND jbi.create_at >= '{start}' AND jbi.create_at < '{end}' "
-        "GROUP BY jbi.brand_id, jbi.organization_id, st.city_id"
-    )
-
-
-def _match_effect_match_dimension_sql(start: str, end: str, signup_join: str, signup_city: str) -> str:
-    return (
-        f"SELECT jbi.brand_id AS brand_id, jbi.organization_id AS project_id, {signup_city} AS city_id "
-        "FROM mvp_applied_jobs_by_helped_account wo "
-        "JOIN job_basic_info jbi ON jbi.job_id = wo.job_id AND jbi.is_deleted = 0 "
-        f"{signup_join} "
-        "LEFT JOIN store st ON st.id = wo.store_id AND st.delete_at IS NULL "
-        "WHERE wo.delete_at IS NULL AND ("
-        f"(wo.sign_up_time >= '{start}' AND wo.sign_up_time < '{end}') "
-        f"OR (wo.on_work_time >= '{start}' AND wo.on_work_time < '{end}')"
-        ") "
-        f"GROUP BY jbi.brand_id, jbi.organization_id, {signup_city}"
-    )
-
-
-def _match_effect_supply_metric_sql(start: str, end: str) -> str:
-    return (
-        "SELECT jbi.brand_id AS brand_id, jbi.organization_id AS project_id, st.city_id AS city_id, "
-        "COUNT(DISTINCT jbi.id) AS 在招岗位数, "
-        "SUM(COALESCE(js.requirement_num, 0)) AS 招聘人数, "
-        "COUNT(DISTINCT js.store_id) AS 招聘门店数 "
-        "FROM job_basic_info jbi "
-        "LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0 "
-        "LEFT JOIN store st ON st.id = js.store_id AND st.delete_at IS NULL "
-        "WHERE jbi.is_deleted = 0 AND jbi.status = 1 "
-        f"AND jbi.create_at >= '{start}' AND jbi.create_at < '{end}' "
-        "GROUP BY jbi.brand_id, jbi.organization_id, st.city_id"
-    )
-
-
-def _match_effect_match_metric_sql(
-    start: str,
-    end: str,
-    signup_join: str,
-    signup_city: str,
-    candidate_expr: str,
-) -> str:
-    return (
-        f"SELECT jbi.brand_id AS brand_id, jbi.organization_id AS project_id, {signup_city} AS city_id, "
-        f"COUNT(DISTINCT CASE WHEN wo.sign_up_time >= '{start}' AND wo.sign_up_time < '{end}' THEN wo.id END) AS 报名人数, "
-        "COUNT(DISTINCT CASE WHEN wo.on_work_status = 1 "
-        f"AND wo.on_work_time >= '{start}' AND wo.on_work_time < '{end}' THEN wo.id END) AS 入职人数, "
-        f"COUNT(DISTINCT CASE WHEN wo.sign_up_time >= '{start}' AND wo.sign_up_time < '{end}' THEN {candidate_expr} END) AS 候选人数 "
-        "FROM mvp_applied_jobs_by_helped_account wo "
-        "JOIN job_basic_info jbi ON jbi.job_id = wo.job_id AND jbi.is_deleted = 0 "
-        f"{signup_join} "
-        "LEFT JOIN store st ON st.id = wo.store_id AND st.delete_at IS NULL "
-        "WHERE wo.delete_at IS NULL AND ("
-        f"(wo.sign_up_time >= '{start}' AND wo.sign_up_time < '{end}') "
-        f"OR (wo.on_work_time >= '{start}' AND wo.on_work_time < '{end}')"
-        ") "
-        f"GROUP BY jbi.brand_id, jbi.organization_id, {signup_city}"
-    )
-
-
-def _recruiting_detail_from_and_where(
-    table_names: set[str],
-    location: str | None = None,
-    brand_name: str | None = None,
-    city_only_location: bool = False,
-) -> str:
-    parts = ["FROM job_basic_info jbi"]
-    if location is not None and "job_address" in table_names:
-        parts.append("LEFT JOIN job_address ja ON ja.job_id = jbi.job_id AND ja.delete_at IS NULL")
-    if "job_store" in table_names:
-        parts.append("LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0")
-    if {"job_store", "store"} <= table_names:
-        parts.append("LEFT JOIN store s ON s.id = js.store_id AND s.delete_at IS NULL")
-    if brand_name is not None and "brand" in table_names:
-        parts.append("LEFT JOIN brand b ON b.id = jbi.brand_id AND b.is_delete = 0")
-    if "job_salary" in table_names:
-        parts.append("LEFT JOIN job_salary jsa ON jsa.job_basic_info_id = jbi.id AND jsa.is_deleted = 0")
-    if "job_hiring_requirement" in table_names:
-        parts.append("LEFT JOIN job_hiring_requirement jhr ON jhr.job_basic_info_id = jbi.id AND jhr.is_deleted = 0")
-    where = "WHERE jbi.is_deleted = 0 AND jbi.status = 1"
-    if location is not None:
-        escaped_location = _escape_sql_string(location)
-        location_condition = (
-            _recruiting_city_condition(escaped_location)
-            if city_only_location
-            else _recruiting_location_condition(escaped_location)
-        )
-        where = f"{where} AND {location_condition}"
-    if brand_name is not None:
-        where = f"{where} AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
-    parts.append(where)
-    return " ".join(parts)
-
-
-def _recruiting_detail_select_items(question: str, schema: dict[str, Any]) -> list[str]:
-    items = [
-        "jbi.id AS 岗位ID",
-        "jbi.job_name AS 岗位名称",
-    ]
-    for item in (
-        _select_field_item(schema, "job_basic_info", "jbi", ("岗位类别", "岗位类型", "职能类别"), "岗位类型", ("job_type",)),
-        _select_field_item(schema, "job_store", "js", ("招聘人数",), "招聘人数", ("requirement_num",)),
-        _select_field_item(schema, "job_basic_info", "jbi", ("状态", "岗位状态"), "岗位状态", ("status",)),
-    ):
-        if item is not None:
-            items.append(item)
-    time_range = _extract_time_range(question, schema)
-    if time_range is not None:
-        items.append(f"jbi.{time_range.field} AS {time_range.alias}")
-    if "门店" in question:
-        for item in (
-            _select_field_item(schema, "store", "s", ("门店名称",), "门店名称", ("name",)),
-            _select_field_item(schema, "store", "s", ("门店地址", "详细地址", "精确地址"), "门店地址", ("address", "exact_address")),
-            _select_field_item(schema, "store", "s", ("门店ID",), "门店ID", ("id",)),
-        ):
-            if item is not None:
-                items.append(item)
-    if "薪资" in question:
-        for item in (
-            _select_field_item(schema, "job_salary", "jsa", ("最低综合薪资", "最低薪资", "薪资范围最低"), "最低薪资", ("min_comprehensive_salary",)),
-            _select_field_item(schema, "job_salary", "jsa", ("最高综合薪资", "最高薪资", "薪资范围最高"), "最高薪资", ("max_comprehensive_salary",)),
-            _select_field_item(schema, "job_salary", "jsa", ("薪资类型", "类型", "薪资结构"), "薪资类型", ("type", "salary_period")),
-        ):
-            if item is not None:
-                items.append(item)
-    if re.search(r"(用人要求|学历|经验|年龄|技能)", question):
-        for item in (
-            _select_field_item(schema, "job_hiring_requirement", "jhr", ("学历", "最低学历"), "学历要求", ("education_id",)),
-            _select_field_item(schema, "job_hiring_requirement", "jhr", ("最少工作时长", "工作经验", "工作年限"), "经验要求", ("min_work_time",)),
-            _select_age_requirement_item(schema),
-            _select_field_item(schema, "job_hiring_requirement", "jhr", ("软性技能", "技能要求"), "技能要求", ("soft_skill",)),
-        ):
-            if item is not None:
-                items.append(item)
-    if re.search(r"(岗位描述|工作内容|技能要求)", question):
-        item = _select_field_item(schema, "job_basic_info", "jbi", ("工作内容", "岗位描述"), "岗位描述", ("job_content",))
-        if item is not None:
-            items.append(item)
-    return list(dict.fromkeys(items))
-
-
-def _select_age_requirement_item(schema: dict[str, Any]) -> str | None:
-    if _has_column(schema, "job_hiring_requirement", "min_age") and _has_column(schema, "job_hiring_requirement", "max_age"):
-        return "CONCAT(jhr.min_age, '-', jhr.max_age) AS 年龄要求"
-    return _select_field_item(schema, "job_hiring_requirement", "jhr", ("年龄",), "年龄要求", ("min_age", "max_age"))
-
-
-def _select_field_item(
-    schema: dict[str, Any],
-    table_name: str,
-    table_alias: str,
-    terms: tuple[str, ...],
-    output_alias: str,
-    fallback_names: tuple[str, ...],
-) -> str | None:
-    column = _select_column(schema, table_name, terms, fallback_names)
-    if column is None:
-        return None
-    return f"{table_alias}.{column} AS {output_alias}"
-
-
 def _select_column(
     schema: dict[str, Any],
     table_name: str,
@@ -983,148 +2241,75 @@ def _has_column(schema: dict[str, Any], table_name: str, column_name: str) -> bo
     return any((column.get("columnName") or column.get("name")) == column_name for column in _table_columns(schema, table_name))
 
 
-def _has_recruiting_location_tables(table_names: set[str]) -> bool:
-    required = {"job_basic_info", "job_address", "job_store", "store", "province", "city", "region"}
-    return required <= table_names
-
-
-def _has_recruiting_tables(table_names: set[str]) -> bool:
-    return "job_basic_info" in table_names
-
-
-def _recruiting_from_and_where() -> str:
-    return "FROM job_basic_info jbi WHERE jbi.is_deleted = 0 AND jbi.status = 1"
-
-
-def _recruiting_location_from_and_where(location: str) -> str:
-    return (
-        "FROM job_basic_info jbi "
-        "LEFT JOIN job_address ja ON ja.job_id = jbi.job_id AND ja.delete_at IS NULL "
-        "LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0 "
-        "LEFT JOIN store s ON s.id = js.store_id AND s.delete_at IS NULL "
-        f"WHERE jbi.is_deleted = 0 AND jbi.status = 1 AND {_recruiting_location_condition(location)}"
-    )
-
-
-def _recruiting_location_condition(location: str) -> str:
-    return (
-        "("
-        "EXISTS ("
-        "SELECT 1 FROM province p JOIN city c ON c.province_id = p.id "
-        f"WHERE ({_province_name_matches(location)}) "
-        "AND (ja.city_id = c.id OR s.city_id = c.id OR FIND_IN_SET(c.id, jbi.city_ids) > 0)"
-        ") OR EXISTS ("
-        "SELECT 1 FROM city c "
-        f"WHERE ({_city_name_matches(location)}) "
-        "AND (ja.city_id = c.id OR s.city_id = c.id OR FIND_IN_SET(c.id, jbi.city_ids) > 0)"
-        ") OR EXISTS ("
-        "SELECT 1 FROM region r "
-        f"WHERE ({_region_name_matches(location)}) "
-        "AND (ja.region_id = r.id OR s.region_id = r.id)"
-        "))"
-    )
-
-
-def _recruiting_city_condition(location: str) -> str:
-    return (
-        "("
-        "EXISTS ("
-        "SELECT 1 FROM city c "
-        f"WHERE ({_city_name_matches(location)}) "
-        "AND (ja.city_id = c.id OR s.city_id = c.id OR FIND_IN_SET(c.id, jbi.city_ids) > 0)"
-        "))"
-    )
-
-
-def _append_job_time_range_condition(from_and_where: str, question: str, schema: dict[str, Any]) -> str:
-    time_range = _extract_time_range(question, schema)
-    if time_range is None:
-        return from_and_where
-    return (
-        f"{from_and_where} AND jbi.{time_range.field} >= '{time_range.start}' "
-        f"AND jbi.{time_range.field} < '{time_range.end}'"
-    )
-
-
-def _append_job_name_condition(from_and_where: str, question: str) -> str:
-    job_name = _extract_job_name_filter(question)
-    if job_name is None:
-        return from_and_where
-    return f"{from_and_where} AND jbi.job_name LIKE '%{_escape_sql_string(job_name)}%'"
-
-
-def _extract_time_range(question: str, schema: dict[str, Any] | None = None) -> TimeRange | None:
-    field = _resolve_job_time_field(question, schema or {})
-    if field is None:
-        return None
+def resolve_time_range_for_question(
+    question: str,
+    schema: dict[str, Any] | None = None,
+    *,
+    concepts: list[dict[str, Any]] | None = None,
+) -> TimeRange | None:
     bounds = _extract_time_bounds(question)
     if bounds is None:
         return None
-    return TimeRange(field=field.name, alias=field.alias, start=bounds[0], end=bounds[1])
-
-
-def _job_basic_select_items(question: str, schema: dict[str, Any]) -> str:
-    items = [
-        "jbi.id AS 岗位ID",
-        "jbi.job_name AS 岗位名称",
-        "jbi.job_content AS 工作内容",
-    ]
-    time_range = _extract_time_range(question, schema)
-    if time_range is not None:
-        items.append(f"jbi.{time_range.field} AS {time_range.alias}")
-    else:
-        items.append("jbi.publish_at AS 发布时间")
-    items.append("jbi.status AS 状态")
-    return ", ".join(items)
+    for concept in concepts or []:
+        qualified = str(concept.get("timeRangeField") or "").strip()
+        if "." not in qualified:
+            continue
+        table_name, field_name = qualified.rsplit(".", 1)
+        return TimeRange(
+            field=field_name,
+            alias="时间范围",
+            start=bounds[0],
+            end=bounds[1],
+            table_name=table_name,
+        )
+    field = _resolve_time_field(question, schema or {})
+    if field is None:
+        return None
+    return TimeRange(
+        field=field.name,
+        alias=field.alias,
+        start=bounds[0],
+        end=bounds[1],
+        table_name=field.table_name,
+    )
 
 
-def _job_order_by(question: str, schema: dict[str, Any]) -> str:
-    time_range = _extract_time_range(question, schema)
-    if time_range is not None:
-        direction = "ASC" if re.search(r"(正序|升序|从早到晚)", question) else "DESC"
-        return f"ORDER BY jbi.{time_range.field} {direction}"
-    return "ORDER BY jbi.publish_at DESC"
+def _extract_time_range(question: str, schema: dict[str, Any] | None = None) -> TimeRange | None:
+    return resolve_time_range_for_question(question, schema)
 
 
-def _resolve_job_time_field(question: str, schema: dict[str, Any]) -> FieldRef | None:
-    columns = _table_columns(schema, "job_basic_info")
+def _resolve_time_field(question: str, schema: dict[str, Any]) -> FieldRef | None:
     question_text = _normalize_semantic_text(question)
     best: tuple[int, FieldRef] | None = None
-    for column in columns:
-        name = str(column.get("columnName") or column.get("name") or "")
-        if not name:
-            continue
-        data_type = str(column.get("dataType") or column.get("type") or "")
-        comment = str(column.get("comment") or "")
-        if not _is_time_like_column(name, data_type, comment):
+    for table in schema.get("tables", []) if isinstance(schema.get("tables"), list) else []:
+        if not isinstance(table, dict):
             continue
-        score = _time_field_match_score(question_text, name, comment)
-        if score <= 0:
+        columns = table.get("columns")
+        if not isinstance(columns, list):
             continue
-        field_ref = FieldRef(name=name, alias=_column_alias(name, comment))
-        if best is None or score > best[0]:
-            best = (score, field_ref)
+        for column in columns:
+            if not isinstance(column, dict):
+                continue
+            name = str(column.get("columnName") or column.get("name") or "")
+            if not name:
+                continue
+            data_type = str(column.get("dataType") or column.get("type") or "")
+            comment = str(column.get("comment") or "")
+            if not _is_time_like_column(name, data_type, comment):
+                continue
+            score = _time_field_match_score(question_text, name, comment)
+            if score <= 0:
+                continue
+            table_name = str(table.get("tableName") or table.get("name") or "")
+            field_ref = FieldRef(
+                name=name,
+                alias=_column_alias(name, comment),
+                table_name=table_name,
+            )
+            if best is None or score > best[0]:
+                best = (score, field_ref)
     if best is not None:
         return best[1]
-    if _extract_time_bounds(question) is not None and re.search(r"(在招岗位数|岗位供给|招聘人数|招聘门店数|供给)", question):
-        created_column = _select_column(schema, "job_basic_info", ("创建时间",), ("create_at",))
-        if created_column is not None:
-            return FieldRef(created_column, _column_alias(created_column, "创建时间"))
-    fallback = _select_time_field(question)
-    if fallback is None:
-        return None
-    return fallback
-
-
-def _select_time_field(question: str) -> FieldRef | None:
-    if re.search(r"(发布|上架)", question):
-        return FieldRef("publish_at", "发布时间")
-    if re.search(r"(下架)", question):
-        return FieldRef("off_at", "下架时间")
-    if re.search(r"(更新|修改)", question):
-        return FieldRef("update_at", "更新时间")
-    if re.search(r"(创建|新建|新增)", question):
-        return FieldRef("create_at", "创建时间")
     return None
 
 
@@ -1139,9 +2324,6 @@ def _is_time_like_column(name: str, data_type: str, comment: str) -> bool:
 def _time_field_match_score(question_text: str, name: str, comment: str) -> int:
     field_text = _normalize_semantic_text(f"{name}{comment}")
     score = 0
-    for term in ("创建", "发布", "下架", "更新"):
-        if term in question_text and term in field_text:
-            score += 100
     comment_text = _normalize_semantic_text(comment)
     if comment_text and comment_text in question_text:
         score += 50
@@ -1150,23 +2332,18 @@ def _time_field_match_score(question_text: str, name: str, comment: str) -> int:
         score += 30
     if "时间" in question_text and "时间" in field_text:
         score += 5
+    if "日期" in question_text and ("时间" in field_text or "日期" in field_text):
+        score += 5
+    if "报名" in question_text and "报名" in comment_text:
+        score += 40
+    if re.search(r"(上架|发布|新上架)", question_text):
+        if "publish" in name.lower() or "发布" in comment_text:
+            score += 40
     return score
 
 
 def _normalize_semantic_text(text: str) -> str:
     normalized = text.lower()
-    replacements = {
-        "新建": "创建",
-        "新增": "创建",
-        "录入": "创建",
-        "生成": "创建",
-        "上架": "发布",
-        "上线": "发布",
-        "修改": "更新",
-        "下线": "下架",
-    }
-    for source, target in replacements.items():
-        normalized = normalized.replace(source, target)
     return re.sub(r"[^0-9a-z\u4e00-\u9fff]+", "", normalized)
 
 
@@ -1174,24 +2351,73 @@ def _column_alias(name: str, comment: str) -> str:
     cleaned = re.sub(r"[。；;，,\s].*$", "", comment.strip())
     if cleaned:
         return cleaned
-    fallback_aliases = {
-        "create_at": "创建时间",
-        "publish_at": "发布时间",
-        "off_at": "下架时间",
-        "update_at": "更新时间",
-    }
-    return fallback_aliases.get(name, name)
+    return name
+
+
+def _normalize_fullwidth_digits(text: str) -> str:
+    return text.translate(str.maketrans("０１２３４５６７８９", "0123456789"))
 
 
 def _extract_time_bounds(question: str) -> tuple[str, str] | None:
+    question = _normalize_fullwidth_digits(question)
     date_range = _extract_explicit_date_range(question)
     if date_range is not None:
         return date_range
+    if re.search(r"(近|最近|过去)\s*(?:1|一)\s*年", question):
+        today = _today()
+        return _format_datetime(_one_year_before(today)), _format_datetime(today + timedelta(days=1))
+    if re.search(r"(今天|今日)", question):
+        today = _today()
+        return _format_datetime(today), _format_datetime(today + timedelta(days=1))
+    if re.search(r"(昨天|昨日)", question):
+        today = _today()
+        yesterday = today - timedelta(days=1)
+        return _format_datetime(yesterday), _format_datetime(today)
     relative_month_match = re.search(r"(?P<relative_year>今年|去年|前年|明年|后年)\s*(?P<month>\d{1,2})\s*月(?:份)?", question)
     if relative_month_match is not None:
         year = _today().year + _relative_year_offset(relative_month_match.group("relative_year"))
         month = int(relative_month_match.group("month"))
         return _month_bounds(year, month)
+    if not re.search(r"20\d{2}\s*年", question):
+        cn_day_range = re.search(
+            r"(?P<month>\d{1,2})\s*月\s*(?P<start_day>\d{1,2})\s*日?\s*"
+            r"(?:到|至|~|～|-)\s*"
+            r"(?:(?P<end_month>\d{1,2})\s*月\s*)?(?P<end_day>\d{1,2})\s*日?",
+            question,
+        )
+        if cn_day_range is not None:
+            year = _today().year
+            month = int(cn_day_range.group("month"))
+            end_month_text = cn_day_range.group("end_month")
+            end_month = int(end_month_text) if end_month_text else month
+            if end_month != month:
+                return None
+            start_day = int(cn_day_range.group("start_day"))
+            end_day = int(cn_day_range.group("end_day"))
+            try:
+                start = date(year, month, start_day)
+                end = date(year, month, end_day)
+            except ValueError:
+                return None
+            if end >= start:
+                return _format_datetime(start), _format_datetime(end + timedelta(days=1))
+        single_cn_day = re.search(r"(?P<month>\d{1,2})\s*月\s*(?P<day>\d{1,2})\s*日", question)
+        if single_cn_day is not None and not re.search(r"(到|至|~|～|-)", question):
+            year = _today().year
+            try:
+                day = date(year, int(single_cn_day.group("month")), int(single_cn_day.group("day")))
+            except ValueError:
+                day = None
+            if day is not None:
+                return _format_datetime(day), _format_datetime(day + timedelta(days=1))
+        cn_month_only = re.search(
+            r"(?:整个|整)\s*(?P<month>\d{1,2})\s*月(?:份)?|(?P<month_only>\d{1,2})\s*月(?:份)?(?!\s*\d{1,2}\s*日)",
+            question,
+        )
+        if cn_month_only is not None:
+            month_text = cn_month_only.group("month") or cn_month_only.group("month_only")
+            if month_text is not None:
+                return _month_bounds(_today().year, int(month_text))
     month_match = re.search(r"(?P<year>20\d{2})\s*年\s*(?P<month>\d{1,2})\s*月(?:份)?", question)
     if month_match is None:
         month_match = re.search(r"(?P<year>20\d{2})[-/](?P<month>\d{1,2})(?![-/]\d)", question)
@@ -1202,23 +2428,6 @@ def _extract_time_bounds(question: str) -> tuple[str, str] | None:
     return _month_bounds(year, month)
 
 
-def _extract_year_bounds(question: str) -> tuple[str, str] | None:
-    relative_year_match = re.search(r"(?P<relative_year>今年|去年|前年|明年|后年)(?:全年|年内|全年内)?", question)
-    if relative_year_match is not None:
-        year = _today().year + _relative_year_offset(relative_year_match.group("relative_year"))
-        return _year_bounds(year)
-    if re.search(r"(全年|年内|全年内)", question):
-        return _year_bounds(_today().year)
-    year_match = re.search(r"(?P<year>20\d{2})\s*年(?:全年|年内|全年内)?", question)
-    if year_match is None:
-        return None
-    return _year_bounds(int(year_match.group("year")))
-
-
-def _year_bounds(year: int) -> tuple[str, str]:
-    return _format_datetime(date(year, 1, 1)), _format_datetime(date(year + 1, 1, 1))
-
-
 def _relative_year_offset(relative_year: str) -> int:
     offsets = {
         "今年": 0,
@@ -1230,6 +2439,13 @@ def _relative_year_offset(relative_year: str) -> int:
     return offsets[relative_year]
 
 
+def _one_year_before(value: date) -> date:
+    try:
+        return value.replace(year=value.year - 1)
+    except ValueError:
+        return value.replace(year=value.year - 1, day=28)
+
+
 def _month_bounds(year: int, month: int) -> tuple[str, str] | None:
     if not 1 <= month <= 12:
         return None
@@ -1271,374 +2487,20 @@ def _today() -> date:
     return date.today()
 
 
-def _extract_location_for_recruiting_job_question(question: str) -> str | None:
-    if not _is_recruiting_job_question(question):
-        return None
-    text = re.sub(r"(查询|查看|看看|列出|给我|帮我查|当前|目前|现在)", "", question)
-    text = re.sub(r"(所有|全部|每个|各个)", "", text)
-    patterns = [
-        r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:有)?(?:多少|几|数量|总数).*?(?:在招|招聘)(?:岗位|职位)",
-        r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:在招|招聘)(?:岗位|职位)",
-        r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:有|有哪些|有什么).*?(?:在招|招聘)(?:岗位|职位)",
-        r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:岗位|职位)",
-        r"(?:在|位于)(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:岗位|职位)",
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, text)
-        if match is not None:
-            return _clean_location_candidate(match.group("location"), require_location_signal=True)
-    return None
-
-
-def _is_recruiting_job_question(question: str) -> bool:
-    return bool(re.search(r"(岗位|职位|招聘|在招)", question))
-
-
-def _is_recruiting_remaining_signup_query(question: str) -> bool:
-    return bool("岗位" in question and "报名" in question and re.search(r"(剩余|还剩|余量|可报名)", question))
-
-
-def _is_work_order_detail_query(question: str) -> bool:
-    return bool(
-        "品牌" in question
-        and re.search(r"(报名|工单)", question)
-        and re.search(r"(候选人状态|候选人|面试成功)", question)
-        and re.search(r"(姓名|名字|岗位|职位|项目)", question)
-    )
-
-
-def _is_entity_lookup_query(question: str, entity: str) -> bool:
-    if _is_business_query(question):
-        return False
-    if entity == "品牌" and _extract_brand_filter(question) is not None:
-        return True
-    if entity == "项目" and _extract_project_name(question) is not None:
-        return True
-    if re.search(r"(列表|清单|信息|有哪些|哪些|我能看到|可见|能看到|查询.*(?:品牌|项目)|查看.*(?:品牌|项目))", question):
-        return True
-    return bool(re.fullmatch(rf"\s*(?:查询|查看|列出)?\s*{entity}\s*", question))
-
-
 def _is_business_query(question: str) -> bool:
     return bool(
         re.search(
-            r"(报名|工单|候选人|入职|上岗|在招|招聘|岗位|职位|门店|剩余|转化|漏斗|匹配|统计|多少|几|数量|总数|人数|数)",
-            question,
-        )
-    )
-
-
-def _is_single_entity_lookup_sql(sql: str) -> bool:
-    normalized = re.sub(r"\s+", " ", sql.strip().lower())
-    table_aliases = _sql_table_aliases(normalized)
-    referenced_tables = set(table_aliases.values())
-    entity_tables = {"brand", "sponge_project", "city", "province", "region", "store"}
-    if len(referenced_tables) != 1 or not referenced_tables <= entity_tables:
-        return False
-    if " limit " not in f" {normalized} ":
-        return False
-    return bool(re.search(r"\b(?:id|name|job_name)\b", normalized))
-
-
-_ENTITY_NAME_CHARS = r"[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40}"
-_ENTITY_SEPARATOR = r"[\s:：,，、;；]+"
-_DIRECT_MUNICIPALITIES = ("上海", "北京", "天津", "重庆")
-
-
-def _extract_city_brand_filter(question: str) -> tuple[str, str] | None:
-    if not _is_recruiting_job_question(question):
-        return None
-    text = re.sub(r"(根据|我要|海绵数据|帮我查询|帮我查|帮我|查询|查看|看看|当前|目前|现在|，|,|。|\s)", "", question)
-    patterns = [
-        r"(?P<city>[\u4e00-\u9fff]{2,8}?(?:省|市|区|县))(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40}?)(?:当前|目前|现在)?(?:在招|招聘)(?:岗位|职位)",
-        rf"(?P<city>{'|'.join(_DIRECT_MUNICIPALITIES)})(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{{1,40}}?)(?:当前|目前|现在)?(?:在招|招聘)(?:岗位|职位)",
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, text)
-        if match is None:
-            continue
-        location = _clean_location_candidate(match.group("city"), require_location_signal=True)
-        brand = _clean_brand_candidate(match.group("brand"))
-        if location is not None and brand is not None:
-            return location, brand
-    return None
-
-
-def _extract_brand_filter(question: str) -> tuple[str, str] | None:
-    contains_patterns = [
-        r"品牌(?:名称)?(?:包含|含有|模糊匹配|like)(?P<brand>.+?)(?:，|,|。|；|;|的品牌|品牌信息|包括|返回|$)",
-        r"(?:name|名称)\s+LIKE\s+[\"'“”‘’%]*(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40})",
-    ]
-    for pattern in contains_patterns:
-        match = re.search(pattern, question, flags=re.IGNORECASE)
-        if match is None:
-            continue
-        brand = _clean_brand_candidate(match.group("brand"))
-        if brand is not None:
-            return "contains", brand
-
-    exact_patterns = [
-        rf"品牌(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<brand>{_ENTITY_NAME_CHARS})",
-        rf"品牌{_ENTITY_SEPARATOR}(?P<brand>{_ENTITY_NAME_CHARS})",
-        rf"(?P<brand>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?品牌(?:下|的)?",
-    ]
-    for pattern in exact_patterns:
-        match = re.search(pattern, question)
-        if match is None:
-            continue
-        brand = _clean_brand_candidate(match.group("brand"))
-        if brand is not None:
-            return "exact", brand
-    return None
-
-
-def _extract_brand_name(question: str) -> str | None:
-    brand_filter = _extract_brand_filter(question)
-    return brand_filter[1] if brand_filter is not None else None
-
-
-def _extract_project_name(question: str) -> str | None:
-    patterns = [
-        r"项目(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|项目信息|包括|返回|$)",
-        rf"项目(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
-        rf"项目{_ENTITY_SEPARATOR}(?P<name>{_ENTITY_NAME_CHARS})",
-        rf"(?P<name>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?项目(?:下|的)?",
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, question, flags=re.IGNORECASE)
-        if match is None:
-            continue
-        project = _clean_entity_candidate(match.group("name"), extra_forbidden=("品牌", "岗位", "职位", "报名"))
-        if project is not None:
-            return project
-    return None
-
-
-def _extract_job_name_filter(question: str) -> str | None:
-    patterns = [
-        r"(?:岗位|职位)(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|岗位信息|职位信息|包括|返回|$)",
-        rf"(?:岗位|职位)(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
-        rf"(?:招聘|在招|招|急招)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})(?:岗位|职位)",
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, question, flags=re.IGNORECASE)
-        if match is None:
-            continue
-        job_name = _clean_entity_candidate(match.group("name"), extra_forbidden=("品牌", "项目", "门店", "报名"))
-        if job_name is not None:
-            return job_name
-    return None
-
-
-def _clean_brand_candidate(value: str) -> str | None:
-    return _clean_entity_candidate(
-        value,
-        extra_forbidden=("岗位", "候选人", "报名", "入职", "在招", "招聘", "数量", "多少"),
-        suffix_pattern=r"(的品牌信息|品牌信息|的品牌|品牌|的|下)$",
-    )
-
-
-def _clean_entity_candidate(
-    value: str,
-    *,
-    extra_forbidden: tuple[str, ...] = (),
-    suffix_pattern: str = r"(的|下)$",
-) -> str | None:
-    brand = re.sub(r"\s+", "", value)
-    brand = brand.strip("\"'“”‘’%:：,，、;；")
-    brand = re.sub(r"^(名称为|名称是|为|是|=|等于)", "", brand)
-    brand = re.sub(suffix_pattern, "", brand)
-    brand = brand.strip("\"'“”‘’%:：,，、;；")
-    forbidden = ("查询", "查看", "给我", "帮我", "根据", "roll-core", "信息", "数据") + extra_forbidden
-    if 2 <= len(brand) <= 40 and not any(term in brand for term in forbidden):
-        return brand
-    return None
-
-
-def _sql_references_brand_table(sql: str) -> bool:
-    return _sql_references_table(sql, "brand")
-
-
-def _sql_contains_brand_name_filter(sql: str, brand_name: str) -> bool:
-    return _sql_contains_name_filter(sql, brand_name)
-
-
-def _sql_references_table(sql: str, table_name: str) -> bool:
-    return table_name in _sql_table_aliases(sql.lower()).values()
-
-
-def _sql_contains_name_filter(sql: str, name: str) -> bool:
-    normalized = sql.lower()
-    escaped = re.escape(_escape_sql_string(name).lower())
-    return bool(
-        re.search(rf"\b[a-zA-Z_][a-zA-Z0-9_]*\.name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
-        or re.search(rf"\bname\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
-    )
-
-
-def _sql_contains_job_name_filter(sql: str, job_name: str) -> bool:
-    normalized = sql.lower()
-    escaped = re.escape(_escape_sql_string(job_name).lower())
-    return bool(
-        re.search(rf"\bjbi\.job_name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
-        or re.search(rf"\bjob_name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
-    )
-
-
-def _is_monthly_recruiting_conversion_query(question: str) -> bool:
-    return bool(
-        re.search(r"(全年|年内|每月|月度)", question)
-        and re.search(r"(报名人数|报名数)", question)
-        and re.search(r"(入职人数|入职数|上岗人数|上岗数)", question)
-        and re.search(r"(转化率|转化)", question)
-        and "品牌" in question
-        and "项目" in question
-    )
-
-
-def is_recruiting_match_effect_query(question: str) -> bool:
-    return bool(
-        "岗位" in question
-        and re.search(r"(候选人|报名|入职|上岗)", question)
-        and re.search(r"(匹配效果|报名多|入职少|在招多|报名少|候选人多|岗位少)", question)
-        and re.search(r"(品牌|项目|城市)", question)
-    )
-
-
-def _is_recruiting_supply_multi_metric_query(question: str) -> bool:
-    return bool(
-        _is_multi_metric_query(question)
-        and re.search(r"(在招岗位数|岗位供给|招聘人数|招聘门店数)", question)
-        and re.search(r"(品牌|项目|城市|区域)", question)
-    )
-
-
-def _is_multi_metric_query(question: str) -> bool:
-    metric_terms = (
-        "岗位供给数量",
-        "候选人供给数量",
-        "报名人数",
-        "入职人数",
-        "报名转化率",
-        "入职转化率",
-        "在招岗位数",
-        "招聘人数",
-        "招聘门店数",
-    )
-    dimension_terms = ("品牌", "项目", "城市", "区域")
-    metric_count = sum(1 for term in metric_terms if term in question)
-    dimension_count = sum(1 for term in dimension_terms if term in question)
-    has_list_separator = bool(re.search(r"[、,，]", question))
-    return (metric_count >= 2) or (metric_count >= 1 and dimension_count >= 2 and has_list_separator)
-
-
-def _requires_recruiting_detail_joins(question: str) -> bool:
-    if re.search(r"(明细|详情|信息|包含|需要|显示|带上|返回|字段)", question) is None:
-        return False
-    return bool(
-        re.search(
-            r"(门店|门店地址|详细地址|精确地址|地址|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
+            r"(查询|查看|看看|搜索|统计|多少|几|哪些|有哪些|列表|明细|清单|展示|返回|输出|分析|报告|count|sum|avg|min|max)",
             question,
+            flags=re.IGNORECASE,
         )
     )
 
 
-def _question_requests_count(question: str) -> bool:
-    if re.search(r"(每个|各个|分别|列表|明细|详情|有哪些|有什么|剩余|还剩|所有.*(?:岗位|职位)|全部.*(?:岗位|职位))", question):
-        return False
-    return bool(re.search(r"(多少|几|数量|总数|count|统计)", question, flags=re.IGNORECASE))
-
-
-def _clean_location_candidate(candidate: str, *, require_location_signal: bool = False) -> str | None:
-    cleaned = re.sub(r"[，,。；;？?\s]", "", candidate)
-    cleaned = re.sub(r"(有哪些|有什么|所有|全部|每个|各个|多少|数量|列表|明细|信息|数据|情况|都|的|有)$", "", cleaned)
-    if not 2 <= len(cleaned) <= 12:
-        return None
-    if re.search(r"[\u4e00-\u9fff]", cleaned) is None:
-        return None
-    if re.search(r"(岗位|职位|招聘|在招|品牌|项目|查询|查看|当前|目前|现在)", cleaned):
-        return None
-    if _is_generic_recruiting_term(cleaned):
-        return None
-    if require_location_signal and not _has_location_signal(cleaned):
-        return None
-    return cleaned
-
-
-def _has_location_signal(candidate: str) -> bool:
-    if re.search(r"(省|市|区|县|镇|乡|街道|路|街|大道|广场|商圈|附近|地铁|站|商场|门店)$", candidate):
-        return True
-    return 2 <= len(candidate) <= 4 and not _is_generic_recruiting_term(candidate)
-
-
-def _is_generic_recruiting_term(candidate: str) -> bool:
-    generic_terms = {
-        "兼职",
-        "全职",
-        "小时工",
-        "暑假工",
-        "寒假工",
-        "长期工",
-        "短期工",
-        "服务员",
-        "店员",
-        "骑手",
-        "厨师",
-        "收银员",
-        "营业员",
-        "理货员",
-        "分拣",
-        "补货",
-        "打包",
-        "餐厅",
-        "门店",
-        "品牌",
-        "项目",
-        "高薪",
-        "急招",
-        "最新",
-        "全部",
-        "所有",
-        "热门",
-        "附近",
-        "本周",
-        "今天",
-        "明天",
-    }
-    return candidate in generic_terms
-
-
 def _escape_sql_string(value: str) -> str:
     return value.replace("\\", "\\\\").replace("'", "''")
 
 
-def _province_name_matches(location: str) -> str:
-    literal = f"'{location}'"
-    return (
-        f"p.name LIKE '%{location}%' OR "
-        "REPLACE(REPLACE(REPLACE(REPLACE(p.name, '特别行政区', ''), '自治区', ''), '省', ''), '市', '') = "
-        f"REPLACE(REPLACE(REPLACE(REPLACE({literal}, '特别行政区', ''), '自治区', ''), '省', ''), '市', '')"
-    )
-
-
-def _city_name_matches(location: str) -> str:
-    literal = f"'{location}'"
-    return (
-        f"c.name LIKE '%{location}%' OR "
-        "REPLACE(REPLACE(REPLACE(c.name, '自治州', ''), '地区', ''), '市', '') = "
-        f"REPLACE(REPLACE(REPLACE({literal}, '自治州', ''), '地区', ''), '市', '')"
-    )
-
-
-def _region_name_matches(location: str) -> str:
-    literal = f"'{location}'"
-    return (
-        f"r.name LIKE '%{location}%' OR "
-        "REPLACE(REPLACE(REPLACE(r.name, '自治县', ''), '区', ''), '县', '') = "
-        f"REPLACE(REPLACE(REPLACE({literal}, '自治县', ''), '区', ''), '县', '')"
-    )
-
-
 def _enforce_chinese_select_aliases(sql: str) -> None:
     select_list = _top_level_select_list(sql)
     if select_list is None:
@@ -1648,7 +2510,7 @@ def _enforce_chinese_select_aliases(sql: str) -> None:
         if not cleaned:
             continue
         alias_match = re.search(
-            r"\s+as\s+(`[^`]+`|\"[^\"]+\"|'[^']+'|[\u4e00-\u9fff][\w\u4e00-\u9fff]*)\s*$",
+            _SELECT_AS_ALIAS_PATTERN,
             cleaned,
             flags=re.IGNORECASE,
         )
@@ -1671,7 +2533,7 @@ def _enforce_no_null_placeholder_select_items(sql: str) -> None:
 
 def _select_expression_without_alias(item: str) -> str:
     return re.sub(
-        r"\s+as\s+(`[^`]+`|\"[^\"]+\"|'[^']+'|[\u4e00-\u9fff][\w\u4e00-\u9fff]*)\s*$",
+        _SELECT_AS_ALIAS_PATTERN,
         "",
         item.strip(),
         flags=re.IGNORECASE,