pytrilogy 0.0.1.104__py3-none-any.whl → 0.0.1.106__py3-none-any.whl

trilogy/parsing/common.py

@@ -174,3 +174,33 @@ def agg_wrapper_to_concept(
         keys=tuple(parent.by) if parent.by else keys,
     )
     return out
+
+
+def arbitrary_to_concept(
+    parent: (
+        AggregateWrapper
+        | WindowItem
+        | FilterItem
+        | Function
+        | ListWrapper
+        | int
+        | float
+        | str
+    ),
+    namespace: str,
+    name: str,
+    metadata: Metadata | None = None,
+    purpose: Purpose | None = None,
+) -> Concept:
+    if isinstance(parent, AggregateWrapper):
+        return agg_wrapper_to_concept(parent, namespace, name, metadata, purpose)
+    elif isinstance(parent, WindowItem):
+        return window_item_to_concept(parent, name, namespace, purpose, metadata)
+    elif isinstance(parent, FilterItem):
+        return filter_item_to_concept(parent, name, namespace, purpose, metadata)
+    elif isinstance(parent, Function):
+        return function_to_concept(parent, name, namespace)
+    elif isinstance(parent, ListWrapper):
+        return constant_to_concept(parent, name, namespace, purpose, metadata)
+    else:
+        return constant_to_concept(parent, name, namespace, purpose, metadata)

trilogy/parsing/parse_engine.py

@@ -17,6 +17,7 @@ from trilogy.constants import (
     DEFAULT_NAMESPACE,
     NULL_VALUE,
     VIRTUAL_CONCEPT_PREFIX,
+    MagicConstants,
 )
 from trilogy.core.enums import (
     BooleanOperator,
@@ -62,6 +63,7 @@ from trilogy.core.models import (
     ColumnAssignment,
     Comment,
     Comparison,
+    SubselectComparison,
     Concept,
     ConceptTransform,
     Conditional,
@@ -108,6 +110,7 @@ from trilogy.parsing.common import (
     function_to_concept,
     filter_item_to_concept,
     constant_to_concept,
+    arbitrary_to_concept,
 )
 
 CONSTANT_TYPES = (int, float, str, bool, ListWrapper)
@@ -187,9 +190,9 @@ grammar = r"""
 
     // FUNCTION blocks
     function: raw_function
-    function_binding_item: IDENTIFIER data_type
+    function_binding_item: IDENTIFIER ":" data_type
     function_binding_list: (function_binding_item ",")* function_binding_item ","?
-    raw_function: "def" "rawsql"  IDENTIFIER  "("  function_binding_list ")" "-" ">" data_type "as"i MULTILINE_STRING
+    raw_function: "bind" "sql"  IDENTIFIER  "("  function_binding_list ")" "-" ">" data_type "as"i MULTILINE_STRING
 
     
     // user_id where state = Mexico
@@ -246,7 +249,9 @@ grammar = r"""
 
     COMPARISON_OPERATOR: (/is[\s]+not/ | "is" |"=" | ">" | "<" | ">=" | "<=" | "!="  )
     
-    comparison: (expr COMPARISON_OPERATOR expr) | (expr array_comparison expr_tuple) 
+    comparison: (expr COMPARISON_OPERATOR expr) | (expr array_comparison expr_tuple)
+
+    subselect_comparison: expr array_comparison expr
     
     expr_tuple: "("  (expr ",")* expr ","?  ")"
 
@@ -258,7 +263,7 @@ grammar = r"""
 
     parenthetical: "(" (conditional | expr) ")"
     
-    expr:  window_item | filter_item | 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 | 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
     
@@ -525,43 +530,11 @@ class ParseToObjects(Transformer):
                     concept.metadata.line_number = meta.line
                 self.environment.add_concept(concept, meta=meta)
                 final.append(concept)
-            elif isinstance(arg, FilterItem):
+            elif isinstance(
+                arg, (FilterItem, WindowItem, AggregateWrapper, ListWrapper)
+            ):
                 id_hash = string_to_hash(str(arg))
-                concept = filter_item_to_concept(
-                    arg,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                    namespace=self.environment.namespace,
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            elif isinstance(arg, WindowItem):
-                id_hash = string_to_hash(str(arg))
-                concept = window_item_to_concept(
-                    arg,
-                    namespace=self.environment.namespace,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            elif isinstance(arg, AggregateWrapper):
-                id_hash = string_to_hash(str(arg))
-                concept = agg_wrapper_to_concept(
-                    arg,
-                    namespace=self.environment.namespace,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            # we don't need virtual types for most constants
-            elif isinstance(arg, (ListWrapper)):
-                id_hash = string_to_hash(str(arg))
-                concept = constant_to_concept(
+                concept = arbitrary_to_concept(
                     arg,
                     name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
                     namespace=self.environment.namespace,
@@ -570,6 +543,7 @@ class ParseToObjects(Transformer):
                     concept.metadata.line_number = meta.line
                 self.environment.add_concept(concept, meta=meta)
                 final.append(concept)
+
             else:
                 final.append(arg)
         return final
@@ -773,8 +747,10 @@ class ParseToObjects(Transformer):
         while isinstance(source_value, Parenthetical):
             source_value = source_value.content
 
-        if isinstance(source_value, FilterItem):
-            concept = filter_item_to_concept(
+        if isinstance(
+            source_value, (FilterItem, WindowItem, AggregateWrapper, Function)
+        ):
+            concept = arbitrary_to_concept(
                 source_value,
                 name=name,
                 namespace=namespace,
@@ -782,31 +758,6 @@ class ParseToObjects(Transformer):
                 metadata=metadata,
             )
 
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-        elif isinstance(source_value, WindowItem):
-
-            concept = window_item_to_concept(
-                source_value,
-                name=name,
-                namespace=namespace,
-                purpose=purpose,
-                metadata=metadata,
-            )
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-        elif isinstance(source_value, AggregateWrapper):
-            concept = agg_wrapper_to_concept(
-                source_value,
-                namespace=namespace,
-                name=name,
-                metadata=metadata,
-                purpose=purpose,
-            )
             if concept.metadata:
                 concept.metadata.line_number = meta.line
             self.environment.add_concept(concept, meta=meta)
@@ -824,19 +775,6 @@ class ParseToObjects(Transformer):
             self.environment.add_concept(concept, meta=meta)
             return ConceptDerivation(concept=concept)
 
-        elif isinstance(source_value, Function):
-            function: Function = source_value
-
-            concept = function_to_concept(
-                function,
-                name=name,
-                namespace=namespace,
-            )
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-
         raise SyntaxError(
             f"Received invalid type {type(args[2])} {args[2]} as input to select"
             " transform"
@@ -926,7 +864,7 @@ class ParseToObjects(Transformer):
             elif isinstance(val, Grain):
                 grain = val
             elif isinstance(val, Query):
-                address = Address(location=f"({val.text})")
+                address = Address(location=f"({val.text})", is_query=True)
         if not address:
             raise ValueError(
                 "Malformed datasource, missing address or query declaration"
@@ -1219,7 +1157,14 @@ class ParseToObjects(Transformer):
     def where(self, args):
         root = args[0]
         if not isinstance(root, (Comparison, Conditional, Parenthetical)):
-            root = Comparison(left=root, right=True, operator=ComparisonOperator.EQ)
+            if arg_to_datatype(root) == DataType.BOOL:
+                root = Comparison(left=root, right=True, operator=ComparisonOperator.EQ)
+            else:
+                root = Comparison(
+                    left=root,
+                    right=MagicConstants.NULL,
+                    operator=ComparisonOperator.IS_NOT,
+                )
         return WhereClause(conditional=root)
 
     @v_args(meta=True)
@@ -1232,7 +1177,6 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def raw_function(self, meta: Meta, args) -> Function:
-        print(args)
         identity = args[0]
         fargs = args[1]
         output = args[2]
@@ -1273,6 +1217,22 @@ class ParseToObjects(Transformer):
     def comparison(self, args) -> Comparison:
         return Comparison(left=args[0], right=args[2], operator=args[1])
 
+    @v_args(meta=True)
+    def subselect_comparison(self, meta: Meta, args) -> SubselectComparison:
+        right = args[2]
+        if not isinstance(right, Concept):
+            right = arbitrary_to_concept(
+                right,
+                namespace=self.environment.namespace,
+                name=f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(right))}",
+            )
+            self.environment.add_concept(right)
+        return SubselectComparison(
+            left=args[0],
+            right=right,
+            operator=args[1],
+        )
+
     def expr_tuple(self, args):
         return Parenthetical(content=args)
 

trilogy/parsing/render.py

@@ -298,128 +298,6 @@ class Renderer:
     def _(self, arg: "FilterItem"):
         return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
 
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
     @to_string.register
     def _(self, arg: "ImportStatement"):
         return f"import {arg.path} as {arg.alias};"