@roll-agent/octopus-agent 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roll-agent/octopus-agent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "丸子Agent（Octopus Agent）",
   "license": "UNLICENSED",
   "keywords": [

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "octopus-skill"
-version = "0.1.1"
+version = "0.1.2"
 description = "丸子Agent（Octopus Agent）"
 readme = "README.md"
 requires-python = ">=3.11"

package/src/octopus_skill/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"

package/src/octopus_skill/sql_generator.py

@@ -970,18 +970,55 @@ def _concept_time_range_field_issue(
     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