fix parsing issues:

Author: Yuri Zmytrakov

stac_fastapi/core/stac_fastapi/core/core.py

@@ -877,13 +877,6 @@ async def post_search(
                 query_fields = get_properties_from_cql2_filter(cql2_filter)
                 await self.queryables_cache.validate(query_fields)
                 search = await self.database.apply_cql2_filter(search, cql2_filter)
-                date_str = getattr(search, "_cql2_date_str", None)
-                collection_ids = getattr(search, "_cql2_collection_ids", None)
-                if date_str is not None:
-                    datetime_parsed = format_datetime_range(date_str=date_str)
-                    search, datetime_search = self.database.apply_datetime_filter(
-                        search=search, datetime=datetime_parsed
-                    )
             except HTTPException:
                 raise
             except Exception as e:

stac_fastapi/opensearch/stac_fastapi/opensearch/database_logic.py

@@ -17,6 +17,7 @@
 
 import stac_fastapi.sfeos_helpers.filter as filter_module
 from stac_fastapi.core.base_database_logic import BaseDatabaseLogic
+from stac_fastapi.core.datetime_utils import format_datetime_range
 from stac_fastapi.core.serializers import CollectionSerializer, ItemSerializer
 from stac_fastapi.core.utilities import MAX_LIMIT, bbox2polygon, get_bool_env
 from stac_fastapi.extensions.core.transaction.request import (
@@ -57,7 +58,9 @@
     DatetimeOptimizer,
     to_es_via_ast,
 )
-from stac_fastapi.sfeos_helpers.filter.datetime_optimizer import extract_from_ast
+from stac_fastapi.sfeos_helpers.filter.datetime_optimizer import (
+    extract_collection_datetime,
+)
 from stac_fastapi.sfeos_helpers.mappings import (
     AGGREGATION_MAPPING,
     COLLECTIONS_INDEX,
@@ -799,14 +802,12 @@ async def apply_cql2_filter(
                 optimizer = DatetimeOptimizer()
                 optimized_ast = optimizer.optimize_query_structure(ast)
 
-                date_str = extract_from_ast(optimized_ast, "datetime")
-                collection_ids = extract_from_ast(optimized_ast, "collection") or None
+                _cql2_collection_datetime = extract_collection_datetime(optimized_ast)
 
                 es_query = to_es_via_ast(queryables_mapping, optimized_ast)
 
                 search = search.filter(es_query)
-                search._cql2_date_str = date_str
-                search._cql2_collection_ids = collection_ids
+                search._cql2_collection_datetime = _cql2_collection_datetime
 
             except Exception:
                 # Fallback to dictionary-based approach
@@ -866,9 +867,37 @@ async def execute_search(
         search_body: Dict[str, Any] = {}
         query = search.query.to_dict() if search.query else None
 
-        index_param = await self.async_index_selector.select_indexes(
-            collection_ids, datetime_search
-        )
+        cql2_collection_datetime = getattr(search, "_cql2_collection_datetime", None)
+
+        # Special case for cql2 index selection
+        if cql2_collection_datetime:
+            index_param = ""
+            for node in cql2_collection_datetime:
+                if node[0]:
+                    collection_id = node[0]
+                    # Parse datetime for index select without changing Search object
+                    _, datetime_search = self.apply_datetime_filter(
+                        search, format_datetime_range(node[1])
+                    )
+                    if not isinstance(collection_id, list):
+                        collection_id = [collection_id]
+                    index_param_temp = await self.async_index_selector.select_indexes(
+                        collection_id, datetime_search
+                    )
+                    index_param = ",".join(
+                        p for p in (index_param, index_param_temp) if p
+                    )
+
+            collection_ids = []
+            for collections, _ in cql2_collection_datetime:
+                if isinstance(collections, list):
+                    collection_ids.extend(collections)
+                else:
+                    collection_ids.append(collections)
+        else:
+            index_param = await self.async_index_selector.select_indexes(
+                collection_ids, datetime_search
+            )
         if len(index_param) > ES_MAX_URL_LENGTH - 300:
             index_param = ITEM_INDICES
             query = add_collections_to_body(collection_ids, query)

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter/datetime_optimizer.py

@@ -127,44 +127,108 @@ def _contains_datetime(self, node: CqlNode) -> bool:
 def extract_from_ast(node: CqlNode, field_name: str):
     """Extract values from AST for a given field."""
     values = []
-    datetime_start = None
-    datetime_end = None
 
     def recurse(n):
-        nonlocal datetime_start, datetime_end
-
+        """Run field extraction in recursion."""
         if hasattr(n, "children"):
             for child in n.children:
                 recurse(child)
 
         if hasattr(n, "field") and hasattr(n, "value"):
             if n.field == field_name:
-                if field_name == "datetime":
-                    op = getattr(n, "op", None)
-                    if op == ComparisonOp.GTE:
-                        datetime_start = n.value
-                    elif op == ComparisonOp.LTE:
-                        datetime_end = n.value
-                    else:
-                        values.append(n.value)
+                if isinstance(n.value, list):
+                    values.extend(n.value)
                 else:
-                    if isinstance(n.value, list):
-                        values.extend(n.value)
-                    else:
-                        values.append(n.value)
+                    values.append(n.value)
+        # Handle datetime range optimization
+        elif hasattr(n, "op") and n.op == LogicalOp.AND and hasattr(n, "children"):
+            # Check if this is a datetime range (GTE and LTE on datetime field)
+            datetime_nodes = []
+            for child in n.children:
+                if (
+                    hasattr(child, "field")
+                    and child.field == "datetime"
+                    and hasattr(child, "op")
+                    and hasattr(child, "value")
+                ):
+                    datetime_nodes.append(child)
+
+            if len(datetime_nodes) == 2:
+                # Check if we have both GTE and LTE for datetime
+                gte_node = None
+                lte_node = None
+                for d_node in datetime_nodes:
+                    if d_node.op == ComparisonOp.GTE:
+                        gte_node = d_node
+                    elif d_node.op == ComparisonOp.LTE:
+                        lte_node = d_node
+
+                if gte_node and lte_node:
+                    values.append(
+                        {
+                            "type": "range",
+                            "start": gte_node.value,
+                            "end": lte_node.value,
+                        }
+                    )
 
     recurse(node)
 
-    if field_name == "datetime":
-        if datetime_start and datetime_end:
-            return f"{datetime_start}/{datetime_end}"
-        elif datetime_start:
-            return f"{datetime_start}/.."
-        elif datetime_end:
-            return f"../{datetime_end}"
-        elif values:
-            return values[0]
-        else:
-            return None
-
-    return values
+    return values if values else None
+
+
+def extract_collection_datetime(node):
+    """Get (collection, datetime_range) pairs from node."""
+    pairs = []
+
+    def recurse(n):
+        # Check if this is an AND node (we're looking for AND clauses)
+        if hasattr(n, "op") and hasattr(n.op, "value") and n.op.value == "and":
+            collection = None
+            gte_date = None
+            lte_date = None
+
+            # Look through all children of this AND node
+            if hasattr(n, "children"):
+                for child in n.children:
+                    # Check if it's a comparison node
+                    if (
+                        hasattr(child, "op")
+                        and hasattr(child, "field")
+                        and hasattr(child, "value")
+                    ):
+                        if child.field == "collection":
+                            collection = child.value
+                        elif child.field in [
+                            "datetime",
+                            "start_datetime",
+                            "end_datetime",
+                        ]:  # Handle all datetime fields
+                            if hasattr(child.op, "value"):
+                                if child.op.value == ">=":
+                                    gte_date = child.value
+                                elif child.op.value == "<=":
+                                    lte_date = child.value
+
+            # If we found dates, add to pairs (even without collection)
+            if gte_date or lte_date:
+                if gte_date and lte_date:
+                    date_range = f"{gte_date}/{lte_date}"
+                elif gte_date:
+                    date_range = f"{gte_date}/.."
+                elif lte_date:
+                    date_range = f"../{lte_date}"
+
+                # Add to pairs - if no collection, use empty string
+                pairs.append((collection or "", date_range))
+            # If we found a collection but no dates
+            elif collection is not None:
+                pairs.append((collection, ""))
+
+        # Continue searching through children
+        if hasattr(n, "children"):
+            for child in n.children:
+                recurse(child)
+
+    recurse(node)
+    return pairs