@roll-agent/octopus-agent 0.1.0 → 0.1.2

package/src/octopus_skill/llm_sql_generator.py

@@ -5,7 +5,12 @@ import re
 from dataclasses import dataclass
 from typing import Any, Callable
 
-from .prompt_builder import NL2SQL_SYSTEM_PROMPT, build_nl2sql_prompt, build_sql_repair_prompt
+from .prompt_builder import (
+    NL2SQL_SYSTEM_PROMPT,
+    build_nl2sql_prompt,
+    build_sql_expert_review_prompt,
+    build_sql_repair_prompt,
+)
 from .schema_context_retriever import SchemaContext
 from .sql_generator import GeneratedSql, SqlGenerationError, contains_forbidden_dml_keyword
 
@@ -54,6 +59,30 @@ class SamplingSqlGenerator:
         )
         return _parse_generated_sql(self.sampler(NL2SQL_SYSTEM_PROMPT, prompt))
 
+    def review_sql(
+        self,
+        *,
+        question: str,
+        sql: str,
+        schema_context: SchemaContext,
+    ) -> "SqlExpertReview":
+        prompt = build_sql_expert_review_prompt(
+            question=question,
+            sql=sql,
+            schema_context=schema_context,
+            default_limit=self.default_limit,
+            max_limit=self.max_limit,
+            confirmed_query_plan=self.confirmed_query_plan,
+        )
+        return _parse_sql_expert_review(self.sampler(NL2SQL_SYSTEM_PROMPT, prompt))
+
+
+@dataclass(frozen=True)
+class SqlExpertReview:
+    executable: bool
+    issues: list[dict[str, str]]
+    repaired_sql: str | None = None
+
 
 def _parse_generated_sql(text: str) -> GeneratedSql:
     try:
@@ -101,6 +130,31 @@ def _parse_generated_sql(text: str) -> GeneratedSql:
     )
 
 
+def _parse_sql_expert_review(text: str) -> SqlExpertReview:
+    payload = _load_json_object(text)
+    executable = bool(payload.get("executable", False))
+    issues_payload = payload.get("issues")
+    issues: list[dict[str, str]] = []
+    if isinstance(issues_payload, list):
+        for item in issues_payload:
+            if not isinstance(item, dict):
+                continue
+            issues.append(
+                {
+                    "code": str(item.get("code") or ""),
+                    "message": str(item.get("message") or ""),
+                    "repairHint": str(item.get("repairHint") or ""),
+                }
+            )
+    repaired_sql = payload.get("repairedSql")
+    if isinstance(repaired_sql, str) and repaired_sql.strip():
+        repaired_sql = repaired_sql.strip()
+        _require_select_sql(repaired_sql)
+    else:
+        repaired_sql = None
+    return SqlExpertReview(executable=executable, issues=issues, repaired_sql=repaired_sql)
+
+
 def _load_json_object(text: str) -> dict[str, Any]:
     cleaned = text.strip()
     if cleaned.startswith("```"):

package/src/octopus_skill/octopus_run.py

@@ -469,7 +469,7 @@ def _query_result_payload(query_result: Any, *, include_sql: bool = False, base_
     }
     query_plan = getattr(query_result, "query_plan", None)
     if isinstance(query_plan, dict):
-        payload["queryPlan"] = query_plan
+        payload["queryPlan"] = _public_query_plan(query_plan)
     execution_steps = getattr(query_result, "execution_steps", None)
     if isinstance(execution_steps, list):
         payload["executionSteps"] = execution_steps
@@ -485,6 +485,14 @@ def _query_result_payload(query_result: Any, *, include_sql: bool = False, base_
     return _jsonable(payload)
 
 
+def _public_query_plan(query_plan: dict[str, Any]) -> Json:
+    return {
+        key: value
+        for key, value in query_plan.items()
+        if not str(key).startswith("_")
+    }
+
+
 def _user_visible_answer(query_result: Any, *, base_question: str | None = None) -> str:
     answer = str(getattr(query_result, "answer", ""))
     question = base_question or ""

package/src/octopus_skill/prompt_builder.py

@@ -17,7 +17,8 @@ INSTRUCTION_STAGE_PREFIX: dict[InstructionStage, str] = {
 }
 
 
-NL2SQL_SYSTEM_PROMPT = """你是丸子Agent（Octopus Agent）的海绵数据 SQL 生成器。
+NL2SQL_SYSTEM_PROMPT = """你是丸子Agent（Octopus Agent）的海绵数据 SQL 专家，一名专业 MySQL SQL 专家。
+你必须以 SQL 专家的标准生成 SQL：输出前逐句自检，确保 SQL 整体可以直接执行，没有任何 SQL 语法错误，也没有 SQL 写法问题（如括号/引号不闭合、SELECT 与 GROUP BY 不一致、聚合函数误用、JOIN 缺少等值键、别名冲突、字段/表拼写错误等）。
 业务规则的唯一来源是 payload 中的 mandatoryAgentInstructions 与 schemaContext.policy；必须逐条遵守，不得使用训练记忆中的业务口径替代 schema 要求。
 生成 SQL 前必须严格按 schemaContext.readOrder 顺序阅读 schemaContext 各段内容，再组合 SELECT、JOIN、WHERE、LIMIT。
 只输出 JSON，结构见 outputSchema。返回 JSON 中的 sql 字段必须直接以 SELECT 开头；不要为了状态枚举单独返回 clarification。用户明确提出状态筛选时把状态条件写入 WHERE；用户未提出状态筛选或 schemaContext 缺少枚举时不要追问，首次查询保持宽泛，并把相关状态字段及中文含义加入 SELECT 结果。"""
@@ -76,6 +77,46 @@ def build_sql_repair_prompt(
     )
 
 
+def build_sql_expert_review_prompt(
+    *,
+    question: str,
+    sql: str,
+    schema_context: SchemaContext,
+    default_limit: int,
+    max_limit: int,
+    confirmed_query_plan: dict[str, Any] | None = None,
+) -> str:
+    payload = _base_sql_prompt_payload(
+        question=question,
+        schema_context=schema_context,
+        default_limit=default_limit,
+        max_limit=max_limit,
+        confirmed_query_plan=confirmed_query_plan,
+        task="review_sql_executability",
+        original_sql=sql,
+    )
+    payload["reviewInstruction"] = (
+        "你是专业 MySQL SQL 专家，只检查 SQL 写法是否整体可执行，不改变业务口径。"
+        "重点检查：聚合函数是否误写在 WHERE/JOIN ON；GROUP BY/HAVING 是否合法；"
+        "子查询和派生表别名是否完整；外层引用的派生表字段是否存在；"
+        "SELECT 中非聚合字段与 GROUP BY 是否兼容；MySQL 低版本不支持 WITH。"
+        "如果 SQL 可执行，返回 executable=true 且 repairedSql 为空；"
+        "如果不可执行，返回 executable=false、issues，并在不改变业务口径和 schema 字段的前提下给出 repairedSql。"
+    )
+    payload["reviewOutputSchema"] = {
+        "executable": True,
+        "issues": [{"code": "ISSUE_CODE", "message": "中文问题说明", "repairHint": "中文修复建议"}],
+        "repairedSql": "SELECT ... LIMIT 50 或空字符串",
+    }
+    compact = confirmed_query_plan is not None
+    return json.dumps(
+        payload,
+        ensure_ascii=False,
+        indent=None if compact else 2,
+        separators=(",", ":") if compact else (", ", ": "),
+    )
+
+
 def _base_sql_prompt_payload(
     *,
     question: str,
@@ -99,8 +140,13 @@ def _base_sql_prompt_payload(
             "schemaContext 未提供对应口径时，不要凭训练记忆或字段名猜测 SQL。"
             "涉及时间范围时，如果命中的 schemaContext.concepts 或 metrics 提供 timeRangeField，"
             "必须使用该字段生成 WHERE 时间过滤，不要改用关联维表的同名时间字段。"
+            "JOIN ... ON 只能写 schemaContext.relations / joins / exampleJoinPatterns 中提供的等值关联键；"
+            "禁止凭字段名相似或训练记忆新增 schema 未定义 JOIN。"
             "涉及“最多/最高/最大/排名/排行”等聚合极值诉求时，必须优先按聚合指标倒序排序，"
             "再按时间等次要维度排序。"
+            "你必须作为专业 MySQL SQL 专家自检 SQL 整体可执行性：聚合函数不能写在 WHERE/JOIN ON，"
+            "聚合筛选必须放 HAVING 或先在子查询聚合后外层过滤；派生表字段和别名必须真实存在；"
+            "MySQL 低版本不支持 WITH。"
             "不要把查询动作、状态变化、时间词或范围词当作名称筛选；"
             "只有用户明确说“名称包含/岗位名称是/叫做/简称为”时，才允许对 name/title/job_name 写 LIKE。"
             if not compact
@@ -112,8 +158,13 @@ def _base_sql_prompt_payload(
             "schemaContext 未提供对应口径时，不要凭训练记忆或字段名猜测 SQL。"
             "涉及时间范围时，如果命中的 schemaContext.concepts 或 metrics 提供 timeRangeField，"
             "必须使用该字段生成 WHERE 时间过滤，不要改用关联维表的同名时间字段。"
+            "JOIN ... ON 只能写 schemaContext.relations / joins / exampleJoinPatterns 中提供的等值关联键；"
+            "禁止凭字段名相似或训练记忆新增 schema 未定义 JOIN。"
             "涉及“最多/最高/最大/排名/排行”等聚合极值诉求时，必须优先按聚合指标倒序排序，"
             "再按时间等次要维度排序。"
+            "你必须作为专业 MySQL SQL 专家自检 SQL 整体可执行性：聚合函数不能写在 WHERE/JOIN ON，"
+            "聚合筛选必须放 HAVING 或先在子查询聚合后外层过滤；派生表字段和别名必须真实存在；"
+            "MySQL 低版本不支持 WITH。"
             "JOIN ... ON 只能写 schema relations / joins 中的等值关联键（如 a.id = b.x_id）；"
             "confirmedQueryPlan.filters 里的 LIKE/IN 筛选必须写在 WHERE，禁止写在 JOIN ON；"
             "同一 logicalGroup 且 logicalOperator=OR 的筛选必须用 OR 连接，并用括号包裹；"
@@ -125,10 +176,13 @@ def _base_sql_prompt_payload(
         "schemaContext": _schema_context_payload(schema_context, compact=compact),
         "outputSchema": _sql_output_schema(default_limit, question),
     }
-    if task == "repair_sql":
+    if task:
         payload["task"] = task
+    if task == "repair_sql":
         payload["originalSql"] = original_sql or ""
         payload["validationError"] = validation_error or {}
+    elif task == "review_sql_executability":
+        payload["sqlToReview"] = original_sql or ""
     if confirmed_query_plan:
         payload["confirmedQueryPlan"] = _compact_query_plan_for_sql(confirmed_query_plan)
     return payload
@@ -198,13 +252,16 @@ def _compact_query_plan_for_sql(query_plan: dict[str, Any]) -> dict[str, Any]:
     ]
     if entities:
         compact["entities"] = entities
+    plan_filters = query_plan.get("_sqlFilters")
+    if not isinstance(plan_filters, list):
+        plan_filters = query_plan.get("filters", [])
     filters = [
         {
             key: item[key]
             for key in ("field", "operator", "value", "description", "source", "logicalGroup", "logicalOperator")
             if key in item
         }
-        for item in query_plan.get("filters", [])
+        for item in plan_filters
         if isinstance(item, dict)
     ]
     if filters:

package/src/octopus_skill/question_analyzer.py

@@ -132,10 +132,15 @@ class QuestionAnalysisError(Exception):
     """Raised when question analysis fails."""
 
 
+SAMPLING_MAX_RETRIES = 2
+
+
 def analyze_question(
     question: str,
     sampler: Sampler,
     agent_instructions: list[dict[str, Any]] | None = None,
+    *,
+    max_sampling_retries: int = SAMPLING_MAX_RETRIES,
 ) -> QuestionAnalysis:
     """Use LLM to analyze user question and extract structured intent + query targets.
 
@@ -152,12 +157,18 @@ def analyze_question(
     """
     prompt = build_question_analysis_prompt(question, agent_instructions)
 
-    try:
-        raw_response = sampler(QUESTION_ANALYSIS_SYSTEM_PROMPT, prompt)
-    except Exception as exc:
-        raise QuestionAnalysisError(f"LLM 调用失败：{type(exc).__name__}: {exc}") from exc
-
-    payload = _parse_analysis_response(raw_response)
+    raw_response: str | None = None
+    for attempt in range(max_sampling_retries + 1):
+        try:
+            raw_response = sampler(QUESTION_ANALYSIS_SYSTEM_PROMPT, prompt)
+            break
+        except Exception as exc:
+            if attempt >= max_sampling_retries:
+                raise QuestionAnalysisError(
+                    f"LLM 调用失败（已重试 {max_sampling_retries} 次）：{type(exc).__name__}: {exc}"
+                ) from exc
+
+    payload = _parse_analysis_response(raw_response or "")
     return _build_analysis(payload, question)
 
 

package/src/octopus_skill/sql_generator.py

@@ -49,6 +49,9 @@ class SchemaValidationIssue:
 class LowQualitySqlIssue:
     code: str
     message: str
+    missing_items: tuple[str, ...] = ()
+    current_problem: str = ""
+    repair_hint: str = ""
 
 
 _SELECT_AS_ALIAS_PATTERN = (
@@ -86,6 +89,7 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError("SQL must not contain scope placeholders")
     _enforce_text_filters_use_like(sql)
     _enforce_join_on_uses_equality_keys(sql)
+    _enforce_no_aggregate_functions_in_row_filters(sql)
     _enforce_chinese_select_aliases(sql)
     _enforce_no_null_placeholder_select_items(sql)
     _enforce_no_tautological_join_conditions(sql)
@@ -724,6 +728,41 @@ def _enforce_join_on_uses_equality_keys(sql: str) -> None:
         raise SqlGenerationError(violations[0])
 
 
+_AGGREGATE_FUNCTION_RE = re.compile(
+    r"\b(?:count|sum|avg|min|max|group_concat)\s*\(",
+    flags=re.IGNORECASE,
+)
+
+
+def _enforce_no_aggregate_functions_in_row_filters(sql: str) -> None:
+    for clause in _iter_join_on_clauses(sql):
+        if _AGGREGATE_FUNCTION_RE.search(clause):
+            raise SqlGenerationError(
+                "SQL aggregate functions must not be used in JOIN ON; "
+                "aggregate first in a subquery or move aggregate predicates to HAVING"
+            )
+    where_clause = _top_level_where_clause(sql)
+    if where_clause and _AGGREGATE_FUNCTION_RE.search(where_clause):
+        raise SqlGenerationError(
+            "SQL aggregate functions must not be used in WHERE; "
+            "move aggregate predicates to HAVING or aggregate first in a subquery"
+        )
+
+
+def _top_level_where_clause(sql: str) -> str:
+    where_index = _find_top_level_keyword(sql, "where", start=0)
+    if where_index is None:
+        return ""
+    body_start = where_index + len("where")
+    suffix_starts = [
+        index
+        for keyword in ("group by", "having", "order by", "limit")
+        if (index := _find_top_level_keyword(sql, keyword, start=body_start)) is not None
+    ]
+    body_end = min(suffix_starts) if suffix_starts else len(sql)
+    return sql[body_start:body_end]
+
+
 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
@@ -877,7 +916,18 @@ def low_quality_sql_issue_for_question(question: str, sql: str, *, schema: dict[
             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)
+                concept_label = str(concept.get("comment") or concept.get("name") or "命中的 schema concept")
+                return LowQualitySqlIssue(
+                    code="SCHEMA_SQL_QUALITY",
+                    message=message,
+                    missing_items=(f"必须引用表 {table_name}",),
+                    current_problem=(
+                        f"当前 SQL 没有使用 {table_name}，无法覆盖“{concept_label}”要求的查询口径。"
+                    ),
+                    repair_hint=(
+                        f"按 schema.concepts 中“{concept_label}”的定义补充 {table_name} 及对应 JOIN/WHERE 条件。"
+                    ),
+                )
     aggregate_issue = _aggregate_sql_quality_issue(question, sql)
     if aggregate_issue is not None:
         return aggregate_issue
@@ -901,6 +951,9 @@ def _concept_time_range_field_issue(
                 f"用户问题包含时间范围，且 schema concept 指定时间字段为 {qualified}；"
                 "SQL 必须使用该字段过滤时间范围，不要改用关联维表的同名时间字段。"
             ),
+            missing_items=(f"时间范围字段 {qualified}",),
+            current_problem=f"当前 SQL 没有使用 {qualified} 过滤用户要求的时间范围。",
+            repair_hint=f"在 WHERE 中使用 {qualified} 补充时间范围过滤。",
         )
     unexpected = _unexpected_time_filter_fields(sql, expected_field=qualified)
     if unexpected:
@@ -910,22 +963,62 @@ def _concept_time_range_field_issue(
                 f"用户问题包含时间范围，且 schema concept 指定时间字段为 {qualified}；"
                 f"SQL 不应同时使用 {'、'.join(unexpected)} 过滤时间范围。"
             ),
+            missing_items=(f"唯一时间范围字段 {qualified}",),
+            current_problem=f"当前 SQL 还使用了 {'、'.join(unexpected)} 过滤时间范围，可能把口径切到关联表时间。",
+            repair_hint=f"删除关联表时间过滤，只保留 {qualified} 的时间范围条件。",
         )
     return None
 
 
+_TIME_RANGE_DATE_LITERAL = r"'20\d{2}-\d{1,2}-\d{1,2}(?:\s+\d{1,2}:\d{2}:\d{2})?'"
+
+
 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):
+    if _scope_has_time_filter_for_range(sql, time_range):
+        return True
+    for subquery in _sql_derived_subqueries(sql).values():
+        if _sql_has_time_filter_for_range(subquery, time_range):
+            return True
+    return False
+
+
+def _mask_derived_subqueries(sql: str) -> str:
+    spans = _sql_derived_subquery_spans(sql)
+    if not spans:
+        return sql
+    chars = list(sql)
+    for start, end in spans:
+        for index in range(start, min(end, len(chars))):
+            chars[index] = " "
+    return "".join(chars)
+
+
+def _scope_has_time_filter_for_range(sql: str, time_range: TimeRange) -> bool:
+    """Return True if the designated time field is compared to a date literal in this
+    query scope.
+
+    Nested derived subqueries are masked out here and evaluated separately by
+    ``_sql_has_time_filter_for_range`` so alias resolution stays scoped. The check
+    scans the whole scope (not just the top-level WHERE) so the field can satisfy the
+    requirement whether it is used in WHERE or inside a conditional aggregate such as
+    ``SUM(CASE WHEN sign_up_time >= ... THEN 1 ELSE 0 END)``, which some schema concepts
+    mandate for period metrics.
+    """
+    scope_text = _mask_derived_subqueries(sql)
+    op = r"(?:>=|<=|>|<|=)"
+    date = _TIME_RANGE_DATE_LITERAL
+    field_patterns: list[str] = [_time_range_sql_field_pattern(scope_text, time_range)]
+    base_tables = set(_sql_top_level_table_aliases(scope_text).values())
+    if not time_range.table_name or base_tables == {time_range.table_name.lower()}:
+        # Single base table in scope: an unqualified column reference is unambiguous.
+        field_patterns.append(rf"(?<![.\w]){re.escape(time_range.field.lower())}\b")
+    for field_pattern in field_patterns:
+        checks = (
+            rf"{field_pattern}\s*{op}\s*{date}",
+            rf"{date}\s*{op}\s*{field_pattern}",
+            rf"{field_pattern}\s+between\s+{date}\s+and\s+{date}",
+        )
+        if any(re.search(pattern, scope_text, flags=re.IGNORECASE) for pattern in checks):
             return True
     return False
 
@@ -972,9 +1065,23 @@ def _aggregate_sql_quality_issue(question: str, sql: str) -> LowQualitySqlIssue
     return LowQualitySqlIssue(
         code="AGGREGATE_SQL_REQUIRED",
         message="用户问题要求统计数量/最多值及对应维度，SQL 必须使用 COUNT/SUM/AVG/MIN/MAX 等聚合函数，不能只返回明细行。",
+        missing_items=("聚合函数 COUNT/SUM/AVG/MIN/MAX",),
+        current_problem="当前 SQL 返回明细行，不能回答数量、最多值、排名或按维度统计问题。",
+        repair_hint="按用户问题中的统计维度 GROUP BY，并用聚合函数生成指标。",
     )
 
 
+def format_sql_quality_issue(issue: LowQualitySqlIssue) -> str:
+    parts = [f"当前 SQL 不满足查询口径：{issue.message}"]
+    if issue.missing_items:
+        parts.append(f"缺失口径：{'；'.join(issue.missing_items)}")
+    if issue.current_problem:
+        parts.append(f"当前 SQL 的问题：{issue.current_problem}")
+    if issue.repair_hint:
+        parts.append(f"建议修复方向：{issue.repair_hint}")
+    return "；".join(parts)
+
+
 def _question_requires_aggregate_sql(question: str) -> bool:
     if not re.search(r"(计数|统计|数量|个数|总数|多少)", question):
         return False
@@ -1207,6 +1314,7 @@ def _schema_invalid_join_issues(
     allowed_pairs = _schema_allowed_join_pairs(schema)
     if not allowed_pairs:
         return []
+    derived_aliases = set(_sql_derived_subquery_aliases(sql))
     issues: list[SchemaValidationIssue] = []
     seen: set[tuple[tuple[str, str], tuple[str, str]]] = set()
     for pair in _sql_equality_pairs(sql, table_aliases):
@@ -1216,6 +1324,8 @@ def _schema_invalid_join_issues(
         if pair in allowed_pairs:
             continue
         left, right = pair
+        if left[0] in derived_aliases or right[0] in derived_aliases:
+            continue
         issues.append(
             SchemaValidationIssue(
                 code="INVALID_JOIN",
@@ -1323,19 +1433,37 @@ def _sql_derived_subquery_spans(sql: str) -> list[tuple[int, int]]:
     ]
 
 
+_DERIVED_SUBQUERY_TRAILING = (
+    r"on\b"
+    r"|(?:(?:left|right|inner|outer|cross|natural)\s+)?join\b"
+    r"|where\b|group\b|order\b|having\b|limit\b"
+    r"|,"
+    r"|\)(?!\s*[a-zA-Z_])"
+    r"|;"
+)
+_DERIVED_SUBQUERY_ALIAS_PATTERN = re.compile(
+    rf"\)\s*(?:as\s+)?([a-zA-Z_][a-zA-Z0-9_]*)(?:\s+(?:{_DERIVED_SUBQUERY_TRAILING})|\s*$)",
+    flags=re.IGNORECASE,
+)
+_RESERVED_DERIVED_ALIASES = frozenset(
+    {"on", "where", "left", "right", "inner", "outer", "join", "select", "cross", "natural", "group", "order", "having", "limit"}
+)
+
+
 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,
-    ):
+    seen_ranges: set[tuple[int, int]] = set()
+    for match in _DERIVED_SUBQUERY_ALIAS_PATTERN.finditer(sql):
         alias = match.group(1).lower()
-        if alias in {"on", "where", "left", "right", "inner", "outer", "join", "select"}:
+        if alias in _RESERVED_DERIVED_ALIASES:
             continue
         subquery_start = _find_matching_open_paren(sql, match.start())
         if subquery_start is None:
             continue
+        range_key = (subquery_start, match.start())
+        if range_key in seen_ranges:
+            continue
+        seen_ranges.add(range_key)
         matches.append((alias, subquery_start, match.start()))
     return matches
 
@@ -1662,7 +1790,7 @@ def time_range_from_query_plan(query_plan: dict[str, Any] | None) -> TimeRange |
     start_value = ""
     end_value = ""
     field_name = ""
-    for flt in query_plan.get("filters") or []:
+    for flt in _query_plan_sql_filters(query_plan):
         if not isinstance(flt, dict):
             continue
         if str(flt.get("source") or "") != "question.timeRange":
@@ -1853,7 +1981,34 @@ def resolve_time_range_for_sql(
 
     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)
+    if sql_schema is None and _sql_referenced_table_names(sql):
+        return None
+    if sql_schema is not None:
+        return resolve_time_range_for_question(
+            question,
+            sql_schema,
+            concepts=_concepts_limited_to_schema_tables(concepts, sql_schema),
+        )
+    return resolve_time_range_for_question(question, schema, concepts=concepts)
+
+
+def _concepts_limited_to_schema_tables(
+    concepts: list[dict[str, Any]],
+    schema: dict[str, Any],
+) -> list[dict[str, Any]]:
+    table_names = {name.lower() for name in _table_names(schema)}
+    if not table_names:
+        return []
+    limited: list[dict[str, Any]] = []
+    for concept in concepts:
+        qualified = str(concept.get("timeRangeField") or "").strip()
+        if "." not in qualified:
+            limited.append(concept)
+            continue
+        table_name = qualified.split(".", 1)[0].lower()
+        if table_name in table_names:
+            limited.append(concept)
+    return limited
 
 
 def _qualified_time_range_field(time_range: TimeRange) -> str:
@@ -2004,7 +2159,7 @@ def sql_missing_query_plan_filters(sql: str, query_plan: dict[str, Any] | None)
     missing: list[str] = []
     normalized_sql = sql.lower()
     grouped_filters: dict[str, list[dict[str, Any]]] = {}
-    for flt in query_plan.get("filters") or []:
+    for flt in _query_plan_sql_filters(query_plan):
         if not isinstance(flt, dict):
             continue
         if str(flt.get("operator") or "").upper() != "LIKE":
@@ -2045,6 +2200,14 @@ def sql_satisfies_query_plan_filters(sql: str, query_plan: dict[str, Any] | None
     return not sql_missing_query_plan_filters(sql, query_plan)
 
 
+def _query_plan_sql_filters(query_plan: dict[str, Any]) -> list[Any]:
+    filters = query_plan.get("_sqlFilters")
+    if isinstance(filters, list):
+        return filters
+    filters = query_plan.get("filters")
+    return filters if isinstance(filters, list) else []
+
+
 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