pytrilogy 0.0.1.109__py3-none-any.whl → 0.0.1.111__py3-none-any.whl

trilogy/executor.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Any
+from typing import List, Optional, Any, Generator
 from functools import singledispatchmethod
 from sqlalchemy import text
 from sqlalchemy.engine import Engine, CursorResult
@@ -222,6 +222,35 @@ class Executor(object):
             sql.append(x)
         return sql
 
+    def parse_text_generator(
+        self, command: str, persist: bool = False
+    ) -> Generator[
+        ProcessedQuery | ProcessedQueryPersist | ProcessedShowStatement, None, None
+    ]:
+        """Process a preql text command"""
+        _, parsed = parse_text(command, self.environment)
+        generatable = [
+            x
+            for x in parsed
+            if isinstance(
+                x,
+                (
+                    SelectStatement,
+                    PersistStatement,
+                    MultiSelectStatement,
+                    ShowStatement,
+                ),
+            )
+        ]
+        while generatable:
+            t = generatable.pop(0)
+            x = self.generator.generate_queries(
+                self.environment, [t], hooks=self.hooks
+            )[0]
+            if persist and isinstance(x, ProcessedQueryPersist):
+                self.environment.add_datasource(x.datasource)
+            yield x
+
     def execute_raw_sql(self, command: str) -> CursorResult:
         """Run a command against the raw underlying
         execution engine"""
@@ -229,10 +258,9 @@ class Executor(object):
 
     def execute_text(self, command: str) -> List[CursorResult]:
         """Run a preql text command"""
-        sql = self.parse_text(command)
         output = []
         # connection = self.engine.connect()
-        for statement in sql:
+        for statement in self.parse_text_generator(command):
             if isinstance(statement, ProcessedShowStatement):
                 output.append(
                     generate_result_set(

trilogy/parsing/parse_engine.py

@@ -101,6 +101,7 @@ from trilogy.core.models import (
     ConceptDerivation,
     RowsetDerivationStatement,
     LooseConceptList,
+    list_to_wrapper,
 )
 from trilogy.parsing.exceptions import ParseError
 from trilogy.utility import string_to_hash
@@ -113,6 +114,7 @@ from trilogy.parsing.common import (
     arbitrary_to_concept,
 )
 
+
 CONSTANT_TYPES = (int, float, str, bool, ListWrapper)
 
 grammar = r"""
@@ -138,7 +140,7 @@ grammar = r"""
     //<customer_id,country>.property local_alias STRING
     concept_property_declaration: PROPERTY (prop_ident | IDENTIFIER) data_type concept_nullable_modifier? metadata?
     //metric post_length <- len(post_text);
-    concept_derivation:  (PURPOSE | AUTO | PROPERTY ) IDENTIFIER "<" "-" expr
+    concept_derivation:  (PURPOSE | AUTO | PROPERTY ) (prop_ident | IDENTIFIER) "<" "-" expr
 
     rowset_derivation_statement: ("rowset"i IDENTIFIER "<" "-" (multi_select_statement | select_statement)) | ("with"i IDENTIFIER "as"i (multi_select_statement | select_statement))
     
@@ -179,13 +181,11 @@ grammar = r"""
     // multiple_selects
     multi_select_statement: select_statement ("merge" select_statement)+ "align"i align_clause  where? comment* order_by? comment* limit? comment*
 
-
     align_item: IDENTIFIER ":" IDENTIFIER ("," IDENTIFIER)* ","?
 
     align_clause: align_item ("," align_item)*  ","?
 
     // merge statemment
-
     merge_statement: "merge" IDENTIFIER ("," IDENTIFIER)* ","? comment*
 
     // FUNCTION blocks
@@ -193,7 +193,6 @@ grammar = r"""
     function_binding_item: IDENTIFIER ":" data_type
     function_binding_list: (function_binding_item ",")* function_binding_item ","?
     raw_function: "bind" "sql"  IDENTIFIER  "("  function_binding_list ")" "-" ">" data_type "as"i MULTILINE_STRING
-
     
     // user_id where state = Mexico
     filter_item: "filter"i IDENTIFIER where
@@ -249,9 +248,9 @@ grammar = r"""
 
     COMPARISON_OPERATOR: (/is[\s]+not/ | "is" |"=" | ">" | "<" | ">=" | "<=" | "!="  )
     
-    comparison: (expr COMPARISON_OPERATOR expr) | (expr array_comparison expr_tuple)
+    comparison: (expr COMPARISON_OPERATOR expr) 
 
-    subselect_comparison: expr array_comparison expr
+    subselect_comparison: expr array_comparison expr | (expr array_comparison expr_tuple)
     
     expr_tuple: "("  (expr ",")* expr ","?  ")"
 
@@ -267,7 +266,6 @@ grammar = r"""
     
     // functions
     
-    //math TODO: add syntactic sugar
     fadd: ("add"i "(" expr "," expr ")" ) | ( expr "+" expr )
     fsub: ("subtract"i "(" expr "," expr ")" ) | ( expr "-" expr )
     fmul: ("multiply"i "(" expr "," expr ")" ) | ( expr "*" expr )
@@ -738,10 +736,17 @@ class ParseToObjects(Transformer):
         purpose = args[0]
         if purpose == Purpose.AUTO:
             purpose = None
-        name = args[1]
-        lookup, namespace, name, parent_concept = parse_concept_reference(
-            name, self.environment, purpose
-        )
+        raw_name = args[1]
+        if isinstance(raw_name, str):
+            lookup, namespace, name, parent_concept = parse_concept_reference(
+                raw_name, self.environment, purpose
+            )
+        else:
+            keys, name = raw_name
+            if "." in name:
+                namespace, name = name.rsplit(".", 1)
+            else:
+                namespace = self.environment.namespace or DEFAULT_NAMESPACE
         source_value = args[2]
         # we need to strip off every parenthetical to see what is being assigned.
         while isinstance(source_value, Parenthetical):
@@ -971,7 +976,26 @@ class ParseToObjects(Transformer):
         return Ordering(args.lower())
 
     def order_list(self, args):
-        return [OrderItem(expr=x, order=y) for x, y in zip(args[::2], args[1::2])]
+
+        def handle_order_item(x, namespace: str):
+            if not isinstance(x, Concept):
+                x = arbitrary_to_concept(
+                    x,
+                    namespace=namespace,
+                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(x))}",
+                )
+            return x
+
+        return [
+            OrderItem(
+                expr=handle_order_item(
+                    x,
+                    self.environment.namespace,
+                ),
+                order=y,
+            )
+            for x, y in zip(args[::2], args[1::2])
+        ]
 
     def order_by(self, args):
         return OrderBy(items=args[0])
@@ -1207,26 +1231,34 @@ class ParseToObjects(Transformer):
         return float(args[0])
 
     def array_lit(self, args):
-        types = [arg_to_datatype(arg) for arg in args]
-        assert len(set(types)) == 1
-        return ListWrapper(args, type=types[0])
+        return list_to_wrapper(args)
 
     def literal(self, args):
         return args[0]
 
     def comparison(self, args) -> Comparison:
+        if args[1] == ComparisonOperator.IN:
+            raise SyntaxError
         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):
+
+        while isinstance(right, Parenthetical) and isinstance(
+            right.content,
+            (Concept, Function, FilterItem, WindowItem, AggregateWrapper, ListWrapper),
+        ):
+            right = right.content
+        if isinstance(
+            right, (Function, FilterItem, WindowItem, AggregateWrapper, ListWrapper)
+        ):
             right = arbitrary_to_concept(
                 right,
                 namespace=self.environment.namespace,
                 name=f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(right))}",
             )
-            self.environment.add_concept(right)
+            self.environment.add_concept(right, meta=meta)
         return SubselectComparison(
             left=args[0],
             right=right,