pytrilogy 0.0.3.7__tar.gz → 0.0.3.9__tar.gz

{pytrilogy-0.0.3.7/pytrilogy.egg-info → pytrilogy-0.0.3.9}/PKG-INFO

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

{pytrilogy-0.0.3.7 → pytrilogy-0.0.3.9/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.7 → pytrilogy-0.0.3.9}/pytrilogy.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ tests/test_select.py
 tests/test_show.py
 tests/test_statements.py
 tests/test_undefined_concept.py
+tests/test_user_functions.py
 tests/test_where_clause.py
 trilogy/__init__.py
 trilogy/compiler.py

{pytrilogy-0.0.3.7 → pytrilogy-0.0.3.9}/tests/test_models.py

@@ -219,10 +219,14 @@ def test_comparison():
     # this should not error
     Comparison(left=1, right=[1, 2, 3], operator=ComparisonOperator.IN)
 
-    Comparison(left=1, right=ListWrapper([1, 2, 3]), operator=ComparisonOperator.IN)
+    Comparison(
+        left=1,
+        right=ListWrapper([1, 2, 3], type=DataType.INTEGER),
+        operator=ComparisonOperator.IN,
+    )
 
 
-def test_comparison():
+def test_comparison_invalid_type():
     try:
         Comparison(left=1, right="abc", operator=ComparisonOperator.EQ)
     except Exception as exc:

{pytrilogy-0.0.3.7 → pytrilogy-0.0.3.9}/tests/test_select.py

@@ -222,12 +222,14 @@ property id.class int;
 property id.name string;
 
 auto class_count <- count(class);
-auto name_count <- count(name);
+auto name_count <- count(name) by class;
+
+auto test_ratio <- name_count / sum name_count over class;
 
 select
     class,
     count(class) -> name_count,
-    (name_count / sum name_count over class) -> name_class_ratio,
+    name_count / sum name_count over class -> name_class_ratio,
 ;
 """
     env, statements = env.parse(q1)
@@ -236,6 +238,5 @@ select
     assert select.grain.components == {
         "local.class",
     }
-    assert select.local_concepts["local.name_class_ratio"].grain.components == {
-        "local.class",
-    }
+    benv = env.materialize_for_select()
+    assert benv.concepts["test_ratio"].keys == {"local.class", "local.id"}

pytrilogy-0.0.3.9/tests/test_user_functions.py

@@ -0,0 +1,206 @@
+from trilogy import Dialects
+from trilogy.core.enums import Derivation, Purpose
+
+
+def test_user_function_def():
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+def percent_ratio(a, b, digits=3) -> round(a::float / b * 100, digits);
+
+                 
+select @percent_ratio(10, 100) as ratio;
+                 
+                 """
+    )
+
+    assert results.fetchall()[0].ratio == 10.0
+
+
+def test_user_function_aggregate():
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+key x int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+def sum_times(a)-> a * sum(x);
+
+                 
+select @sum_times(10) as total;
+                 
+                 """
+    )
+
+    assert results.fetchall()[0].total == 130
+
+
+def test_user_function_nested():
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+key x int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+def sum_times(a)-> a * sum(x + price);
+
+                 
+select @sum_times(10) as total;
+                 
+                 """
+    )
+
+    assert results.fetchall()[0].total == 230
+
+
+def test_user_function_nested_rowset():
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+key x int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+def sum_times(a)-> a * sum(x + price);
+
+with rowset as  
+select @sum_times(10) as total;
+
+select rowset.total;
+                 
+                 """
+    )
+
+    assert results.fetchall()[0].rowset_total == 230
+
+
+def test_user_function_case():
+    from trilogy.hooks.query_debugger import DebuggingHook
+
+    DebuggingHook()
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+key x int;
+key y int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+datasource join_x_y (
+x: x,
+y: y)
+grain (x, y)
+query '''
+select 1 as x, 1 as y
+union all
+select 2 as x, 1 as y
+union all
+select 10 as x, 2 as y
+''';
+
+def weekday_sales(weekday) ->  
+    SUM(CASE WHEN 10 = weekday THEN x ELSE 0 END) + 
+    SUM(CASE WHEN 10 = weekday THEN price ELSE 0.0 END)
+;
+
+
+select 
+    y,
+    @weekday_sales(10) -> test
+order by y asc;
+                
+"""
+    )
+    results = results.fetchall()
+    assert results[0].test == 8
+    assert results[1].test == 15
+
+
+def test_parsing():
+    x = Dialects.DUCK_DB.default_executor()
+    x.execute_query(
+        """
+key x int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+
+auto test <-SUM(CASE WHEN 10 = weekday THEN x ELSE 0 END) + 
+    SUM(CASE WHEN 10 = weekday THEN price ELSE 0.0 END);
+
+
+
+                 
+"""
+    )
+    test = x.environment.concepts["test"]
+    assert test.keys == set()
+    assert test.purpose == Purpose.METRIC
+    assert test.derivation == Derivation.BASIC

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

{pytrilogy-0.0.3.7 → pytrilogy-0.0.3.9}/trilogy/core/models/author.py

@@ -75,6 +75,9 @@ class Mergeable(ABC):
     def with_merge(self, source: Concept, target: Concept, modifiers: List[Modifier]):
         raise NotImplementedError
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        raise NotImplementedError(type(self))
+
 
 class ConceptArgs(ABC):
     @property
@@ -152,6 +155,11 @@ class ConceptRef(Addressable, Namespaced, DataTyped, Mergeable, BaseModel):
             metadata=self.metadata,
         )
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        if self.address == source:
+            return target
+        return self
+
 
 class UndefinedConcept(ConceptRef):
     pass
@@ -409,7 +417,7 @@ class Grain(Namespaced, BaseModel):
     ) -> Grain:
         from trilogy.parsing.common import concepts_to_grain_concepts
 
-        return Grain.model_construct(
+        x = Grain.model_construct(
             components={
                 c.address
                 for c in concepts_to_grain_concepts(concepts, environment=environment)
@@ -417,6 +425,8 @@ class Grain(Namespaced, BaseModel):
             where_clause=where_clause,
         )
 
+        return x
+
     def with_namespace(self, namespace: str) -> "Grain":
         return Grain.model_construct(
             components={address_with_namespace(c, namespace) for c in self.components},
@@ -537,6 +547,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         MagicConstants,
         WindowItem,
         AggregateWrapper,
+        FilterItem,
     ]
     right: Union[
         int,
@@ -556,6 +567,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         WindowItem,
         AggregateWrapper,
         TupleWrapper,
+        FilterItem,
     ]
     operator: ComparisonOperator
 
@@ -662,6 +674,21 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
             operator=self.operator,
         )
 
+    def with_reference_replacement(self, source, target):
+        return self.__class__.model_construct(
+            left=(
+                self.left.with_reference_replacement(source, target)
+                if isinstance(self.left, Mergeable)
+                else self.left
+            ),
+            right=(
+                self.right.with_reference_replacement(source, target)
+                if isinstance(self.right, Mergeable)
+                else self.right
+            ),
+            operator=self.operator,
+        )
+
     def with_namespace(self, namespace: str):
         return self.__class__.model_construct(
             left=(
@@ -1224,7 +1251,7 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
     def with_merge(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ) -> "OrderItem":
-        return OrderItem(
+        return OrderItem.model_construct(
             expr=(
                 self.expr.with_merge(source, target, modifiers)
                 if isinstance(self.expr, Mergeable)
@@ -1233,19 +1260,19 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
             order=self.order,
         )
 
-    @property
-    def output(self):
-        return self.expr.output
+    def with_reference_replacement(self, source, target):
+        return OrderItem.model_construct(
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            order=self.order,
+        )
 
     @property
     def concept_arguments(self) -> Sequence[ConceptRef]:
-        base: List[ConceptRef] = []
-        x = self.expr
-        if isinstance(x, ConceptRef):
-            base += [x]
-        elif isinstance(x, ConceptArgs):
-            base += x.concept_arguments
-        return base
+        return get_concept_arguments(self.expr)
 
     @property
     def row_arguments(self) -> Sequence[ConceptRef]:
@@ -1305,6 +1332,17 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         )
         return output
 
+    def with_reference_replacement(self, source, target):
+        return WindowItem.model_construct(
+            type=self.type,
+            content=self.content.with_reference_replacement(source, target),
+            over=[x.with_reference_replacement(source, target) for x in self.over],
+            order_by=[
+                x.with_reference_replacement(source, target) for x in self.order_by
+            ],
+            index=self.index,
+        )
+
     def with_namespace(self, namespace: str) -> "WindowItem":
         return WindowItem.model_construct(
             type=self.type,
@@ -1316,31 +1354,19 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
 
     @property
     def concept_arguments(self) -> List[ConceptRef]:
-        return self.arguments
-
-    @property
-    def arguments(self) -> List[ConceptRef]:
         output = [self.content]
         for order in self.order_by:
-            output += [order.output]
+            output += get_concept_arguments(order)
         for item in self.over:
-            output += [item]
+            output += get_concept_arguments(item)
         return output
 
-    @property
-    def output(self) -> ConceptRef:
-        return self.content
-
     @property
     def output_datatype(self):
         if self.type in (WindowType.RANK, WindowType.ROW_NUMBER):
             return DataType.INTEGER
         return self.content.output_datatype
 
-    @property
-    def output_purpose(self):
-        return Purpose.PROPERTY
-
 
 def get_basic_type(
     type: DataType | ListType | StructType | MapType | NumericType,
@@ -1407,12 +1433,28 @@ class CaseWhen(Namespaced, ConceptArgs, Mergeable, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return CaseWhen.model_construct(
+            comparison=self.comparison.with_reference_replacement(source, target),
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+        )
+
 
 class CaseElse(Namespaced, ConceptArgs, Mergeable, BaseModel):
     expr: "Expr"
     # this ensures that it's easily differentiable from CaseWhen
     discriminant: ComparisonOperator = ComparisonOperator.ELSE
 
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return f"ELSE {str(self.expr)}"
+
     @field_validator("expr", mode="before")
     def enforce_expr(cls, v):
         if isinstance(v, Concept):
@@ -1435,6 +1477,19 @@ class CaseElse(Namespaced, ConceptArgs, Mergeable, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return CaseElse.model_construct(
+            discriminant=self.discriminant,
+            expr=(
+                self.expr.with_reference_replacement(
+                    source,
+                    target,
+                )
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+        )
+
     def with_namespace(self, namespace: str) -> CaseElse:
         return CaseElse.model_construct(
             discriminant=self.discriminant,
@@ -1483,35 +1538,10 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
             List[Set[DataType]],
         ]
     ] = None
-    arguments: Sequence[
-        Union[
-            ConceptRef,
-            AggregateWrapper,
-            Function,
-            Parenthetical,
-            CaseWhen,
-            CaseElse,
-            WindowItem,
-            int,
-            float,
-            str,
-            date,
-            datetime,
-            MapWrapper[Any, Any],
-            DataType,
-            ListType,
-            MapType,
-            NumericType,
-            DatePart,
-            list,
-            ListWrapper[Any],
-        ]
-    ]
+    arguments: Sequence[FuncArgs]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        if "datatype" in str(self):
-            raise SyntaxError(str(self))
 
     def __repr__(self):
         return f'{self.operator.value}({",".join([str(a) for a in self.arguments])})'
@@ -1597,6 +1627,29 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
                     )
         return v
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        return Function.model_construct(
+            operator=self.operator,
+            arguments=[
+                (
+                    c.with_reference_replacement(
+                        source,
+                        target,
+                    )
+                    if isinstance(
+                        c,
+                        Mergeable,
+                    )
+                    else c
+                )
+                for c in self.arguments
+            ],
+            output_datatype=self.output_datatype,
+            output_purpose=self.output_purpose,
+            valid_inputs=self.valid_inputs,
+            arg_count=self.arg_count,
+        )
+
     def with_namespace(self, namespace: str) -> "Function":
         return Function.model_construct(
             operator=self.operator,
@@ -1658,10 +1711,13 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         return base_grain
 
 
-class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
+class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel):
     function: Function
     by: List[ConceptRef] = Field(default_factory=list)
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
     @field_validator("by", mode="before")
     @classmethod
     def enforce_concept_ref(cls, v):
@@ -1693,10 +1749,6 @@ class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
     def output_purpose(self):
         return self.function.output_purpose
 
-    @property
-    def arguments(self):
-        return self.function.arguments
-
     def with_merge(self, source: Concept, target: Concept, modifiers: List[Modifier]):
         return AggregateWrapper.model_construct(
             function=self.function.with_merge(source, target, modifiers=modifiers),
@@ -1707,6 +1759,16 @@ class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return AggregateWrapper.model_construct(
+            function=self.function.with_reference_replacement(source, target),
+            by=(
+                [c.with_reference_replacement(source, target) for c in self.by]
+                if self.by
+                else []
+            ),
+        )
+
     def with_namespace(self, namespace: str) -> "AggregateWrapper":
         return AggregateWrapper.model_construct(
             function=self.function.with_namespace(namespace),
@@ -1796,11 +1858,6 @@ class RowsetItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
             rowset=self.rowset.with_namespace(namespace),
         )
 
-    @property
-    def arguments(self) -> List[ConceptRef]:
-        output = [self.content]
-        return output
-
     @property
     def output(self) -> ConceptRef:
         return self.content
@@ -1831,7 +1888,10 @@ class OrderBy(Mergeable, Namespaced, BaseModel):
 
     @property
     def concept_arguments(self):
-        return [x.expr for x in self.items]
+        base = []
+        for x in self.items:
+            base += x.concept_arguments
+        return base
 
 
 class AlignClause(Namespaced, BaseModel):
@@ -2088,6 +2148,11 @@ class Comment(BaseModel):
     text: str
 
 
+class ArgBinding(BaseModel):
+    name: str
+    default: Expr | None = None
+
+
 Expr = (
     MagicConstants
     | bool
@@ -2099,6 +2164,7 @@ Expr = (
     | datetime
     | TupleWrapper
     | ListWrapper
+    | MapWrapper
     | WindowItem
     | FilterItem
     | ConceptRef
@@ -2107,4 +2173,30 @@ Expr = (
     | Parenthetical
     | Function
     | AggregateWrapper
+    | CaseWhen
+    | CaseElse
+)
+
+FuncArgs = (
+    ConceptRef
+    | AggregateWrapper
+    | Function
+    | Parenthetical
+    | CaseWhen
+    | CaseElse
+    | WindowItem
+    | FilterItem
+    | int
+    | float
+    | str
+    | date
+    | datetime
+    | MapWrapper[Any, Any]
+    | DataType
+    | ListType
+    | MapType
+    | NumericType
+    | DatePart
+    | list
+    | ListWrapper[Any]
 )