pytrilogy 0.0.1.112__tar.gz → 0.0.1.114__tar.gz

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

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

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

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

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/pytrilogy.egg-info/SOURCES.txt

@@ -93,5 +93,6 @@ trilogy/parsing/exceptions.py
 trilogy/parsing/helpers.py
 trilogy/parsing/parse_engine.py
 trilogy/parsing/render.py
+trilogy/parsing/trilogy.lark
 trilogy/scripts/__init__.py
 trilogy/scripts/trilogy.py

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/setup.py

@@ -40,7 +40,7 @@ setuptools.setup(
         ]
     ),
     package_data={
-        "": ["*.tf", "*.jinja", "py.typed"],
+        "": ["*.tf", "*.jinja", "py.typed", "*.lark"],
     },
     install_requires=install_requires,
     extras_require={

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/tests/test_declarations.py

@@ -4,7 +4,7 @@ from trilogy.parser import parse
 def test_declarations():
     declarations = """key namespace.user_id int metadata(description="the description");
     metric namespace.count <- count(namespace.user_id);
-    metric namespace.distinct_count <- count_distinct(namespace.user_id); # the distinct count of user ids
+    metric namespace.distinct_count <- count_distinct(namespace.user_id); #the distinct count of user ids
     """
     env, _ = parse(declarations)
 
@@ -14,3 +14,5 @@ def test_declarations():
         env.concepts["namespace.distinct_count"].metadata.description
         == "the distinct count of user ids"
     )
+
+    assert env.concepts["namespace.user_id"].metadata.description == "the description"

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

@@ -211,7 +211,7 @@ rowset test<- select
     ;
 
 select 
-    count(test.name) -> test_name_count;
+    count( test.name ) -> test_name_count;
 """
     )
     # assert output_purpose == Purpose.METRIC
@@ -240,3 +240,26 @@ def test_between():
     ), type(right)
     assert right.operator == ComparisonOperator.LTE
     assert right.right == 5
+
+
+def test_the_comments():
+    _, parsed = parse_text(
+        """const
+         # comment here?
+           order_id <- 4; SELECT 
+        # TOOD - add in more columns?
+        order_id   # this is the order id
+        WHERE 
+        # order_id should not be null
+        order_id
+        # in this comp
+          is not 
+        null; # nulls are the worst
+        
+        """
+    )
+    query = parsed[-1]
+    right = query.where_clause.conditional.right
+    assert isinstance(right, MagicConstants), type(right)
+    rendered = BaseDialect().render_expr(right)
+    assert rendered == "null"

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/tests/test_select.py

@@ -37,6 +37,7 @@ datasource users (
     env, parsed = parse(declarations)
 
     q1 = """select
+    # a comment
     user_id,
     about_me,
     count(post_id)->post_count

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/tests/test_where_clause.py

@@ -150,7 +150,7 @@ select
     order_id,
     total_revenue,
 where 
-(order_id =1 or order_id = 2) and total_revenue>30
+(order_id = 1 or order_id = 2) and total_revenue>30
 ;
 
 

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/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.112"
+__version__ = "0.0.1.114"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/trilogy/core/enums.py

@@ -76,6 +76,12 @@ class JoinType(Enum):
 class Ordering(Enum):
     ASCENDING = "asc"
     DESCENDING = "desc"
+    ASC_NULLS_AUTO = "asc nulls auto"
+    ASC_NULLS_FIRST = "asc nulls first"
+    ASC_NULLS_LAST = "asc nulls last"
+    DESC_NULLS_FIRST = "desc nulls first"
+    DESC_NULLS_LAST = "desc nulls last"
+    DESC_NULLS_AUTO = "desc nulls auto"
 
 
 class WindowType(Enum):
@@ -220,6 +226,7 @@ class ComparisonOperator(Enum):
     ILIKE = "ilike"
     CONTAINS = "contains"
     ELSE = "else"
+    BETWEEN = "between"
 
     @classmethod
     def _missing_(cls, value):

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

@@ -812,6 +812,7 @@ class Function(Namespaced, SelectGrain, BaseModel):
             "Parenthetical",
             CaseWhen,
             "CaseElse",
+            list,
             ListWrapper[int],
             ListWrapper[str],
             ListWrapper[float],
@@ -996,6 +997,7 @@ class WindowItem(Namespaced, SelectGrain, BaseModel):
     content: Concept
     order_by: List["OrderItem"]
     over: List["Concept"] = Field(default_factory=list)
+    index: Optional[int] = None
 
     def with_namespace(self, namespace: str) -> "WindowItem":
         return WindowItem(
@@ -2735,6 +2737,14 @@ class Comparison(ConceptArgs, Namespaced, SelectGrain, BaseModel):
             raise SyntaxError(
                 f"Cannot compare {self.left} and {self.right} of different types"
             )
+        if self.operator == ComparisonOperator.BETWEEN:
+            if (
+                not isinstance(self.right, ComparisonOperator)
+                and self.right.operator == BooleanOperator.AND
+            ):
+                raise SyntaxError(
+                    f"Between operator must have two operands with and, not {self.right}"
+                )
 
     def __add__(self, other):
         if not isinstance(other, (Comparison, Conditional, Parenthetical)):
@@ -2810,6 +2820,29 @@ class Comparison(ConceptArgs, Namespaced, SelectGrain, BaseModel):
         output += get_concept_arguments(self.right)
         return output
 
+    @property
+    def row_arguments(self) -> List[Concept]:
+        output = []
+        if isinstance(self.left, ConceptArgs):
+            output += self.left.row_arguments
+        else:
+            output += get_concept_arguments(self.left)
+        if isinstance(self.right, ConceptArgs):
+            output += self.right.row_arguments
+        else:
+            output += get_concept_arguments(self.right)
+        return output
+
+    @property
+    def existence_arguments(self) -> List[Tuple[Concept, ...]]:
+        """Return concepts directly referenced in where clause"""
+        output: List[Tuple[Concept, ...]] = []
+        if isinstance(self.left, ConceptArgs):
+            output += self.left.existence_arguments
+        if isinstance(self.right, ConceptArgs):
+            output += self.right.existence_arguments
+        return output
+
 
 class SubselectComparison(Comparison):
 
@@ -2909,6 +2942,7 @@ class Conditional(ConceptArgs, Namespaced, SelectGrain, BaseModel):
         float,
         list,
         bool,
+        MagicConstants,
         Concept,
         Comparison,
         "Conditional",
@@ -2922,11 +2956,13 @@ class Conditional(ConceptArgs, Namespaced, SelectGrain, BaseModel):
         float,
         list,
         bool,
+        MagicConstants,
         Concept,
         Comparison,
         "Conditional",
         "Parenthetical",
         Function,
+        FilterItem,
     ]
     operator: BooleanOperator
 

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/trilogy/dialect/base.py

@@ -10,6 +10,7 @@ from trilogy.core.enums import (
     WindowType,
     DatePart,
     PurposeLineage,
+    ComparisonOperator,
 )
 from trilogy.core.models import (
     ListType,
@@ -58,17 +59,23 @@ def INVALID_REFERENCE_STRING(x: Any, callsite: str = ""):
 
 
 def window_factory(string: str, include_concept: bool = False) -> Callable:
-    def render_window(concept: str, window: str, sort: str) -> str:
+    def render_window(
+        concept: str, window: str, sort: str, offset: int | None = None
+    ) -> str:
         if not include_concept:
             concept = ""
+        if offset:
+            base = f"{string}({concept}, {offset})"
+        else:
+            base = f"{string}({concept})"
         if window and sort:
-            return f"{string}({concept}) over (partition by {window} order by {sort} )"
+            return f"{base} over (partition by {window} order by {sort} )"
         elif window:
-            return f"{string}({concept}) over (partition by {window})"
+            return f"{base} over (partition by {window})"
         elif sort:
-            return f"{string}({concept}) over (order by {sort} )"
+            return f"{base} over (order by {sort} )"
         else:
-            return f"{string}({concept}) over ()"
+            return f"{base} over ()"
 
     return render_window
 
@@ -109,10 +116,10 @@ FUNCTION_MAP = {
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.UNNEST: lambda x: f"unnest({x[0]})",
     # math
-    FunctionType.ADD: lambda x: f"({x[0]} + {x[1]})",
-    FunctionType.SUBTRACT: lambda x: f"({x[0]} - {x[1]})",
-    FunctionType.DIVIDE: lambda x: f"({x[0]} / {x[1]})",
-    FunctionType.MULTIPLY: lambda x: f"({x[0]} * {x[1]})",
+    FunctionType.ADD: lambda x: f"{x[0]} + {x[1]}",
+    FunctionType.SUBTRACT: lambda x: f"{x[0]} - {x[1]}",
+    FunctionType.DIVIDE: lambda x: f"{x[0]} / {x[1]}",
+    FunctionType.MULTIPLY: lambda x: f"{x[0]} * {x[1]}",
     FunctionType.ROUND: lambda x: f"round({x[0]},{x[1]})",
     FunctionType.MOD: lambda x: f"({x[0]} % {x[1]})",
     # aggregate types
@@ -355,17 +362,30 @@ class BaseDialect:
                     lookup = lookup_cte.existence_source_map[e.right.address]
 
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} (select {lookup[0]}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {lookup[0]})"
-            elif isinstance(e.right, (ListWrapper, Parenthetical)):
+            elif isinstance(e.right, (ListWrapper, Parenthetical, list)):
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
-            elif isinstance(e.right, (str, int, bool, float, list)):
+
+            elif isinstance(
+                e.right,
+                (
+                    str,
+                    int,
+                    bool,
+                    float,
+                ),
+            ):
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} ({self.render_expr(e.right, cte=cte, cte_map=cte_map)})"
             else:
-                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} ({self.render_expr(e.right, cte=cte, cte_map=cte_map)})"
+                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
         elif isinstance(e, Comparison):
+            if e.operator == ComparisonOperator.BETWEEN:
+                right_comp = e.right
+                assert isinstance(right_comp, Conditional)
+                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(right_comp.left, cte=cte, cte_map=cte_map) and self.render_expr(right_comp.right, cte=cte, cte_map=cte_map)}"
             return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
         elif isinstance(e, Conditional):
             # conditions need to be nested in parentheses
-            return f"( {self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)} ) "
+            return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
         elif isinstance(e, WindowItem):
             rendered_order_components = [
                 f"{self.render_expr(x.expr, cte, cte_map=cte_map)} {x.order.value}"
@@ -375,11 +395,11 @@ class BaseDialect:
                 self.render_expr(x, cte, cte_map=cte_map) for x in e.over
             ]
             return f"{self.WINDOW_FUNCTION_MAP[e.type](concept = self.render_expr(e.content, cte=cte, cte_map=cte_map), window=','.join(rendered_over_components), sort=','.join(rendered_order_components))}"  # noqa: E501
-        elif isinstance(e, FilterItem):
-            return f"CASE WHEN {self.render_expr(e.where.conditional, cte=cte, cte_map=cte_map)} THEN  {self.render_expr(e.content, cte=cte, cte_map=cte_map)} ELSE 0 END"
         elif isinstance(e, Parenthetical):
             # conditions need to be nested in parentheses
-            return f"( {self.render_expr(e.content, cte=cte, cte_map=cte_map)} ) "
+            if isinstance(e.content, list):
+                return f"( {','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e.content])} )"
+            return f"( {self.render_expr(e.content, cte=cte, cte_map=cte_map)} )"
         elif isinstance(e, CaseWhen):
             return f"WHEN {self.render_expr(e.comparison, cte=cte, cte_map=cte_map) } THEN {self.render_expr(e.expr, cte=cte, cte_map=cte_map) }"
         elif isinstance(e, CaseElse):
@@ -412,7 +432,7 @@ class BaseDialect:
         elif isinstance(e, ListWrapper):
             return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}]"
         elif isinstance(e, list):
-            return f"{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}"
+            return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}]"
         elif isinstance(e, DataType):
             return str(e.value)
         elif isinstance(e, DatePart):

{pytrilogy-0.0.1.112 → pytrilogy-0.0.1.114}/trilogy/parsing/common.py

@@ -41,7 +41,7 @@ def concept_list_to_keys(concepts: Tuple[Concept, ...]) -> Tuple[Concept, ...]:
 
 
 def constant_to_concept(
-    parent: ListWrapper | int | float | str,
+    parent: ListWrapper | list | int | float | str,
     name: str,
     namespace: str,
     purpose: Purpose | None = None,