@roll-agent/octopus-agent 0.0.4 → 0.0.6

package/src/octopus_sponge_skill/sql_generator.py

@@ -65,15 +65,12 @@ class RuleBasedSqlGenerator:
         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:
+        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
-                if operator == "contains":
-                    brand_where = f"b.is_delete = 0 AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
-                else:
-                    brand_where = f"b.is_delete = 0 AND b.name = '{_escape_sql_string(brand_name)}'"
+                _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 "
@@ -82,11 +79,15 @@ class RuleBasedSqlGenerator:
             )
             return GeneratedSql(sql, ["brand"], [])
 
-        if ("项目" in question or "project" in lowered) and "sponge_project" in table_names:
+        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 "
-                "WHERE p.is_delete = 0 "
+                f"WHERE {project_where} "
                 f"LIMIT {self.default_limit}"
             )
             return GeneratedSql(sql, ["sponge_project"], [])
@@ -101,7 +102,7 @@ class RuleBasedSqlGenerator:
         if location and _has_recruiting_location_tables(table_names):
             escaped_location = _escape_sql_string(location)
             from_and_where = _append_job_time_range_condition(
-                _recruiting_location_from_and_where(escaped_location),
+                _append_job_name_condition(_recruiting_location_from_and_where(escaped_location), question),
                 question,
                 schema,
             )
@@ -123,7 +124,11 @@ class RuleBasedSqlGenerator:
             )
 
         if _is_recruiting_job_question(question) and _has_recruiting_tables(table_names):
-            from_and_where = _append_job_time_range_condition(_recruiting_from_and_where(), question, schema)
+            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:
@@ -150,8 +155,11 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         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")
+    if _sql_selects_sensitive_field(sql):
+        raise SqlGenerationError("SQL contains a sensitive field")
     if ":scope." in normalized:
         raise SqlGenerationError("SQL must not contain scope placeholders")
+    _enforce_text_filters_use_like(sql)
     _enforce_chinese_select_aliases(sql)
     _enforce_no_null_placeholder_select_items(sql)
     limit = re.search(r"\blimit\s+(\d+)\b", normalized)
@@ -161,11 +169,157 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError(f"SQL LIMIT must not exceed {max_limit}")
 
 
+SENSITIVE_FIELD_NAMES = {
+    "phone",
+    "mobile",
+    "tel",
+    "telephone",
+    "phone_number",
+    "mobile_number",
+    "mobile_phone",
+    "contact_phone",
+    "contact_mobile",
+    "contact_tel",
+    "id_card",
+    "idcard",
+    "identity_card",
+    "cert_no",
+    "certificate_no",
+    "password",
+    "token",
+    "secret",
+    "credential",
+    "private_key",
+}
+SENSITIVE_FIELD_SUFFIXES = ("_phone", "_mobile", "_tel")
+SENSITIVE_FIELD_LABELS = (
+    "手机号",
+    "手机号码",
+    "电话",
+    "电话号码",
+    "联系方式",
+    "身份证",
+    "身份证号",
+    "身份证号码",
+    "密码",
+    "令牌",
+    "密钥",
+    "凭证",
+)
+
+
+def sensitive_terms_in_text(text: str) -> list[str]:
+    lowered = text.lower()
+    terms: list[str] = []
+    for label in SENSITIVE_FIELD_LABELS:
+        if label in text:
+            terms.append(label)
+    english_terms = {
+        "phone": "手机号",
+        "mobile": "手机号",
+        "tel": "电话",
+        "telephone": "电话",
+        "id_card": "身份证",
+        "idcard": "身份证",
+        "password": "密码",
+        "token": "令牌",
+        "secret": "密钥",
+    }
+    for term, label in english_terms.items():
+        if re.search(rf"\b{re.escape(term)}\b", lowered) and label not in terms:
+            terms.append(label)
+    return list(dict.fromkeys(terms))
+
+
+def _sql_selects_sensitive_field(sql: str) -> bool:
+    select_clause = _top_level_select_clause(sql)
+    if select_clause is None:
+        return False
+    return any(_select_item_contains_sensitive_field(item) for item in _split_select_items(select_clause))
+
+
+def _top_level_select_clause(sql: str) -> str | None:
+    match = re.search(r"\bselect\b(?P<select>.*?)\bfrom\b", sql, flags=re.IGNORECASE | re.DOTALL)
+    if match is None:
+        return None
+    return match.group("select")
+
+
+def _split_select_items(select_clause: str) -> list[str]:
+    items: list[str] = []
+    start = 0
+    depth = 0
+    quote: str | None = None
+    for index, char in enumerate(select_clause):
+        if quote is not None:
+            if char == quote:
+                quote = None
+            continue
+        if char in {"'", '"', "`"}:
+            quote = char
+        elif char == "(":
+            depth += 1
+        elif char == ")" and depth > 0:
+            depth -= 1
+        elif char == "," and depth == 0:
+            items.append(select_clause[start:index].strip())
+            start = index + 1
+    tail = select_clause[start:].strip()
+    if tail:
+        items.append(tail)
+    return items
+
+
+def _select_item_contains_sensitive_field(item: str) -> bool:
+    if any(label in item for label in SENSITIVE_FIELD_LABELS):
+        return True
+    identifiers = re.findall(r"\b[a-zA-Z_][a-zA-Z0-9_]*\b", item.lower())
+    for identifier in identifiers:
+        if identifier in {"select", "case", "when", "then", "else", "end", "as", "if", "null", "coalesce"}:
+            continue
+        if identifier in SENSITIVE_FIELD_NAMES or identifier.endswith(SENSITIVE_FIELD_SUFFIXES):
+            return True
+    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()
+        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")
+
+
+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) -> 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):
+        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):
+        return True
     if _is_work_order_detail_query(question):
         if "mvp_applied_jobs_by_helped_account" not in normalized:
             return True
@@ -352,12 +506,27 @@ def _generate_recruiting_detail_sql(question: str, schema: dict[str, Any], defau
         raise SqlGenerationError("job_basic_info is required for recruiting detail query")
 
     select_items = _recruiting_detail_select_items(question, schema)
-    from_and_where = _append_job_time_range_condition(_recruiting_detail_from_and_where(table_names), 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_store", "store", "job_salary", "job_hiring_requirement")
+        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, [])
@@ -374,8 +543,8 @@ def _generate_work_order_detail_sql(question: str, schema: dict[str, Any], defau
     if not sql:
         raise SqlGenerationError("Work order detail schema example has no SQL")
     sql = re.sub(
-        r"b\.name\s*=\s*'[^']*'",
-        f"b.name = '{_escape_sql_string(brand_name)}'",
+        r"b\.name\s*(?:=|LIKE)\s*'%?[^']*%?'",
+        f"b.name LIKE '%{_escape_sql_string(brand_name)}%'",
         sql,
         count=1,
         flags=re.IGNORECASE,
@@ -682,17 +851,37 @@ def _match_effect_match_metric_sql(
     )
 
 
-def _recruiting_detail_from_and_where(table_names: set[str]) -> str:
+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")
-    parts.append("WHERE jbi.is_deleted = 0 AND jbi.status = 1")
+    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)
 
 
@@ -836,6 +1025,17 @@ def _recruiting_location_condition(location: str) -> str:
     )
 
 
+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:
@@ -846,6 +1046,13 @@ def _append_job_time_range_condition(from_and_where: str, question: str, schema:
     )
 
 
+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:
@@ -1073,6 +1280,7 @@ def _extract_location_for_recruiting_job_question(question: str) -> str | None:
         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:
@@ -1099,6 +1307,63 @@ 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(
+            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>.+?)(?:，|,|。|；|;|的品牌|品牌信息|包括|返回|$)",
@@ -1113,8 +1378,9 @@ def _extract_brand_filter(question: str) -> tuple[str, str] | None:
             return "contains", brand
 
     exact_patterns = [
-        r"品牌(?:名称)?(?:为|是|=|等于)(?P<brand>.+?)(?:，|,|。|；|;|候选人|工单|报名|提供|输出|通过|包括|返回|$)",
-        r"(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{2,40})品牌(?:下|的)?",
+        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)
@@ -1131,30 +1397,94 @@ def _extract_brand_name(question: str) -> str | None:
     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 = brand.strip("\"'“”‘’%:：,，、;；")
     brand = re.sub(r"^(名称为|名称是|为|是|=|等于)", "", brand)
-    brand = re.sub(r"(的品牌信息|品牌信息|的品牌|品牌|的|下)$", "", brand)
-    brand = brand.strip("\"'“”‘’%")
-    if 2 <= len(brand) <= 40 and re.search(r"(查询|查看|给我|帮我|根据|roll-core|岗位|候选人|报名|入职|在招|招聘|数量|多少)", brand) is None:
+    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 "brand" in _sql_table_aliases(sql.lower()).values()
+    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(brand_name).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)
@@ -1203,11 +1533,11 @@ def _is_multi_metric_query(question: str) -> bool:
 
 
 def _requires_recruiting_detail_joins(question: str) -> bool:
-    if re.search(r"(明细|详情|包含|需要|显示|带上|返回)", question) is None:
+    if re.search(r"(明细|详情|信息|包含|需要|显示|带上|返回|字段)", question) is None:
         return False
     return bool(
         re.search(
-            r"(门店|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
+            r"(门店|门店地址|详细地址|精确地址|地址|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
             question,
         )
     )
@@ -1285,7 +1615,7 @@ def _escape_sql_string(value: str) -> str:
 def _province_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"p.name = {literal} OR "
+        f"p.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(REPLACE(p.name, '特别行政区', ''), '自治区', ''), '省', ''), '市', '') = "
         f"REPLACE(REPLACE(REPLACE(REPLACE({literal}, '特别行政区', ''), '自治区', ''), '省', ''), '市', '')"
     )
@@ -1294,7 +1624,7 @@ def _province_name_matches(location: str) -> str:
 def _city_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"c.name = {literal} OR "
+        f"c.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(c.name, '自治州', ''), '地区', ''), '市', '') = "
         f"REPLACE(REPLACE(REPLACE({literal}, '自治州', ''), '地区', ''), '市', '')"
     )
@@ -1303,7 +1633,7 @@ def _city_name_matches(location: str) -> str:
 def _region_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"r.name = {literal} OR "
+        f"r.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(r.name, '自治县', ''), '区', ''), '县', '') = "
         f"REPLACE(REPLACE(REPLACE({literal}, '自治县', ''), '区', ''), '县', '')"
     )