pytrilogy 0.0.1.111__tar.gz → 0.0.1.112__tar.gz

{pytrilogy-0.0.1.111/pytrilogy.egg-info → pytrilogy-0.0.1.112}/PKG-INFO

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

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112}/tests/test_parsing.py

@@ -1,4 +1,4 @@
-from trilogy.core.enums import Purpose
+from trilogy.core.enums import Purpose, ComparisonOperator
 from trilogy.core.models import (
     DataType,
     Parenthetical,
@@ -6,6 +6,7 @@ from trilogy.core.models import (
     ShowStatement,
     SelectStatement,
     Environment,
+    Comparison,
 )
 from trilogy.core.functions import argument_to_purpose, function_args_to_output_purpose
 from trilogy.parsing.parse_engine import (
@@ -217,3 +218,25 @@ select
     for name in ["test_name_count"]:
         assert name in env.concepts
         assert env.concepts[name].purpose == Purpose.METRIC
+
+
+def test_between():
+    _, parsed = parse_text(
+        "const order_id <- 4; SELECT order_id  WHERE order_id BETWEEN 3 and 5;"
+    )
+    query: ProcessedQuery = parsed[-1]
+    left = query.where_clause.conditional.left
+    assert isinstance(
+        left,
+        Comparison,
+    ), type(left)
+    assert left.operator == ComparisonOperator.GTE
+    assert left.right == 3
+
+    right = query.where_clause.conditional.right
+    assert isinstance(
+        right,
+        Comparison,
+    ), type(right)
+    assert right.operator == ComparisonOperator.LTE
+    assert right.right == 5

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.1.111"
+__version__ = "0.0.1.112"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112}/trilogy/core/models.py

@@ -2041,6 +2041,14 @@ class CTE(BaseModel):
         ds_being_inlined = qds_being_inlined.datasources[0]
         if not isinstance(ds_being_inlined, Datasource):
             return False
+        if any(
+            [
+                x.identifier == ds_being_inlined.identifier
+                for x in self.source.datasources
+            ]
+        ):
+            return False
+
         self.source.datasources = [
             ds_being_inlined,
             *[

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112}/trilogy/core/optimization.py

@@ -12,9 +12,6 @@ from trilogy.constants import logger, CONFIG
 from abc import ABC
 
 
-REGISTERED_RULES: list["OptimizationRule"] = []
-
-
 class OptimizationRule(ABC):
 
     def optimize(self, cte: CTE, inverse_map: dict[str, list[CTE]]) -> bool:
@@ -66,13 +63,15 @@ class InlineDatasource(OptimizationRule):
             to_inline.append(parent_cte)
 
         for replaceable in to_inline:
-            self.log(f"Inlining parent {replaceable.name}")
-            cte.inline_parent_datasource(replaceable, force_group=force_group)
 
+            result = cte.inline_parent_datasource(replaceable, force_group=force_group)
+            if result:
+                self.log(f"Inlined parent {replaceable.name}")
+            else:
+                self.log(f"Failed to inline {replaceable.name}")
         return optimized
 
 
-# This will be used in the future for more complex condition decomposition
 def decompose_condition(conditional: Conditional):
     chunks = []
     if conditional.operator == BooleanOperator.AND:
@@ -154,12 +153,6 @@ class PredicatePushdown(OptimizationRule):
         return optimized
 
 
-if CONFIG.optimizations.datasource_inlining:
-    REGISTERED_RULES.append(InlineDatasource())
-if CONFIG.optimizations.predicate_pushdown:
-    REGISTERED_RULES.append(PredicatePushdown())
-
-
 def filter_irrelevant_ctes(
     input: list[CTE],
     root_cte: CTE,
@@ -233,6 +226,12 @@ def optimize_ctes(
     input: list[CTE], root_cte: CTE, select: SelectStatement | MultiSelectStatement
 ):
     complete = False
+    REGISTERED_RULES: list["OptimizationRule"] = []
+
+    if CONFIG.optimizations.datasource_inlining:
+        REGISTERED_RULES.append(InlineDatasource())
+    if CONFIG.optimizations.predicate_pushdown:
+        REGISTERED_RULES.append(PredicatePushdown())
 
     while not complete:
         actions_taken = False

{pytrilogy-0.0.1.111 → pytrilogy-0.0.1.112}/trilogy/parsing/parse_engine.py

@@ -250,6 +250,8 @@ grammar = r"""
     
     comparison: (expr COMPARISON_OPERATOR expr) 
 
+    between_comparison: expr "BETWEEN"i expr "AND"i expr
+
     subselect_comparison: expr array_comparison expr | (expr array_comparison expr_tuple)
     
     expr_tuple: "("  (expr ",")* expr ","?  ")"
@@ -262,7 +264,7 @@ grammar = r"""
 
     parenthetical: "(" (conditional | expr) ")"
     
-    expr:  window_item | filter_item | comparison | subselect_comparison | fgroup |  aggregate_functions | unnest | _string_functions | _math_functions | _generic_functions | _constant_functions| _date_functions |  literal |  expr_reference  | index_access | attr_access |  parenthetical
+    expr:  window_item | filter_item | between_comparison | comparison | subselect_comparison | fgroup |  aggregate_functions | unnest | _string_functions | _math_functions | _generic_functions | _constant_functions| _date_functions |  literal |  expr_reference  | index_access | attr_access |  parenthetical
     
     // functions
     
@@ -1241,6 +1243,19 @@ class ParseToObjects(Transformer):
             raise SyntaxError
         return Comparison(left=args[0], right=args[2], operator=args[1])
 
+    def between_comparison(self, args) -> Conditional:
+        left_bound = args[1]
+        right_bound = args[2]
+        return Conditional(
+            left=Comparison(
+                left=args[0], right=left_bound, operator=ComparisonOperator.GTE
+            ),
+            right=Comparison(
+                left=args[0], right=right_bound, operator=ComparisonOperator.LTE
+            ),
+            operator=BooleanOperator.AND,
+        )
+
     @v_args(meta=True)
     def subselect_comparison(self, meta: Meta, args) -> SubselectComparison:
         right = args[2]