pytrilogy 0.0.3.8__tar.gz → 0.0.3.10__tar.gz

{pytrilogy-0.0.3.8/pytrilogy.egg-info → pytrilogy-0.0.3.10}/PKG-INFO

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

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/pytrilogy.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ tests/test_query_processing.py
 tests/test_select.py
 tests/test_show.py
 tests/test_statements.py
+tests/test_typing.py
 tests/test_undefined_concept.py
 tests/test_user_functions.py
 tests/test_where_clause.py

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/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.10/tests/test_typing.py

@@ -0,0 +1,42 @@
+from trilogy import Dialects
+
+
+def test_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type email string;
+
+key customer_id int;
+property customer_id.email string::email;
+
+def is_valid_email(email) -> contains(email, '@');
+
+datasource customers (
+    id:customer_id,
+    email: email
+)
+grain (customer_id)
+query '''
+select 1 as id, 'bright@gmail.com' as email
+union all
+select 2 as id, 'funky@hotmail.com' as email
+''';
+
+
+"""
+    )
+
+    results = env.execute_query(
+        """SELECT
+customer_id,
+@is_valid_email(email)->valid;"""
+    )
+
+    for row in results.fetchall():
+        assert row.valid is True
+
+    assert "email" in env.environment.data_types
+
+    assert env.environment.concepts["email"].datatype.traits == ["email"]

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

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/authoring/__init__.py

@@ -38,6 +38,9 @@ from trilogy.core.models.environment import Environment
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     ConceptTransform,
+    MultiSelectStatement,
+    PersistStatement,
+    RawSQLStatement,
     SelectItem,
     SelectStatement,
 )
@@ -87,4 +90,7 @@ __all__ = [
     "DEFAULT_NAMESPACE",
     "arbitrary_to_concept",
     "arg_to_datatype",
+    "MultiSelectStatement",
+    "PersistStatement",
+    "RawSQLStatement",
 ]

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/enums.py

@@ -172,6 +172,7 @@ class FunctionType(Enum):
     UPPER = "upper"
     SUBSTRING = "substring"
     STRPOS = "strpos"
+    CONTAINS = "contains"
 
     # Dates
     DATE = "date"

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/functions.py

@@ -271,6 +271,15 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.INTEGER,
         arg_count=2,
     ),
+    FunctionType.CONTAINS: FunctionConfig(
+        valid_inputs=[
+            {DataType.STRING},
+            {DataType.STRING},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.BOOL,
+        arg_count=2,
+    ),
     FunctionType.SUBSTRING: FunctionConfig(
         valid_inputs=[{DataType.STRING}, {DataType.INTEGER}, {DataType.INTEGER}],
         output_purpose=Purpose.PROPERTY,

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/models/author.py

@@ -55,6 +55,7 @@ from trilogy.core.models.core import (
     MapWrapper,
     NumericType,
     StructType,
+    TraitDataType,
     TupleWrapper,
     arg_to_datatype,
     is_compatible_datatype,
@@ -101,9 +102,9 @@ class HasUUID(ABC):
 
 class ConceptRef(Addressable, Namespaced, DataTyped, Mergeable, BaseModel):
     address: str
-    datatype: DataType | ListType | StructType | MapType | NumericType = (
-        DataType.UNKNOWN
-    )
+    datatype: (
+        DataType | TraitDataType | ListType | StructType | MapType | NumericType
+    ) = DataType.UNKNOWN
     metadata: Optional["Metadata"] = None
 
     @property
@@ -547,6 +548,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         MagicConstants,
         WindowItem,
         AggregateWrapper,
+        FilterItem,
     ]
     right: Union[
         int,
@@ -566,6 +568,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         WindowItem,
         AggregateWrapper,
         TupleWrapper,
+        FilterItem,
     ]
     operator: ComparisonOperator
 
@@ -754,7 +757,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         extra="forbid",
     )
     name: str
-    datatype: DataType | ListType | StructType | MapType | NumericType
+    datatype: DataType | TraitDataType | ListType | StructType | MapType | NumericType
     purpose: Purpose
     derivation: Derivation = Derivation.ROOT
     granularity: Granularity = Granularity.MULTI_ROW
@@ -1215,9 +1218,9 @@ class UndefinedConceptFull(Concept, Mergeable, Namespaced):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     name: str
     line_no: int | None = None
-    datatype: DataType | ListType | StructType | MapType | NumericType = (
-        DataType.UNKNOWN
-    )
+    datatype: (
+        DataType | TraitDataType | ListType | StructType | MapType | NumericType
+    ) = DataType.UNKNOWN
     purpose: Purpose = Purpose.UNKNOWN
 
     @property
@@ -1249,7 +1252,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)
@@ -1258,6 +1261,16 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
             order=self.order,
         )
 
+    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]:
         return get_concept_arguments(self.expr)
@@ -1320,6 +1333,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,
@@ -1515,30 +1539,7 @@ 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)
@@ -2153,6 +2154,11 @@ class ArgBinding(BaseModel):
     default: Expr | None = None
 
 
+class CustomType(BaseModel):
+    name: str
+    type: DataType
+
+
 Expr = (
     MagicConstants
     | bool
@@ -2164,6 +2170,7 @@ Expr = (
     | datetime
     | TupleWrapper
     | ListWrapper
+    | MapWrapper
     | WindowItem
     | FilterItem
     | ConceptRef
@@ -2172,4 +2179,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]
 )

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/models/build.py

@@ -51,6 +51,7 @@ from trilogy.core.models.author import (
     ConceptRef,
     Conditional,
     FilterItem,
+    FuncArgs,
     Function,
     Grain,
     HavingClause,
@@ -1498,10 +1499,22 @@ class Factory:
 
     @build.register
     def _(self, base: Function) -> BuildFunction:
+        from trilogy.parsing.common import arbitrary_to_concept
 
+        raw_args: list[Concept | FuncArgs] = []
+        for arg in base.arguments:
+            # to do proper discovery, we need to inject virtual intermediate ocncepts
+            if isinstance(arg, (AggregateWrapper, FilterItem, WindowItem)):
+                narg = arbitrary_to_concept(
+                    arg,
+                    environment=self.environment,
+                )
+                raw_args.append(narg)
+            else:
+                raw_args.append(arg)
         new = BuildFunction.model_construct(
             operator=base.operator,
-            arguments=[self.build(c) for c in base.arguments],
+            arguments=[self.build(c) for c in raw_args],
             output_datatype=base.output_datatype,
             output_purpose=base.output_purpose,
             valid_inputs=base.valid_inputs,

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/models/core.py

@@ -97,6 +97,19 @@ class DataType(Enum):
         return self
 
 
+class TraitDataType(BaseModel):
+    type: DataType
+    traits: list[str]
+
+    @property
+    def data_type(self):
+        return self.type
+
+    @property
+    def value(self):
+        return self.data_type.value
+
+
 class NumericType(BaseModel):
     precision: int = 20
     scale: int = 5

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/models/environment.py

@@ -40,6 +40,7 @@ from trilogy.core.exceptions import (
 from trilogy.core.models.author import (
     Concept,
     ConceptRef,
+    CustomType,
     Function,
     SelectLineage,
     UndefinedConcept,
@@ -191,7 +192,7 @@ class Environment(BaseModel):
         EnvironmentDatasourceDict, PlainValidator(validate_datasources)
     ] = Field(default_factory=EnvironmentDatasourceDict)
     functions: Dict[str, Callable[..., Any]] = Field(default_factory=dict)
-    data_types: Dict[str, DataType] = Field(default_factory=dict)
+    data_types: Dict[str, CustomType] = Field(default_factory=dict)
     named_statements: Dict[str, SelectLineage] = Field(default_factory=dict)
     imports: Dict[str, list[Import]] = Field(
         default_factory=lambda: defaultdict(list)  # type: ignore

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/core/statements/author.py

@@ -15,8 +15,11 @@ from trilogy.core.enums import (
 from trilogy.core.models.author import (
     AggregateWrapper,
     AlignClause,
+    ArgBinding,
     Concept,
     ConceptRef,
+    CustomType,
+    Expr,
     FilterItem,
     Function,
     Grain,
@@ -413,3 +416,13 @@ class ConceptDeclarationStatement(HasUUID, BaseModel):
 
 class ConceptDerivationStatement(BaseModel):
     concept: Concept
+
+
+class TypeDeclaration(BaseModel):
+    type: CustomType
+
+
+class FunctionDeclaration(BaseModel):
+    name: str
+    args: list[ArgBinding]
+    expr: Expr

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/dialect/base.py

@@ -184,6 +184,7 @@ FUNCTION_MAP = {
     FunctionType.LOWER: lambda x: f"LOWER({x[0]}) ",
     FunctionType.SUBSTRING: lambda x: f"SUBSTRING({x[0]},{x[1]},{x[2]})",
     FunctionType.STRPOS: lambda x: f"STRPOS({x[0]},{x[1]})",
+    FunctionType.CONTAINS: lambda x: f"CONTAINS({x[0]},{x[1]})",
     # FunctionType.NOT_LIKE: lambda x: f" CASE WHEN {x[0]} like {x[1]} THEN 0 ELSE 1 END",
     # date types
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc({x[0]},{x[1]})",

{pytrilogy-0.0.3.8 → pytrilogy-0.0.3.10}/trilogy/executor.py

@@ -166,8 +166,11 @@ class Executor(object):
         )
 
     @execute_query.register
-    def _(self, query: str) -> CursorResult:
-        return self.execute_text(query)[-1]
+    def _(self, query: str) -> CursorResult | None:
+        results = self.execute_text(query)
+        if results:
+            return results[-1]
+        return None
 
     @execute_query.register
     def _(self, query: SelectStatement) -> CursorResult: