pytrilogy 0.0.3.84__tar.gz → 0.0.3.86__tar.gz

{pytrilogy-0.0.3.84/pytrilogy.egg-info → pytrilogy-0.0.3.86}/PKG-INFO

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

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/tests/test_datatypes.py

@@ -30,7 +30,7 @@ def test_cast_error():
     """
         )
     except InvalidSyntaxException as e:
-        assert "Cannot compare DataType.INTEGER and DataType.STRING" in str(e)
+        assert "Cannot compare INTEGER (ref:local.x) and STRING (ref:local.y)" in str(e)
         found = True
     if not found:
         assert False, "Expected InvalidSyntaxException not raised"

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

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/core/models/author.py

@@ -637,33 +637,31 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
 
     @model_validator(mode="after")
     def validate_comparison(self):
+        left_type = arg_to_datatype(self.left)
+        right_type = arg_to_datatype(self.right)
         if self.operator in (ComparisonOperator.IS, ComparisonOperator.IS_NOT):
-            if self.right != MagicConstants.NULL and DataType.BOOL != arg_to_datatype(
-                self.right
-            ):
+            if self.right != MagicConstants.NULL and DataType.BOOL != right_type:
                 raise SyntaxError(
                     f"Cannot use {self.operator.value} with non-null or boolean value {self.right}"
                 )
         elif self.operator in (ComparisonOperator.IN, ComparisonOperator.NOT_IN):
-            right_type = arg_to_datatype(self.right)
+
             if isinstance(right_type, ArrayType) and not is_compatible_datatype(
-                arg_to_datatype(self.left), right_type.value_data_type
+                left_type, right_type.value_data_type
             ):
                 raise SyntaxError(
-                    f"Cannot compare {arg_to_datatype(self.left)} and {right_type} with operator {self.operator} in {str(self)}"
+                    f"Cannot compare {left_type} and {right_type} with operator {self.operator} in {str(self)}"
                 )
             elif isinstance(self.right, Concept) and not is_compatible_datatype(
-                arg_to_datatype(self.left), arg_to_datatype(self.right)
+                left_type, right_type
             ):
                 raise SyntaxError(
-                    f"Cannot compare {arg_to_datatype(self.left)} and {arg_to_datatype(self.right)} with operator {self.operator} in {str(self)}"
+                    f"Cannot compare {left_type.name} and {right_type.name} with operator {self.operator} in {str(self)}"
                 )
         else:
-            if not is_compatible_datatype(
-                arg_to_datatype(self.left), arg_to_datatype(self.right)
-            ):
+            if not is_compatible_datatype(left_type, right_type):
                 raise SyntaxError(
-                    f"Cannot compare {arg_to_datatype(self.left)} and {arg_to_datatype(self.right)} of different types with operator {self.operator} in {str(self)}"
+                    f"Cannot compare {left_type.name} ({self.left}) and {right_type.name} ({self.right}) of different types with operator {self.operator.value} in {str(self)}"
                 )
 
         return self

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/core/processing/utility.py

@@ -161,6 +161,9 @@ def resolve_join_order_v2(
                 left_is_partial = any(
                     key in partials.get(left_candidate, []) for key in common
                 )
+                left_is_nullable = any(
+                    key in nullables.get(left_candidate, []) for key in common
+                )
                 right_is_partial = any(key in partials.get(right, []) for key in common)
                 # we don't care if left is nullable for join type (just keys), but if we did
                 # left_is_nullable = any(
@@ -169,21 +172,29 @@ def resolve_join_order_v2(
                 right_is_nullable = any(
                     key in nullables.get(right, []) for key in common
                 )
-                if left_is_partial or right_is_nullable:
+                if left_is_nullable and right_is_nullable:
+                    join_type = JoinType.FULL
+                elif left_is_partial and right_is_partial:
+                    join_type = JoinType.FULL
+                elif left_is_partial:
                     join_type = JoinType.FULL
-                elif right_is_partial:
+                elif right_is_nullable:
+                    join_type = JoinType.RIGHT_OUTER
+                elif right_is_partial or left_is_nullable:
                     join_type = JoinType.LEFT_OUTER
                 # we can't inner join if the left was an outer join
                 else:
                     join_type = JoinType.INNER
+
                 join_types.add(join_type)
                 joinkeys[left_candidate] = common
-
             final_join_type = JoinType.INNER
-            if any([x == JoinType.LEFT_OUTER for x in join_types]):
-                final_join_type = JoinType.LEFT_OUTER
-            elif any([x == JoinType.FULL for x in join_types]):
+            if any([x == JoinType.FULL for x in join_types]):
                 final_join_type = JoinType.FULL
+            elif any([x == JoinType.LEFT_OUTER for x in join_types]):
+                final_join_type = JoinType.LEFT_OUTER
+            elif any([x == JoinType.RIGHT_OUTER for x in join_types]):
+                final_join_type = JoinType.RIGHT_OUTER
             output.append(
                 JoinOrderOutput(
                     # left=left_candidate,
@@ -608,13 +619,12 @@ def find_nullable_concepts(
         local_nullable = [
             x for x in datasources if k in [v.address for v in x.nullable_concepts]
         ]
-        if all(
-            [
-                k in [v.address for v in x.nullable_concepts]
-                for x in datasources
-                if k in [z.address for z in x.output_concepts]
-            ]
-        ):
+        nullable_matches = [
+            k in [v.address for v in x.nullable_concepts]
+            for x in datasources
+            if k in [z.address for z in x.output_concepts]
+        ]
+        if all(nullable_matches) and len(nullable_matches) > 0:
             final_nullable.add(k)
         all_ds = set([ds for ds in local_nullable]).union(nullable_datasources)
         if nullable_datasources:

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/dialect/duckdb.py

@@ -76,6 +76,7 @@ FUNCTION_MAP = {
     FunctionType.DATE: lambda x: f"cast({x[0]} as date)",
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc('{x[1]}', {x[0]})",
     FunctionType.DATE_ADD: lambda x: f"date_add({x[0]}, {x[2]} * INTERVAL 1 {x[1]})",
+    FunctionType.DATE_SUB: lambda x: f"date_add({x[0]}, -{x[2]} * INTERVAL 1 {x[1]})",
     FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
     FunctionType.DATE_DIFF: lambda x: f"date_diff('{x[2]}', {x[0]}, {x[1]})",
     FunctionType.CONCAT: lambda x: f"({' || '.join(x)})",

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/parsing/parse_engine.py

@@ -683,7 +683,9 @@ class ParseToObjects(Transformer):
             )
             # let constant purposes exist to support round-tripping
             # as a build concept may end up with a constant based on constant inlining happening recursively
-            if (
+            if purpose == Purpose.KEY and concept.purpose != Purpose.KEY:
+                concept.purpose = Purpose.KEY
+            elif (
                 purpose
                 and purpose != Purpose.AUTO
                 and concept.purpose != purpose

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/parsing/trilogy.lark

@@ -367,7 +367,7 @@
     fyear: _YEAR expr ")"
     
     DATE_PART: "DAY"i | "WEEK"i | "MONTH"i | "QUARTER"i | "YEAR"i | "MINUTE"i | "HOUR"i | "SECOND"i | "DAY_OF_WEEK"i
-    _DATE_TRUNC.1: "date_trunc("i
+    _DATE_TRUNC.1: "date_trunc("i | "date_truncate("i
     fdate_trunc: _DATE_TRUNC expr "," DATE_PART ")"
     _DATE_PART.1: "date_part("i
     fdate_part: _DATE_PART expr "," DATE_PART ")"

{pytrilogy-0.0.3.84 → pytrilogy-0.0.3.86}/trilogy/std/geography.preql

@@ -9,10 +9,11 @@ type us_zip_code string; # US ZIP code
 ## generic types
 type latitude float; # Latitude in degrees
 type longitude float; # Longitude in degrees
-type lat_long string; # Latitude and longitude in degrees
+type lat_long string; # Latitude and longitude in degrees, as a coordinate pair
 
 type city string; # City name
-type country string; # Country name
+type country string; # Full Country Name
+type country_code string; # ISO-3166 Country code - ex US, CA, GB
 type timezone string; # Timezone name
 type region string; # Region name
 

pytrilogy-0.0.3.86/trilogy/std/net.preql

@@ -0,0 +1,14 @@
+
+## network types
+type url string; # URL string
+type url_image string; # URL of an image
+type domain string; # Domain name
+type ip_net_mask string; # IP network mask
+type ipv6_address string; # IPv6 address
+type ipv4_address string; # IPv4 address
+
+## communication types
+type email_address string; # Email address, including @
+
+## shared types
+type suffix string; # A file suffix or extension, like .txt, .jpg, etc.

pytrilogy-0.0.3.84/trilogy/std/net.preql

@@ -1,9 +0,0 @@
-
-
-type url string;
-type domain string;
-type ip_net_mask string;
-type ipv6_address string;
-type ipv4_address string;
-type suffix string;
-type url_image string;