pytrilogy 0.0.2.36__tar.gz → 0.0.2.37__tar.gz

{pytrilogy-0.0.2.36/pytrilogy.egg-info → pytrilogy-0.0.2.37}/PKG-INFO

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

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/tests/test_select.py

@@ -126,7 +126,7 @@ def test_modifiers():
     generator = BigqueryDialect()
 
     text = generator.compile_statement(query)
-    assert "2 = 2" in text
+    assert ":b = 2" in text
     assert "as `b`" not in text
 
 

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

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/constants.py

@@ -39,6 +39,13 @@ class Comments:
     partial: bool = True
 
 
+@dataclass
+class Rendering:
+    """Control how the SQL is rendered"""
+
+    parameters: bool = True
+
+
 # TODO: support loading from environments
 @dataclass
 class Config:
@@ -48,6 +55,7 @@ class Config:
     validate_missing: bool = True
     comments: Comments = field(default_factory=Comments)
     optimizations: Optimizations = field(default_factory=Optimizations)
+    rendering: Rendering = field(default_factory=Rendering)
 
     @property
     def show_comments(self) -> bool:

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/core/models.py

@@ -3381,6 +3381,21 @@ class Environment(BaseModel):
     materialized_concepts: List[Concept] = Field(default_factory=list)
     alias_origin_lookup: Dict[str, Concept] = Field(default_factory=dict)
 
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.concepts["_env_working_path"] = Concept(
+            name="_env_working_path",
+            namespace=self.namespace,
+            lineage=Function(
+                operator=FunctionType.CONSTANT,
+                arguments=[str(self.working_path)],
+                output_datatype=DataType.STRING,
+                output_purpose=Purpose.CONSTANT,
+            ),
+            datatype=DataType.STRING,
+            purpose=Purpose.CONSTANT,
+        )
+
     @classmethod
     def from_file(cls, path: str | Path) -> "Environment":
         with open(path, "r") as f:
@@ -3554,16 +3569,7 @@ class Environment(BaseModel):
             target = target.with_suffix(".preql")
         else:
             target = path
-        if alias in self.imports:
-            imports = self.imports[alias]
-            for x in imports:
-                if x.path == target:
-                    return imports
-        if env:
-            self.imports[alias].append(
-                ImportStatement(alias=alias, path=target, environment=env)
-            )
-        else:
+        if not env:
             parse_address = gen_cache_lookup(str(target), alias, str(self.working_path))
             try:
                 with open(target, "r", encoding="utf-8") as f:
@@ -3587,13 +3593,8 @@ class Environment(BaseModel):
                     f"Unable to import file {target.parent}, parsing error: {e}"
                 )
             env = nparser.environment
-        for _, concept in env.concepts.items():
-            self.add_concept(concept.with_namespace(alias))
-
-        for _, datasource in env.datasources.items():
-            self.add_datasource(datasource.with_namespace(alias))
         imps = ImportStatement(alias=alias, path=target, environment=env)
-        self.imports[alias].append(imps)
+        self.add_import(alias, source=env, imp_stm=imps)
         return imps
 
     def parse(

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/dialect/base.py

@@ -337,6 +337,13 @@ class BaseDialect:
                         " target grain"
                     )
                     rval = f"{self.FUNCTION_GRAIN_MATCH_MAP[c.lineage.function.operator](args)}"
+            elif (
+                isinstance(c.lineage, Function)
+                and c.lineage.operator == FunctionType.CONSTANT
+                and CONFIG.rendering.parameters is True
+                and c.datatype.data_type != DataType.MAP
+            ):
+                rval = f":{c.safe_address}"
             else:
                 args = [
                     self.render_expr(
@@ -541,7 +548,7 @@ class BaseDialect:
         else:
             raise ValueError(f"Unable to render type {type(e)} {e}")
 
-    def render_cte(self, cte: CTE, auto_sort: bool = True):
+    def render_cte(self, cte: CTE, auto_sort: bool = True) -> CompiledCTE:
         if self.UNNEST_MODE in (
             UnnestMode.CROSS_APPLY,
             UnnestMode.CROSS_JOIN,

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/executor.py

@@ -22,10 +22,14 @@ from trilogy.core.models import (
     CopyStatement,
     ImportStatement,
     MergeStatementV2,
+    Function,
+    FunctionType,
+    MapWrapper,
+    ListWrapper,
 )
 from trilogy.dialect.base import BaseDialect
 from trilogy.dialect.enums import Dialects
-from trilogy.core.enums import IOType
+from trilogy.core.enums import IOType, Granularity
 from trilogy.parser import parse_text
 from trilogy.hooks.base_hook import BaseHook
 from pathlib import Path
@@ -185,7 +189,6 @@ class Executor(object):
 
     @execute_query.register
     def _(self, query: ImportStatement) -> CursorResult:
-        self.environment.add_file_import(query.path, query.alias)
         return MockResult(
             [
                 {
@@ -219,8 +222,7 @@ class Executor(object):
     @execute_query.register
     def _(self, query: ProcessedQuery) -> CursorResult:
         sql = self.generator.compile_statement(query)
-        # connection = self.engine.connect()
-        output = self.connection.execute(text(sql))
+        output = self.execute_raw_sql(sql)
         return output
 
     @execute_query.register
@@ -228,14 +230,14 @@ class Executor(object):
 
         sql = self.generator.compile_statement(query)
 
-        output = self.connection.execute(text(sql))
+        output = self.execute_raw_sql(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))
+        output: CursorResult = self.execute_raw_sql(sql)
         if query.target_type == IOType.CSV:
             import csv
 
@@ -244,7 +246,7 @@ class Executor(object):
                 outcsv.writerow(output.keys())
                 outcsv.writerows(output)
         else:
-            raise NotImplementedError(f"Unsupported IOType {query.target_type}")
+            raise NotImplementedError(f"Unsupported IO Type {query.target_type}")
         # now return the query we ran through IO
         # TODO: instead return how many rows were written?
         return generate_result_set(
@@ -370,13 +372,50 @@ class Executor(object):
             if persist and isinstance(x, ProcessedQueryPersist):
                 self.environment.add_datasource(x.datasource)
 
+    def _hydrate_param(self, param: str) -> Any:
+        matched = [
+            v
+            for v in self.environment.concepts.values()
+            if v.safe_address == param or v.address == param
+        ]
+        if not matched:
+            raise SyntaxError(f"No concept found for parameter {param}")
+
+        concept: Concept = matched.pop()
+        if not concept.granularity == Granularity.SINGLE_ROW:
+            raise SyntaxError(f"Cannot bind non-singleton concept {concept.address}")
+        if (
+            isinstance(concept.lineage, Function)
+            and concept.lineage.operator == FunctionType.CONSTANT
+        ):
+            rval = concept.lineage.arguments[0]
+            if isinstance(rval, ListWrapper):
+                return [x for x in rval]
+            if isinstance(rval, MapWrapper):
+                return {k: v for k, v in rval.items()}
+            return rval
+        else:
+            results = self.execute_query(f"select {concept.name} limit 1;").fetchone()
+        if not results:
+            return None
+        return results[0]
+
     def execute_raw_sql(
         self, command: str, variables: dict | None = None
     ) -> CursorResult:
         """Run a command against the raw underlying
         execution engine"""
+        final_params = None
+        q = text(command)
         if variables:
-            return self.connection.execute(text(command), variables)
+            final_params = variables
+        else:
+            params = q.compile().params
+            if params:
+                final_params = {x: self._hydrate_param(x) for x in params}
+
+        if final_params:
+            return self.connection.execute(text(command), final_params)
         return self.connection.execute(
             text(command),
         )

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/parsing/parse_engine.py

@@ -804,7 +804,8 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def rawsql_statement(self, meta: Meta, args) -> RawSQLStatement:
-        return RawSQLStatement(meta=Metadata(line_number=meta.line), text=args[0])
+        statement = RawSQLStatement(meta=Metadata(line_number=meta.line), text=args[0])
+        return statement
 
     def COPY_TYPE(self, args) -> IOType:
         return IOType(args.value)

{pytrilogy-0.0.2.36 → pytrilogy-0.0.2.37}/trilogy/parsing/trilogy.lark

@@ -302,7 +302,7 @@
     SINGLE_STRING_CHARS: /(?:(?!\${)([^'\\]|\\.))+/+ // any character except '
     _single_quote: "'" ( SINGLE_STRING_CHARS )* "'" 
     _double_quote: "\"" ( DOUBLE_STRING_CHARS )* "\"" 
-    string_lit: _single_quote | _double_quote
+    string_lit: _single_quote | _double_quote | MULTILINE_STRING
 
     MINUS: "-"