@roll-agent/octopus-agent 0.0.10 → 0.0.11

package/src/octopus_skill/sql_generator.py

@@ -40,109 +40,10 @@ 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"], [])
-
-        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")
-
-        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"],
-                [],
-            )
-
-        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")
+@dataclass(frozen=True)
+class LowQualitySqlIssue:
+    code: str
+    message: str
 
 
 def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
@@ -282,16 +183,40 @@ def _select_item_contains_sensitive_field(item: str) -> bool:
     return False
 
 
+_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 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 _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 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()
+    for match in _TEXT_EQUALITY_FILTER_RE.finditer(sql):
+        column = match.group("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)):
+        if _should_normalize_text_filter_to_like(column, value):
             raise SqlGenerationError("SQL text filters must use LIKE")
 
 
@@ -307,31 +232,330 @@ 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) -> bool:
+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:
     normalized = re.sub(r"\s+", " ", sql.strip().lower())
     if _is_business_query(question) and _is_single_entity_lookup_sql(sql):
-        return True
+        return LowQualitySqlIssue(
+            code="BUSINESS_QUERY_SINGLE_ENTITY_LOOKUP",
+            message="本次查询未执行：这是业务数据查询，但生成的 SQL 退化成了品牌、项目、城市、门店或岗位的单表列表，不能回答当前问题。",
+        )
+    if _job_status_filter_mismatches_question(question, sql, schema):
+        return LowQualitySqlIssue(
+            code="JOB_STATUS_ENUM_MISMATCH",
+            message="本次查询未执行：你问的是岗位状态相关数据，但生成的 SQL 没有使用 schema 枚举中对应的岗位状态值，可能把未发布、已发布、已下架等状态混在一起。",
+        )
+    if _plain_job_total_question_has_unrequested_status_filter(question, sql):
+        return LowQualitySqlIssue(
+            code="JOB_TOTAL_SHOULD_NOT_FILTER_STATUS",
+            message="本次查询未执行：你问的是岗位总数，但生成的 SQL 加了岗位状态过滤，会把全部岗位总数误算成特定状态的岗位数量。",
+        )
+    if _generic_job_count_sql_mismatches_question(question, sql, schema):
+        return LowQualitySqlIssue(
+            code="JOB_COUNT_ALIAS_MISMATCH",
+            message="本次查询未执行：你问的是岗位总数，但生成的 SQL 输出字段是“在招岗位数/已发布岗位数”等状态口径，指标名称和查询口径不一致。",
+        )
     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
+        return LowQualitySqlIssue(
+            code="MISSING_BRAND_FILTER",
+            message=f"本次查询未执行：你明确指定了品牌“{brand_filter[1]}”，但生成的 SQL 没有按该品牌名称过滤。",
+        )
     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):
-        return True
+    if (
+        project_name is not None
+        and _sql_references_table(sql, "sponge_project")
+        and not _sql_contains_name_filter(sql, project_name)
+        and not _sql_contains_project_id_filter(sql)
+    ):
+        return LowQualitySqlIssue(
+            code="MISSING_PROJECT_FILTER",
+            message=f"本次查询未执行：你明确指定了项目“{project_name}”，但生成的 SQL 没有按该项目名称过滤。",
+        )
     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):
-        return True
+        return LowQualitySqlIssue(
+            code="MISSING_JOB_NAME_FILTER",
+            message=f"本次查询未执行：你明确指定了岗位“{job_name}”，但生成的 SQL 没有按该岗位名称过滤。",
+        )
+    store_name = _extract_store_name_filter(question)
+    if store_name is not None and _sql_references_table(sql, "store") and not _sql_contains_store_name_filter(sql, store_name):
+        return LowQualitySqlIssue(
+            code="MISSING_STORE_FILTER",
+            message=f"本次查询未执行：你明确指定了门店“{store_name}”，但生成的 SQL 没有按该门店名称过滤。",
+        )
     if _is_work_order_detail_query(question):
         if "mvp_applied_jobs_by_helped_account" not in normalized:
-            return True
+            return LowQualitySqlIssue(
+                code="MISSING_WORK_ORDER_TABLE",
+                message="本次查询未执行：你问的是报名/工单明细，但生成的 SQL 没有使用报名工单表。",
+            )
         if re.search(r"\bfrom\s+brand\b", normalized) and "mvp_applied_jobs_by_helped_account" not in normalized:
-            return True
+            return LowQualitySqlIssue(
+                code="WORK_ORDER_QUERY_BRAND_ONLY",
+                message="本次查询未执行：你问的是报名/工单明细，但生成的 SQL 只查询了品牌列表。",
+            )
         if _has_work_order_job_id_to_job_pk_join(normalized):
-            return True
+            return LowQualitySqlIssue(
+                code="WORK_ORDER_JOB_JOIN_MISMATCH",
+                message="本次查询未执行：报名工单和岗位表的关联方式不符合当前 schema 声明。",
+            )
         if "面试成功" in question and "interview_pass_status" in normalized:
-            return True
+            return LowQualitySqlIssue(
+                code="INTERVIEW_STATUS_FIELD_MISMATCH",
+                message="本次查询未执行：你问的是候选人面试成功状态，但生成的 SQL 使用了不符合当前口径的面试状态字段。",
+            )
+    return None
+
+
+def _job_status_filter_mismatches_question(question: str, sql: str, schema: dict[str, Any] | None) -> bool:
+    requested_values = _requested_job_status_values(question, schema)
+    if requested_values is None:
+        return False
+    table_aliases = _sql_table_aliases(sql)
+    job_aliases = {alias for alias, table in table_aliases.items() if table == "job_basic_info"}
+    if not job_aliases:
+        return False
+    actual_values = _sql_status_filter_values(sql, job_aliases)
+    if actual_values is None:
+        return True
+    return actual_values != requested_values
+
+
+def _plain_job_total_question_has_unrequested_status_filter(question: str, sql: str) -> bool:
+    if not _is_job_count_intent_question(question):
+        return False
+    if _user_requests_recruiting_job_count(question):
+        return False
+    if re.search(r"(未发布|已下架|状态包括|状态为|岗位状态)", question):
+        return False
+    table_aliases = _sql_table_aliases(sql)
+    job_aliases = {alias for alias, table in table_aliases.items() if table == "job_basic_info"}
+    if not job_aliases:
+        return False
+    return _sql_status_filter_values(sql, job_aliases) is not None
+
+
+def _is_job_count_intent_question(question: str) -> bool:
+    if re.search(
+        r"(岗位|职位).{0,8}(总数|数量|数)|(?:总数|数量|多少|几个).{0,8}(岗位|职位)",
+        question,
+    ):
+        return True
+    if re.search(r"(?:查|查询|统计|看).{0,6}总数", question):
+        return True
+    return bool(re.fullmatch(r"(?:查询|统计)?总数", question.strip()))
+
+
+def _user_requests_recruiting_job_count(question: str, schema: dict[str, Any] | None = None) -> bool:
+    if re.search(r"在招岗位数|在招|已发布|已上架", question):
+        return True
+    requested_values = _requested_job_status_values(question, schema)
+    if requested_values is None:
+        return False
+    if schema is None:
+        return True
+    status_enum = _status_enum(schema, "job_basic_info.status")
+    if not status_enum:
+        return True
+    recruiting_values: set[str] = set()
+    for item in status_enum:
+        value = item.get("value")
+        labels = _enum_label_terms(str(item.get("label") or ""))
+        if value is None:
+            continue
+        if any(label in {"在招", "已发布", "已上架"} or "在招" in label for label in labels):
+            recruiting_values.add(str(value))
+    return bool(requested_values & recruiting_values)
+
+
+def _preferred_count_alias(question: str) -> str | None:
+    if not _is_job_count_intent_question(question):
+        return None
+    if "在招岗位数" in question:
+        return "在招岗位数"
+    if re.search(r"岗位总数", question):
+        return "岗位总数"
+    if re.search(r"职位总数", question):
+        return "职位总数"
+    if re.search(r"岗位数", question):
+        return "岗位数"
+    if re.search(r"职位数", question):
+        return "职位数"
+    if "总数" in question:
+        return "总数"
+    if re.search(r"(岗位|职位).{0,8}(总数|数量|数)|(?:总数|数量|多少|几个).{0,8}(岗位|职位)", question):
+        return "岗位总数"
+    return None
+
+
+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 _generic_job_count_sql_mismatches_question(
+    question: str,
+    sql: str,
+    schema: dict[str, Any] | None,
+) -> bool:
+    if not _is_job_count_intent_question(question) or not _sql_counts_job_basic_info(sql):
+        return False
+    preferred_alias = _preferred_count_alias(question)
+    aliases = _sql_select_metric_aliases(sql)
+    if preferred_alias and aliases and preferred_alias not in aliases:
+        if any(alias in {"在招岗位数", "在招岗位", "已发布岗位数"} for alias in aliases):
+            return not _user_requests_recruiting_job_count(question, schema)
+        if preferred_alias == "总数" and any("在招" in alias for alias in aliases):
+            return not _user_requests_recruiting_job_count(question, schema)
+    if _user_requests_recruiting_job_count(question, schema):
+        return False
+    if any("在招" in alias for alias in aliases):
+        return True
     return False
 
 
+def _sql_counts_job_basic_info(sql: str) -> bool:
+    normalized = re.sub(r"\s+", " ", sql.strip().lower())
+    return "count(" in normalized and "job_basic_info" in normalized
+
+
+def _strip_job_status_filters(sql: str) -> str:
+    table_aliases = _sql_table_aliases(sql)
+    job_aliases = {alias for alias, table in table_aliases.items() if table == "job_basic_info"}
+    if not job_aliases:
+        return sql
+    alias_pattern = "|".join(re.escape(alias) for alias in sorted(job_aliases, key=len, reverse=True))
+    columns = [r"(?<!\.)\bstatus"]
+    if alias_pattern:
+        columns.append(rf"\b(?:{alias_pattern})\.status")
+    cleaned = sql
+    for column in columns:
+        cleaned = re.sub(
+            rf"\s+and\s+{column}\s*=\s*-?\d+\b",
+            "",
+            cleaned,
+            flags=re.IGNORECASE,
+        )
+        cleaned = re.sub(
+            rf"\s+and\s+{column}\s+in\s*\([^)]*\)",
+            "",
+            cleaned,
+            flags=re.IGNORECASE,
+        )
+    return cleaned
+
+
+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 normalize_job_count_sql(sql: str, question: str, *, schema: dict[str, Any] | None = None) -> str:
+    if not _is_job_count_intent_question(question) or not _sql_counts_job_basic_info(sql):
+        return sql
+    preferred_alias = _preferred_count_alias(question)
+    normalized = sql
+    if not _user_requests_recruiting_job_count(question, schema):
+        normalized = _strip_job_status_filters(normalized)
+        if preferred_alias:
+            normalized = _replace_primary_metric_alias(normalized, preferred_alias)
+        elif any("在招" in alias for alias in _sql_select_metric_aliases(normalized)):
+            normalized = _replace_primary_metric_alias(normalized, "总数")
+    elif preferred_alias:
+        normalized = _replace_primary_metric_alias(normalized, preferred_alias)
+    return normalized
+
+
+def _requested_job_status_values(question: str, schema: dict[str, Any] | None) -> set[str] | None:
+    if not schema:
+        return None
+    status_enum = _status_enum(schema, "job_basic_info.status")
+    if status_enum is None:
+        return None
+    matched: set[str] = set()
+    for item in status_enum:
+        value = item.get("value")
+        labels = _enum_label_terms(str(item.get("label") or ""))
+        if value is None or not labels:
+            continue
+        if any(label and label in question for label in labels):
+            matched.add(str(value))
+    return matched or None
+
+
+def _status_enum(schema: dict[str, Any], field: str) -> list[dict[str, Any]] | None:
+    enums = schema.get("enums")
+    if not isinstance(enums, list):
+        return None
+    for enum in enums:
+        if not isinstance(enum, dict):
+            continue
+        if str(enum.get("field") or "").lower() != field.lower():
+            continue
+        values = enum.get("values")
+        if isinstance(values, list):
+            return [value for value in values if isinstance(value, dict)]
+    return None
+
+
+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 _sql_status_filter_values(sql: str, job_aliases: set[str]) -> set[str] | None:
+    values: set[str] = set()
+    alias_pattern = "|".join(re.escape(alias) for alias in sorted(job_aliases, key=len, reverse=True))
+    columns = [r"(?<!\.)\bstatus"]
+    if alias_pattern:
+        columns.append(rf"\b(?:{alias_pattern})\.status")
+    for column in columns:
+        for match in re.finditer(rf"{column}\s*=\s*(?P<value>-?\d+)\b", sql, flags=re.IGNORECASE):
+            values.add(match.group("value"))
+        for match in re.finditer(rf"{column}\s+in\s*\((?P<values>[^)]*)\)", sql, flags=re.IGNORECASE):
+            parsed = re.findall(r"-?\d+", match.group("values"))
+            values.update(parsed)
+    return values or None
+
+
 def validate_sql_against_schema(sql: str, schema: dict[str, Any]) -> list[SchemaValidationIssue]:
     issues: list[SchemaValidationIssue] = []
     table_aliases = _sql_table_aliases(sql)
@@ -500,458 +724,6 @@ def _table_columns(schema: dict[str, Any], table_name: str) -> list[dict[str, An
     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,76 +755,6 @@ 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:
@@ -1063,29 +765,6 @@ def _extract_time_range(question: str, schema: dict[str, Any] | None = 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)
-
-
-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 _resolve_job_time_field(question: str, schema: dict[str, Any]) -> FieldRef | None:
     columns = _table_columns(schema, "job_basic_info")
     question_text = _normalize_semantic_text(question)
@@ -1202,23 +881,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,
@@ -1294,10 +956,6 @@ 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
@@ -1307,18 +965,6 @@ def _is_work_order_detail_query(question: str) -> bool:
     )
 
 
-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(
@@ -1342,28 +988,13 @@ def _is_single_entity_lookup_sql(sql: str) -> bool:
 
 _ENTITY_NAME_CHARS = r"[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40}"
 _ENTITY_SEPARATOR = r"[\s:：,，、;；]+"
+_FIELD_LABEL_BOUNDARY = (
+    r"(?:\s+(?=门店|品牌|项目|岗位|职位|城市|区域|有哪些|有什么|多少|包括|返回|状态)"
+    r"|(?=在(?!招)|位于|有哪些|有什么|多少|包括|返回|状态|岗位|职位|门店|品牌|项目|$|[，,。；;？?]))"
+)
 _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>.+?)(?:，|,|。|；|;|的品牌|品牌信息|包括|返回|$)",
@@ -1380,6 +1011,7 @@ def _extract_brand_filter(question: str) -> tuple[str, str] | None:
     exact_patterns = [
         rf"品牌(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<brand>{_ENTITY_NAME_CHARS})",
         rf"品牌{_ENTITY_SEPARATOR}(?P<brand>{_ENTITY_NAME_CHARS})",
+        rf"品牌(?P<brand>{_ENTITY_NAME_CHARS}?)(?={_FIELD_LABEL_BOUNDARY})",
         rf"(?P<brand>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?品牌(?:下|的)?",
     ]
     for pattern in exact_patterns:
@@ -1403,17 +1035,27 @@ def _extract_project_name(question: str) -> str | None:
         rf"项目(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
         rf"项目{_ENTITY_SEPARATOR}(?P<name>{_ENTITY_NAME_CHARS})",
         rf"(?P<name>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?项目(?:下|的)?",
+        rf"项目(?P<name>{_ENTITY_NAME_CHARS})(?={_FIELD_LABEL_BOUNDARY})",
     ]
     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=("品牌", "岗位", "职位", "报名"))
+        project = _clean_project_candidate(match.group("name"))
         if project is not None:
             return project
     return None
 
 
+def _clean_project_candidate(value: str) -> str | None:
+    return _clean_entity_candidate(
+        value,
+        extra_forbidden=("品牌", "岗位", "职位", "报名"),
+        suffix_pattern=r"((?:在|位于)[\u4e00-\u9fff]{1,20}(?:市|省|区|县)?.*$|(?:的)?(?:岗位|职位).*$|的项目信息|项目信息|的项目|项目|的|下)$",
+        reject_location_like=True,
+    )
+
+
 def _extract_job_name_filter(question: str) -> str | None:
     patterns = [
         r"(?:岗位|职位)(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|岗位信息|职位信息|包括|返回|$)",
@@ -1430,11 +1072,33 @@ def _extract_job_name_filter(question: str) -> str | None:
     return None
 
 
+def _extract_store_name_filter(question: str) -> str | None:
+    patterns = [
+        r"门店(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|门店信息|包括|返回|$)",
+        rf"门店(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
+        rf"(?<!所属)门店(?P<name>{_ENTITY_NAME_CHARS})(?=[，,。；;？?\s]|有哪些|有什么|多少|岗位|职位|在招|招聘|$)",
+        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
+        store_name = _clean_entity_candidate(
+            match.group("name"),
+            extra_forbidden=("品牌", "项目", "岗位", "职位", "报名", "薪资", "学历", "学历要求", "年龄要求"),
+            suffix_pattern=r"((?:的)?(?:岗位|职位).*$|门店信息|的门店|门店|的|下)$",
+            reject_location_like=True,
+        )
+        if store_name is not None:
+            return store_name
+    return None
+
+
 def _clean_brand_candidate(value: str) -> str | None:
     return _clean_entity_candidate(
         value,
         extra_forbidden=("岗位", "候选人", "报名", "入职", "在招", "招聘", "数量", "多少"),
-        suffix_pattern=r"(的品牌信息|品牌信息|的品牌|品牌|的|下)$",
+        suffix_pattern=r"((?:的)?(?:岗位|职位).*$|的品牌信息|品牌信息|的品牌|品牌|的|下)$",
     )
 
 
@@ -1443,18 +1107,45 @@ def _clean_entity_candidate(
     *,
     extra_forbidden: tuple[str, ...] = (),
     suffix_pattern: str = r"(的|下)$",
+    reject_location_like: bool = False,
 ) -> 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
+    forbidden = (
+        "查询",
+        "查看",
+        "给我",
+        "帮我",
+        "根据",
+        "roll-core",
+        "信息",
+        "数据",
+        "列表",
+        "明细",
+        "情况",
+        "哪些",
+        "所有",
+        "全部",
+        "我能看到",
+    ) + extra_forbidden
+    if reject_location_like and _is_location_like_entity_name(brand):
+        return None
     if 2 <= len(brand) <= 40 and not any(term in brand for term in forbidden):
         return brand
     return None
 
 
+def _is_location_like_entity_name(value: str) -> bool:
+    return bool(
+        re.fullmatch(r"在[\u4e00-\u9fff]{1,20}(?:市|省|区|县)?", value)
+        or re.fullmatch(r"位于[\u4e00-\u9fff]{1,20}(?:市|省|区|县)?", value)
+        or value.startswith(("在", "位于"))
+    )
+
+
 def _sql_references_brand_table(sql: str) -> bool:
     return _sql_references_table(sql, "brand")
 
@@ -1476,6 +1167,16 @@ def _sql_contains_name_filter(sql: str, name: str) -> bool:
     )
 
 
+def _sql_contains_project_id_filter(sql: str) -> bool:
+    normalized = sql.lower()
+    table_aliases = _sql_table_aliases(normalized)
+    project_aliases = [alias for alias, table in table_aliases.items() if table == "sponge_project"]
+    if not project_aliases:
+        return False
+    alias_pattern = "|".join(re.escape(alias) for alias in sorted(set(project_aliases), key=len, reverse=True))
+    return bool(re.search(rf"\b(?:{alias_pattern})\.id\s*=\s*\d+\b", 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())
@@ -1485,15 +1186,16 @@ def _sql_contains_job_name_filter(sql: str, job_name: str) -> bool:
     )
 
 
-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 _sql_contains_store_name_filter(sql: str, store_name: str) -> bool:
+    normalized = sql.lower()
+    escaped = re.escape(_escape_sql_string(store_name).lower())
+    table_aliases = _sql_table_aliases(normalized)
+    store_aliases = [alias for alias, table in table_aliases.items() if table == "store"]
+    if store_aliases:
+        alias_pattern = "|".join(re.escape(alias) for alias in sorted(set(store_aliases), key=len, reverse=True))
+        if re.search(rf"\b(?:{alias_pattern})\.name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized):
+            return True
+    return bool(re.search(rf"\bstore_name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized))
 
 
 def is_recruiting_match_effect_query(question: str) -> bool:
@@ -1505,50 +1207,6 @@ def is_recruiting_match_effect_query(question: str) -> bool:
     )
 
 
-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"(门店|门店地址|详细地址|精确地址|地址|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
-            question,
-        )
-    )
-
-
-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)
@@ -1612,33 +1270,6 @@ 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: