pytrilogy 0.0.3.53__tar.gz → 0.0.3.54__tar.gz

{pytrilogy-0.0.3.53/pytrilogy.egg-info → pytrilogy-0.0.3.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.53
+Version: 0.0.3.54
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.53
+Version: 0.0.3.54
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.53"
+__version__ = "0.0.3.54"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/core/optimization.py

@@ -120,6 +120,13 @@ def gen_inverse_map(input: list[CTE | UnionCTE]) -> dict[str, list[CTE | UnionCT
     return inverse_map
 
 
+SENSITIVE_DERIVATIONS = [
+    Derivation.UNNEST,
+    Derivation.WINDOW,
+    # Derivation.AGGREGATE,
+]
+
+
 def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
     # if isinstance(select, (PersistStatement, MultiSelectStatement)):
     #     return False
@@ -151,21 +158,31 @@ def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
     ]
     condition_arguments = cte.condition.row_arguments if cte.condition else []
     for x in derived_concepts:
-        if x.derivation == Derivation.WINDOW:
-            return None
-        if x.derivation == Derivation.UNNEST:
-            return None
-        if x.derivation == Derivation.AGGREGATE:
+        if x.derivation in SENSITIVE_DERIVATIONS:
             return None
     for x in parent_derived_concepts:
         if x.address not in condition_arguments:
             continue
-        if x.derivation == Derivation.UNNEST:
-            return None
-        if x.derivation == Derivation.WINDOW:
+        if x.derivation in SENSITIVE_DERIVATIONS:
             return None
+    for x in condition_arguments:
+        # if it's derived in the parent
+        if x.address in parent_derived_concepts:
+            if x.derivation in SENSITIVE_DERIVATIONS:
+                return None
+            # this maybe needs to be recursive if we flatten a ton of derivation
+            # into one CTE
+            if not x.lineage:
+                continue
+            for z in x.lineage.concept_arguments:
+                # if it was preexisting in the parent, it's safe
+                if z.address in direct_parent.source.input_concepts:
+                    continue
+                # otherwise if it's dangerous, play it safe.
+                if z.derivation in SENSITIVE_DERIVATIONS:
+                    return None
     logger.info(
-        f"[Optimization][EarlyReturn] Removing redundant output CTE with derived_concepts {[x.address for x in derived_concepts]}"
+        f"[Optimization][EarlyReturn] Removing redundant output CTE {cte.name} with derived_concepts {[x.address for x in derived_concepts]}"
     )
     return direct_parent
 

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/core/processing/node_generators/rowset_node.py

@@ -95,9 +95,7 @@ def gen_rowset_node(
         f"{padding(depth)}{LOGGER_PREFIX} hiding {final_hidden} local optional {local_optional}"
     )
     node.hide_output_concepts(final_hidden)
-    assert node.resolution_cache
-    # assume grain to be output of select
-    # but don't include anything hidden(the non-rowset concepts)
+
     node.grain = BuildGrain.from_concepts(
         [
             x

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/core/processing/node_generators/window_node.py

@@ -11,7 +11,12 @@ from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.node_generators.common import (
     gen_enrichment_node,
 )
-from trilogy.core.processing.nodes import History, StrategyNode, WindowNode
+from trilogy.core.processing.nodes import (
+    History,
+    StrategyNode,
+    WhereSafetyNode,
+    WindowNode,
+)
 from trilogy.core.processing.utility import create_log_lambda, padding
 from trilogy.utility import unique
 
@@ -71,10 +76,13 @@ def gen_window_node(
     if equivalent_optional:
         for x in equivalent_optional:
             assert isinstance(x.lineage, WINDOW_TYPES)
+            base, parents = resolve_window_parent_concepts(x, environment)
             logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} found equivalent optional {x} with parents {resolve_window_parent_concepts(x, environment)[1]}"
+                f"{padding(depth)}{LOGGER_PREFIX} found equivalent optional {x} with parents {parents}"
             )
             additional_outputs.append(x)
+            # also append the base concept it's being grouped over
+            targets.append(base)
 
     grain_equivalents = [
         x
@@ -85,7 +93,8 @@ def gen_window_node(
     ]
 
     for x in grain_equivalents:
-        logger.info("Appending grain equivalent %s", x)
+        if x.address in additional_outputs:
+            continue
         targets.append(x)
 
     # finally, the ones we'll need to enrich
@@ -134,7 +143,7 @@ def gen_window_node(
     _window_node.rebuild_cache()
     _window_node.resolve()
 
-    window_node = StrategyNode(
+    window_node = WhereSafetyNode(
         input_concepts=[concept] + additional_outputs + parent_concepts + targets,
         output_concepts=[concept] + additional_outputs + parent_concepts + targets,
         environment=environment,

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/core/processing/nodes/__init__.py

@@ -6,7 +6,7 @@ from trilogy.core.models.build import BuildConcept, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.models.environment import Environment
 
-from .base_node import NodeJoin, StrategyNode
+from .base_node import NodeJoin, StrategyNode, WhereSafetyNode
 from .filter_node import FilterNode
 from .group_node import GroupNode
 from .merge_node import MergeNode
@@ -193,4 +193,5 @@ __all__ = [
     "UnnestNode",
     "UnionNode",
     "History",
+    "WhereSafetyNode",
 ]

{pytrilogy-0.0.3.53 → pytrilogy-0.0.3.54}/trilogy/core/processing/nodes/base_node.py

@@ -291,9 +291,14 @@ class StrategyNode:
     def add_output_concept(self, concept: BuildConcept, rebuild: bool = True):
         return self.add_output_concepts([concept], rebuild)
 
-    def hide_output_concepts(self, concepts: List[BuildConcept], rebuild: bool = True):
+    def hide_output_concepts(
+        self, concepts: List[BuildConcept] | list[str] | set[str], rebuild: bool = True
+    ):
         for x in concepts:
-            self.hidden_concepts.add(x.address)
+            if isinstance(x, BuildConcept):
+                self.hidden_concepts.add(x.address)
+            else:
+                self.hidden_concepts.add(x)
         if rebuild:
             self.rebuild_cache()
         return self
@@ -471,3 +476,28 @@ class NodeJoin:
             f" {self.right_node} on"
             f" {','.join([str(k) for k in self.concepts])}"
         )
+
+
+class WhereSafetyNode(StrategyNode):
+    """Specialized node to be used to pad certain
+    select outputs that can't be immediately used in a where
+    clause; eg window functions. Will remove itself if not required."""
+
+    def resolve(self) -> QueryDatasource:
+        if not self.conditions and len(self.parents) == 1:
+            parent = self.parents[0]
+            parent = parent.copy()
+            # avoid performance hit by not rebuilding until end
+            parent.set_output_concepts(self.output_concepts, rebuild=False)
+            parent.hide_output_concepts(self.hidden_concepts, rebuild=False)
+
+            # these conditions
+            if self.preexisting_conditions:
+                parent.set_preexisting_conditions(self.preexisting_conditions)
+            # TODO: add a helper for this
+            parent.ordering = self.ordering
+
+            # actually build the node
+            parent.rebuild_cache()
+            return parent.resolve()
+        return super().resolve()