pytrilogy 0.0.2.22__tar.gz → 0.0.2.23__tar.gz

{pytrilogy-0.0.2.22/pytrilogy.egg-info → pytrilogy-0.0.2.23}/PKG-INFO

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

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23/pytrilogy.egg-info}/PKG-INFO

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

pytrilogy-0.0.2.23/tests/test_imports.py

@@ -0,0 +1,42 @@
+from trilogy import Environment
+from pathlib import Path
+
+
+def test_multi_environment():
+    basic = Environment()
+
+    basic.parse(
+        """
+const pi <- 3.14;
+                     
+
+""",
+        namespace="math",
+    )
+
+    basic.parse(
+        """
+                
+            select math.pi;
+                """
+    )
+
+    assert basic.concepts["math.pi"].name == "pi"
+
+
+def test_test_alias_free_import():
+    basic = Environment(working_path=Path(__file__).parent)
+
+    basic.parse(
+        """
+import test_env;
+
+key id2 int;
+
+
+""",
+    )
+
+    assert basic.concepts["id"].name == "id"
+    assert basic.concepts["id2"].name == "id2"
+    assert basic.concepts["id"].namespace == basic.concepts["id2"].namespace

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/tests/test_models.py

@@ -15,8 +15,11 @@ from trilogy.core.models import (
     Concept,
     AggregateWrapper,
     RowsetItem,
+    TupleWrapper,
+    DataType,
 )
 from trilogy import parse
+from copy import deepcopy
 
 
 def test_cte_merge(test_environment, test_environment_graph):
@@ -312,3 +315,9 @@ select avg_greater_ten;
     lineage = env.concepts["avg_greater_ten"].lineage
     assert isinstance(lineage, AggregateWrapper)
     assert isinstance(lineage.function.concept_arguments[0].lineage, RowsetItem)
+
+
+def test_tuple_clone():
+    x = TupleWrapper([1, 2, 3], type=DataType.INTEGER)
+    y = deepcopy(x)
+    assert y == x

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/tests/test_parsing.py

@@ -1,12 +1,12 @@
 from trilogy.core.enums import Purpose, ComparisonOperator
 from trilogy.core.models import (
     DataType,
-    Parenthetical,
     ProcessedQuery,
     ShowStatement,
     SelectStatement,
     Environment,
     Comparison,
+    TupleWrapper,
 )
 from trilogy.core.functions import argument_to_purpose, function_args_to_output_purpose
 from trilogy.parsing.parse_engine import (
@@ -27,11 +27,11 @@ def test_in():
     right = query.where_clause.conditional.right
     assert isinstance(
         right,
-        Parenthetical,
+        TupleWrapper,
     ), type(right)
-    assert right.content[0] == 1
+    assert right[0] == 1
     rendered = BaseDialect().render_expr(right)
-    assert rendered.strip() == "( 1,2,3 )".strip()
+    assert rendered.strip() == "(1,2,3)".strip()
 
     _, parsed = parse_text(
         "const order_id <- 3; SELECT order_id  WHERE order_id IN (1,);"
@@ -40,11 +40,11 @@ def test_in():
     right = query.where_clause.conditional.right
     assert isinstance(
         right,
-        Parenthetical,
+        TupleWrapper,
     ), type(right)
-    assert right.content[0] == 1
+    assert right[0] == 1
     rendered = BaseDialect().render_expr(right)
-    assert rendered.strip() == "( 1 )".strip()
+    assert rendered.strip() == "(1)".strip()
 
 
 def test_not_in():
@@ -53,13 +53,10 @@ def test_not_in():
     )
     query: ProcessedQuery = parsed[-1]
     right = query.where_clause.conditional.right
-    assert isinstance(
-        right,
-        Parenthetical,
-    ), type(right)
-    assert right.content[0] == 1
+    assert isinstance(right, TupleWrapper), type(right)
+    assert right[0] == 1
     rendered = BaseDialect().render_expr(right)
-    assert rendered.strip() == "( 1,2,3 )".strip()
+    assert rendered.strip() == "(1,2,3)".strip()
 
 
 def test_is_not_null():
@@ -516,3 +513,24 @@ select filtered_test;
     results = Dialects.DUCK_DB.default_executor().generate_sql(text)[0]
 
     assert "filtered_test" in results, results
+
+
+def test_unnest_parsing():
+    x = """
+key scalar int;    
+property scalar.int_array list<int>;
+
+key split <- unnest(int_array);
+
+datasource avalues (
+    int_array: int_array,
+	scalar: scalar
+    ) 
+grain (scalar) 
+query '''(
+select [1,2,3,4] as int_array, 2 as scalar
+)''';
+"""
+
+    env, parsed = parse_text(x)
+    assert env.concepts["split"].datatype == DataType.INTEGER

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/tests/test_show.py

@@ -1,5 +1,4 @@
 from trilogy.core.models import ShowStatement
-from trilogy.core.query_processor import process_query
 from trilogy import Dialects
 from trilogy.parser import parse
 

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/tests/test_statements.py

@@ -1,4 +1,7 @@
 from trilogy.parser import parse
+from trilogy import Dialects
+from trilogy.core.models import ProcessedCopyStatement
+from pathlib import Path
 
 # from trilogy.compiler import compile
 
@@ -43,6 +46,24 @@ datasource posts (
     parse(text)
 
 
+def test_io_statement():
+    target = Path(__file__).parent / "test_io_statement.csv"
+    if target.exists():
+        target.unlink()
+    text = f"""const array <- [1,2,3,4];
+
+auto x <- unnest(array);
+
+copy into csv '{target}' from select x -> test;
+"""
+    exec = Dialects.DUCK_DB.default_executor()
+    results = exec.parse_text(text)
+    assert isinstance(results[-1], ProcessedCopyStatement)
+    for z in results:
+        exec.execute_query(z)
+    assert target.exists(), "csv file was not created"
+
+
 def test_datasource_where():
     text = """key user_id int metadata(description="the description");
 property user_id.display_name string metadata(description="The display name ");

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.22"
+__version__ = "0.0.2.23"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/core/enums.py

@@ -292,3 +292,13 @@ class SelectFiltering(Enum):
     NONE = "none"
     EXPLICIT = "explicit"  # the filtering contains only selected values
     IMPLICIT = "implicit"  # the filtering contains unselected values
+
+
+class IOType(Enum):
+    CSV = "csv"
+
+    @classmethod
+    def _missing_(cls, value):
+        if isinstance(value, str) and value.lower() != value:
+            return IOType(value.lower())
+        return super()._missing_(value)

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/core/functions.py

@@ -104,6 +104,8 @@ def Unnest(args: list[Concept]) -> Function:
     output = arg_to_datatype(args[0])
     if isinstance(output, (ListType)):
         output = output.value_data_type
+    else:
+        output = DataType.STRING
     return Function(
         operator=FunctionType.UNNEST,
         arguments=args,

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/core/models.py

@@ -65,6 +65,7 @@ from trilogy.core.enums import (
     ShowCategory,
     Granularity,
     SelectFiltering,
+    IOType,
 )
 from trilogy.core.exceptions import UndefinedConceptException, InvalidSyntaxException
 from trilogy.utility import unique
@@ -81,6 +82,9 @@ LT = TypeVar("LT")
 
 
 def is_compatible_datatype(left, right):
+    # for unknown types, we can't make any assumptions
+    if right == DataType.UNKNOWN or left == DataType.UNKNOWN:
+        return True
     if left == right:
         return True
     if {left, right} == {DataType.NUMERIC, DataType.FLOAT}:
@@ -1580,6 +1584,13 @@ class RawSQLStatement(BaseModel):
     meta: Optional[Metadata] = Field(default_factory=lambda: Metadata())
 
 
+class CopyStatement(BaseModel):
+    target: str
+    target_type: IOType
+    meta: Optional[Metadata] = Field(default_factory=lambda: Metadata())
+    select: SelectStatement
+
+
 class SelectStatement(Mergeable, Namespaced, SelectTypeMixin, BaseModel):
     selection: List[SelectItem]
     order_by: Optional[OrderBy] = None
@@ -3599,6 +3610,7 @@ class Comparison(
         MagicConstants,
         WindowItem,
         AggregateWrapper,
+        TupleWrapper,
     ]
     operator: ComparisonOperator
 
@@ -4258,13 +4270,23 @@ class ProcessedQuery(BaseModel):
     order_by: Optional[OrderBy] = None
 
 
-class ProcessedQueryMixin(BaseModel):
+class PersistQueryMixin(BaseModel):
     output_to: MaterializedDataset
     datasource: Datasource
     # base:Dataset
 
 
-class ProcessedQueryPersist(ProcessedQuery, ProcessedQueryMixin):
+class ProcessedQueryPersist(ProcessedQuery, PersistQueryMixin):
+    pass
+
+
+class CopyQueryMixin(BaseModel):
+    target: str
+    target_type: IOType
+    # base:Dataset
+
+
+class ProcessedCopyStatement(ProcessedQuery, CopyQueryMixin):
     pass
 
 
@@ -4523,6 +4545,37 @@ class Parenthetical(
         return base
 
 
+class TupleWrapper(Generic[VT], tuple):
+    """Used to distinguish parsed tuple objects from other tuples"""
+
+    def __init__(self, val, type: DataType, **kwargs):
+        super().__init__()
+        self.type = type
+        self.val = val
+
+    def __getnewargs__(self):
+        return (self.val, self.type)
+
+    def __new__(cls, val, type: DataType, **kwargs):
+        return super().__new__(cls, tuple(val))
+        # self.type = type
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Callable[[Any], core_schema.CoreSchema]
+    ) -> core_schema.CoreSchema:
+        args = get_args(source_type)
+        if args:
+            schema = handler(Tuple[args])  # type: ignore
+        else:
+            schema = handler(Tuple)
+        return core_schema.no_info_after_validator_function(cls.validate, schema)
+
+    @classmethod
+    def validate(cls, v):
+        return cls(v, type=arg_to_datatype(v[0]))
+
+
 class PersistStatement(BaseModel):
     datasource: Datasource
     select: SelectStatement
@@ -4589,6 +4642,12 @@ def list_to_wrapper(args):
     return ListWrapper(args, type=types[0])
 
 
+def tuple_to_wrapper(args):
+    types = [arg_to_datatype(arg) for arg in args]
+    assert len(set(types)) == 1
+    return TupleWrapper(args, type=types[0])
+
+
 def dict_to_map_wrapper(arg):
     key_types = [arg_to_datatype(arg) for arg in arg.keys()]
 
@@ -4644,6 +4703,8 @@ def arg_to_datatype(arg) -> DataType | ListType | StructType | MapType | Numeric
         return arg.function.output_datatype
     elif isinstance(arg, Parenthetical):
         return arg_to_datatype(arg.content)
+    elif isinstance(arg, TupleWrapper):
+        return ListType(type=arg.type)
     elif isinstance(arg, WindowItem):
         if arg.type in (WindowType.RANK, WindowType.ROW_NUMBER):
             return DataType.INTEGER

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/core/processing/utility.py

@@ -28,6 +28,7 @@ from trilogy.core.models import (
     DatePart,
     NumericType,
     ListType,
+    TupleWrapper,
 )
 
 from trilogy.core.enums import Purpose, Granularity, BooleanOperator, Modifier
@@ -422,6 +423,7 @@ def is_scalar_condition(
         | NumericType
         | DatePart
         | ListWrapper[Any]
+        | TupleWrapper[Any]
     ),
     materialized: set[str] | None = None,
 ) -> bool:

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/core/query_processor.py

@@ -26,6 +26,8 @@ from trilogy.core.models import (
     BaseJoin,
     InstantiatedUnnestJoin,
     Conditional,
+    ProcessedCopyStatement,
+    CopyStatement,
 )
 
 from trilogy.utility import unique
@@ -418,6 +420,24 @@ def process_persist(
     )
 
 
+def process_copy(
+    environment: Environment,
+    statement: CopyStatement,
+    hooks: List[BaseHook] | None = None,
+) -> ProcessedCopyStatement:
+    select = process_query(
+        environment=environment, statement=statement.select, hooks=hooks
+    )
+
+    # build our object to return
+    arg_dict = {k: v for k, v in select.__dict__.items()}
+    return ProcessedCopyStatement(
+        **arg_dict,
+        target=statement.target,
+        target_type=statement.target_type,
+    )
+
+
 def process_query(
     environment: Environment,
     statement: SelectStatement | MultiSelectStatement,

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/dialect/base.py

@@ -35,6 +35,7 @@ from trilogy.core.models import (
     Environment,
     RawColumnExpr,
     ListWrapper,
+    TupleWrapper,
     MapWrapper,
     ShowStatement,
     RowsetItem,
@@ -49,8 +50,10 @@ from trilogy.core.models import (
     StructType,
     MergeStatementV2,
     Datasource,
+    CopyStatement,
+    ProcessedCopyStatement,
 )
-from trilogy.core.query_processor import process_query, process_persist
+from trilogy.core.query_processor import process_query, process_persist, process_copy
 from trilogy.dialect.common import render_join, render_unnest
 from trilogy.hooks.base_hook import BaseHook
 from trilogy.core.enums import UnnestMode
@@ -391,6 +394,7 @@ class BaseDialect:
             StructType,
             ListType,
             ListWrapper[Any],
+            TupleWrapper[Any],
             DatePart,
             CaseWhen,
             CaseElse,
@@ -430,7 +434,7 @@ class BaseDialect:
                         f"Missing source CTE for {e.right.address}"
                     )
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} (select {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {target} where {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
-            elif isinstance(e.right, (ListWrapper, Parenthetical, list)):
+            elif isinstance(e.right, (ListWrapper, TupleWrapper, Parenthetical, list)):
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)}"
 
             elif isinstance(
@@ -511,6 +515,8 @@ class BaseDialect:
             return str(e)
         elif isinstance(e, ListWrapper):
             return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) for x in e])}]"
+        elif isinstance(e, TupleWrapper):
+            return f"({','.join([self.render_expr(x, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) for x in e])})"
         elif isinstance(e, MapWrapper):
             return f"MAP {{{','.join([f'{self.render_expr(k, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)}:{self.render_expr(v, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)}' for k, v in e.items()])}}}"
         elif isinstance(e, list):
@@ -662,6 +668,7 @@ class BaseDialect:
             | ImportStatement
             | RawSQLStatement
             | MergeStatementV2
+            | CopyStatement
         ],
         hooks: Optional[List[BaseHook]] = None,
     ) -> List[
@@ -675,6 +682,7 @@ class BaseDialect:
             | ProcessedQueryPersist
             | ProcessedShowStatement
             | ProcessedRawSQLStatement
+            | ProcessedCopyStatement
         ] = []
         for statement in statements:
             if isinstance(statement, PersistStatement):
@@ -683,6 +691,12 @@ class BaseDialect:
                         hook.process_persist_info(statement)
                 persist = process_persist(environment, statement, hooks=hooks)
                 output.append(persist)
+            elif isinstance(statement, CopyStatement):
+                if hooks:
+                    for hook in hooks:
+                        hook.process_select_info(statement.select)
+                copy = process_copy(environment, statement, hooks=hooks)
+                output.append(copy)
             elif isinstance(statement, SelectStatement):
                 if hooks:
                     for hook in hooks:

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/executor.py

@@ -10,6 +10,7 @@ from trilogy.core.models import (
     ProcessedShowStatement,
     ProcessedQueryPersist,
     ProcessedRawSQLStatement,
+    ProcessedCopyStatement,
     RawSQLStatement,
     MultiSelectStatement,
     SelectStatement,
@@ -18,9 +19,11 @@ from trilogy.core.models import (
     Concept,
     ConceptDeclarationStatement,
     Datasource,
+    CopyStatement,
 )
 from trilogy.dialect.base import BaseDialect
 from trilogy.dialect.enums import Dialects
+from trilogy.core.enums import IOType
 from trilogy.parser import parse_text
 from trilogy.hooks.base_hook import BaseHook
 from pathlib import Path
@@ -94,7 +97,15 @@ class Executor(object):
         self.connection = self.engine.connect()
 
     def execute_statement(self, statement) -> Optional[CursorResult]:
-        if not isinstance(statement, (ProcessedQuery, ProcessedQueryPersist)):
+        if not isinstance(
+            statement,
+            (
+                ProcessedQuery,
+                ProcessedShowStatement,
+                ProcessedQueryPersist,
+                ProcessedCopyStatement,
+            ),
+        ):
             return None
         return self.execute_query(statement)
 
@@ -183,12 +194,33 @@ class Executor(object):
 
     @execute_query.register
     def _(self, query: ProcessedQueryPersist) -> CursorResult:
+
         sql = self.generator.compile_statement(query)
-        # connection = self.engine.connect()
+
         output = self.connection.execute(text(sql))
         self.environment.add_datasource(query.datasource)
         return output
 
+    @execute_query.register
+    def _(self, query: ProcessedCopyStatement) -> CursorResult:
+        sql = self.generator.compile_statement(query)
+        output: CursorResult = self.connection.execute(text(sql))
+        if query.target_type == IOType.CSV:
+            import csv
+
+            with open(query.target, "w", newline="", encoding="utf-8") as f:
+                outcsv = csv.writer(f)
+                outcsv.writerow(output.keys())
+                outcsv.writerows(output)
+        else:
+            raise NotImplementedError(f"Unsupported IOType {query.target_type}")
+        # now return the query we ran through IO
+        # TODO: instead return how many rows were written?
+        return generate_result_set(
+            query.output_columns,
+            [self.generator.compile_statement(query)],
+        )
+
     @singledispatchmethod
     def generate_sql(self, command) -> list[str]:
         raise NotImplementedError(
@@ -251,39 +283,17 @@ class Executor(object):
         | ProcessedQueryPersist
         | ProcessedShowStatement
         | ProcessedRawSQLStatement
+        | ProcessedCopyStatement
     ]:
-        """Process a preql text command"""
-        _, parsed = parse_text(command, self.environment)
-        generatable = [
-            x
-            for x in parsed
-            if isinstance(
-                x,
-                (
-                    SelectStatement,
-                    PersistStatement,
-                    MultiSelectStatement,
-                    ShowStatement,
-                    RawSQLStatement,
-                ),
-            )
-        ]
-        sql = []
-        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)
-            sql.append(x)
-        return sql
+
+        return list(self.parse_text_generator(command, persist=persist))
 
     def parse_text_generator(self, command: str, persist: bool = False) -> Generator[
         ProcessedQuery
         | ProcessedQueryPersist
         | ProcessedShowStatement
-        | ProcessedRawSQLStatement,
+        | ProcessedRawSQLStatement
+        | ProcessedCopyStatement,
         None,
         None,
     ]:
@@ -300,6 +310,7 @@ class Executor(object):
                     MultiSelectStatement,
                     ShowStatement,
                     RawSQLStatement,
+                    CopyStatement,
                 ),
             )
         ]
@@ -340,13 +351,7 @@ class Executor(object):
                     )
                 )
                 continue
-            compiled_sql = self.generator.compile_statement(statement)
-            logger.debug(compiled_sql)
-
-            output.append(self.connection.execute(text(compiled_sql)))
-            # generalize post-run success hooks
-            if isinstance(statement, ProcessedQueryPersist):
-                self.environment.add_datasource(statement.datasource)
+            output.append(self.execute_query(statement))
         return output
 
     def execute_file(self, file: str | Path) -> List[CursorResult]:

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/parsing/parse_engine.py

@@ -1,7 +1,7 @@
 from os.path import dirname, join
 from typing import List, Optional, Tuple, Union
 from re import IGNORECASE
-from lark import Lark, Transformer, v_args
+from lark import Lark, Transformer, v_args, Tree
 from lark.exceptions import (
     UnexpectedCharacters,
     UnexpectedEOF,
@@ -31,6 +31,7 @@ from trilogy.core.enums import (
     DatePart,
     ShowCategory,
     FunctionClass,
+    IOType,
 )
 from trilogy.core.exceptions import InvalidSyntaxException, UndefinedConceptException
 from trilogy.core.functions import (
@@ -84,6 +85,7 @@ from trilogy.core.models import (
     PersistStatement,
     Query,
     RawSQLStatement,
+    CopyStatement,
     SelectStatement,
     SelectItem,
     WhereClause,
@@ -105,9 +107,11 @@ from trilogy.core.models import (
     ConceptDerivation,
     RowsetDerivationStatement,
     list_to_wrapper,
+    tuple_to_wrapper,
     dict_to_map_wrapper,
     NumericType,
     HavingClause,
+    TupleWrapper,
 )
 from trilogy.parsing.exceptions import ParseError
 from trilogy.parsing.common import (
@@ -748,13 +752,29 @@ class ParseToObjects(Transformer):
     def rawsql_statement(self, meta: Meta, args) -> RawSQLStatement:
         return RawSQLStatement(meta=Metadata(line_number=meta.line), text=args[0])
 
+    def COPY_TYPE(self, args) -> IOType:
+        return IOType(args.value)
+
+    @v_args(meta=True)
+    def copy_statement(self, meta: Meta, args) -> CopyStatement:
+
+        return CopyStatement(
+            target=args[1],
+            target_type=args[0],
+            meta=Metadata(line_number=meta.line),
+            select=args[-1],
+        )
+
     def resolve_import_address(self, address) -> str:
         with open(address, "r", encoding="utf-8") as f:
             text = f.read()
         return text
 
     def import_statement(self, args: list[str]) -> ImportStatement:
-        alias = args[-1]
+        if len(args) == 2:
+            alias = args[-1]
+        else:
+            alias = self.environment.namespace
         path = args[0].split(".")
 
         target = join(self.environment.working_path, *path) + ".preql"
@@ -1064,6 +1084,9 @@ class ParseToObjects(Transformer):
     def array_lit(self, args):
         return list_to_wrapper(args)
 
+    def tuple_lit(self, args):
+        return tuple_to_wrapper(args)
+
     def struct_lit(self, args):
 
         zipped = dict(zip(args[::2], args[1::2]))
@@ -1124,12 +1147,18 @@ class ParseToObjects(Transformer):
 
         while isinstance(right, Parenthetical) and isinstance(
             right.content,
-            (Concept, Function, FilterItem, WindowItem, AggregateWrapper, ListWrapper),
+            (
+                Concept,
+                Function,
+                FilterItem,
+                WindowItem,
+                AggregateWrapper,
+                ListWrapper,
+                TupleWrapper,
+            ),
         ):
             right = right.content
-        if isinstance(
-            right, (Function, FilterItem, WindowItem, AggregateWrapper, ListWrapper)
-        ):
+        if isinstance(right, (Function, FilterItem, WindowItem, AggregateWrapper)):
             right = arbitrary_to_concept(
                 right,
                 namespace=self.environment.namespace,
@@ -1142,7 +1171,7 @@ class ParseToObjects(Transformer):
         )
 
     def expr_tuple(self, args):
-        return Parenthetical(content=args)
+        return TupleWrapper(content=tuple(args))
 
     def parenthetical(self, args):
         return Parenthetical(content=args[0])
@@ -1840,10 +1869,12 @@ def unpack_visit_error(e: VisitError):
         unpack_visit_error(e.orig_exc)
     elif isinstance(e.orig_exc, (UndefinedConceptException, ImportError)):
         raise e.orig_exc
-    elif isinstance(e.orig_exc, SyntaxError):
-        raise InvalidSyntaxException(str(e.orig_exc) + str(e.rule) + str(e.obj))
-    elif isinstance(e.orig_exc, (ValidationError, TypeError)):
-        raise InvalidSyntaxException(str(e.orig_exc) + str(e.rule) + str(e.obj))
+    elif isinstance(e.orig_exc, (SyntaxError, TypeError)):
+        if isinstance(e.obj, Tree):
+            raise InvalidSyntaxException(
+                str(e.orig_exc) + " in " + str(e.rule) + f" Line: {e.obj.meta.line}"
+            )
+        raise InvalidSyntaxException(str(e.orig_exc))
     raise e
 
 

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/parsing/render.py

@@ -32,6 +32,8 @@ from trilogy.core.models import (
     AggregateWrapper,
     PersistStatement,
     ListWrapper,
+    ListType,
+    TupleWrapper,
     RowsetDerivationStatement,
     MultiSelectStatement,
     OrderBy,
@@ -40,6 +42,7 @@ from trilogy.core.models import (
     RawSQLStatement,
     NumericType,
     MergeStatementV2,
+    CopyStatement,
 )
 from trilogy.core.enums import Modifier
 
@@ -180,6 +183,10 @@ class Renderer:
     def _(self, arg: ListWrapper):
         return "[" + ", ".join([self.to_string(x) for x in arg]) + "]"
 
+    @to_string.register
+    def _(self, arg: TupleWrapper):
+        return "(" + ", ".join([self.to_string(x) for x in arg]) + ")"
+
     @to_string.register
     def _(self, arg: DatePart):
         return arg.value
@@ -211,21 +218,30 @@ class Renderer:
             base_description = concept.metadata.description
         else:
             base_description = None
-        if concept.namespace:
+        if concept.namespace and concept.namespace != DEFAULT_NAMESPACE:
             namespace = f"{concept.namespace}."
         else:
             namespace = ""
         if not concept.lineage:
             if concept.purpose == Purpose.PROPERTY and concept.keys:
-                output = f"{concept.purpose.value} {namespace}{concept.keys[0].name}.{concept.name} {concept.datatype.value};"
+                keys = ",".join([self.to_string(key) for key in concept.keys])
+                output = f"{concept.purpose.value} <{keys}>.{namespace}{concept.name} {self.to_string(concept.datatype)};"
             else:
-                output = f"{concept.purpose.value} {namespace}{concept.name} {concept.datatype.value};"
+                output = f"{concept.purpose.value} {namespace}{concept.name} {self.to_string(concept.datatype)};"
         else:
             output = f"{concept.purpose.value} {namespace}{concept.name} <- {self.to_string(concept.lineage)};"
         if base_description:
             output += f" # {base_description}"
         return output
 
+    @to_string.register
+    def _(self, arg: ListType):
+        return f"list<{self.to_string(arg.value_data_type)}>"
+
+    @to_string.register
+    def _(self, arg: DataType):
+        return arg.value
+
     @to_string.register
     def _(self, arg: ConceptDerivation):
         # this is identical rendering;
@@ -271,6 +287,10 @@ class Renderer:
         base += "\n;"
         return base
 
+    @to_string.register
+    def _(self, arg: CopyStatement):
+        return f"COPY INTO {arg.target_type.value.upper()} '{arg.target}' FROM {self.to_string(arg.select)}"
+
     @to_string.register
     def _(self, arg: AlignClause):
         return "\nALIGN\n\t" + ",\n\t".join([self.to_string(c) for c in arg.items])

{pytrilogy-0.0.2.22 → pytrilogy-0.0.2.23}/trilogy/parsing/trilogy.lark

@@ -8,7 +8,7 @@
     | persist_statement
     | rowset_derivation_statement
     | import_statement
-
+    | copy_statement
     | merge_statement_v2
     | rawsql_statement
     
@@ -57,7 +57,7 @@
     
     column_list : (IDENTIFIER "," )* IDENTIFIER ","?
     
-    import_statement: "import" (IDENTIFIER ".") * IDENTIFIER "as" IDENTIFIER
+    import_statement: "import" IDENTIFIER ("."  IDENTIFIER)* ("as" IDENTIFIER)?
 
     // persist_statement
     persist_statement: "persist"i IDENTIFIER "into"i IDENTIFIER "from"i select_statement grain_clause?
@@ -78,6 +78,12 @@
     // raw sql statement
     rawsql_statement: "raw_sql"i "(" MULTILINE_STRING ")"
 
+    // copy statement
+
+    COPY_TYPE: "csv"i
+
+    copy_statement: "copy"i "into"i COPY_TYPE _string_lit "from"i select_statement
+
     // FUNCTION blocks
     function: raw_function
     function_binding_item: IDENTIFIER ":" data_type
@@ -303,6 +309,8 @@
 
     array_lit: "[" (literal ",")* literal ","? "]"()
 
+    tuple_lit: "(" (literal ",")* literal ","? ")"
+
     map_lit: "{" (literal ":" literal ",")* literal ":" literal ","? "}"
 
     _STRUCT.1: "struct("i
@@ -312,7 +320,7 @@
 
     !null_lit.1: "null"i
     
-    literal: null_lit | _string_lit | int_lit | float_lit | bool_lit | array_lit | map_lit | struct_lit
+    literal: null_lit | _string_lit | int_lit | float_lit | bool_lit | array_lit | map_lit | struct_lit | tuple_lit
 
     MODIFIER: "Optional"i | "Partial"i | "Nullable"i
 

pytrilogy-0.0.2.22/tests/test_imports.py

@@ -1,23 +0,0 @@
-from trilogy import Environment
-
-
-def test_multi_environment():
-    basic = Environment()
-
-    basic.parse(
-        """
-const pi <- 3.14;
-                     
-
-""",
-        namespace="math",
-    )
-
-    basic.parse(
-        """
-                
-            select math.pi;
-                """
-    )
-
-    assert basic.concepts["math.pi"].name == "pi"