pytrilogy 0.0.2.58__py3-none-any.whl → 0.0.3.1__py3-none-any.whl

trilogy/dialect/base.py

@@ -11,63 +11,82 @@ from trilogy.core.enums import (
     WindowType,
 )
 from trilogy.core.internal import DEFAULT_CONCEPTS
-from trilogy.core.models import (
-    CTE,
-    AggregateWrapper,
-    CaseElse,
-    CaseWhen,
-    Comparison,
-    CompiledCTE,
-    Concept,
-    ConceptDeclarationStatement,
-    Conditional,
-    CopyStatement,
-    Datasource,
+from trilogy.core.models.build import (
+    BuildAggregateWrapper,
+    BuildCaseElse,
+    BuildCaseWhen,
+    BuildComparison,
+    BuildConcept,
+    BuildConditional,
+    BuildFilterItem,
+    BuildFunction,
+    BuildMultiSelectLineage,
+    BuildOrderItem,
+    BuildParenthetical,
+    BuildRowsetItem,
+    BuildSubselectComparison,
+    BuildWindowItem,
+    Factory,
+)
+from trilogy.core.models.core import (
     DataType,
-    Environment,
-    FilterItem,
-    Function,
-    ImportStatement,
     ListType,
     ListWrapper,
     MapType,
     MapWrapper,
-    MergeStatementV2,
-    MultiSelectStatement,
     NumericType,
-    OrderItem,
-    Parenthetical,
-    PersistStatement,
-    ProcessedCopyStatement,
-    ProcessedQuery,
-    ProcessedQueryPersist,
-    ProcessedRawSQLStatement,
-    ProcessedShowStatement,
-    RawColumnExpr,
-    RawSQLStatement,
-    RowsetDerivationStatement,
-    RowsetItem,
-    SelectStatement,
-    ShowStatement,
     StructType,
-    SubselectComparison,
     TupleWrapper,
-    UnionCTE,
-    WindowItem,
 )
+from trilogy.core.models.datasource import Datasource, RawColumnExpr
+from trilogy.core.models.environment import Environment
+from trilogy.core.models.execute import CTE, CompiledCTE, UnionCTE
 from trilogy.core.processing.utility import (
     decompose_condition,
     is_scalar_condition,
     sort_select_output,
 )
 from trilogy.core.query_processor import process_copy, process_persist, process_query
+from trilogy.core.statements.author import (
+    ConceptDeclarationStatement,
+    CopyStatement,
+    ImportStatement,
+    MergeStatementV2,
+    MultiSelectStatement,
+    PersistStatement,
+    RawSQLStatement,
+    RowsetDerivationStatement,
+    SelectStatement,
+    ShowStatement,
+)
+from trilogy.core.statements.execute import (
+    ProcessedCopyStatement,
+    ProcessedQuery,
+    ProcessedQueryPersist,
+    ProcessedRawSQLStatement,
+    ProcessedShowStatement,
+)
 from trilogy.dialect.common import render_join, render_unnest
 from trilogy.hooks.base_hook import BaseHook
 
 LOGGER_PREFIX = "[RENDERING]"
 
+WINDOW_ITEMS = (BuildWindowItem,)
+FILTER_ITEMS = (BuildFilterItem,)
+AGGREGATE_ITEMS = (BuildAggregateWrapper,)
+FUNCTION_ITEMS = (BuildFunction,)
+PARENTHETICAL_ITEMS = (BuildParenthetical,)
+CASE_WHEN_ITEMS = (BuildCaseWhen,)
+CASE_ELSE_ITEMS = (BuildCaseElse,)
+SUBSELECT_COMPARISON_ITEMS = (BuildSubselectComparison,)
+COMPARISON_ITEMS = (BuildComparison,)
+CONDITIONAL_ITEMS = (BuildConditional,)
+
 
 def INVALID_REFERENCE_STRING(x: Any, callsite: str = ""):
+    # if CONFIG.validate_missing:
+    #     raise SyntaxError(f"INVALID_REFERENCE_BUG_{callsite}<{x}>")
+
     return f"INVALID_REFERENCE_BUG_{callsite}<{x}>"
 
 
@@ -237,7 +256,7 @@ def safe_quote(string: str, quote_char: str):
     return ".".join([f"{quote_char}{string}{quote_char}" for string in components])
 
 
-def safe_get_cte_value(coalesce, cte: CTE | UnionCTE, c: Concept, quote_char: str):
+def safe_get_cte_value(coalesce, cte: CTE | UnionCTE, c: BuildConcept, quote_char: str):
     address = c.address
     raw = cte.source_map.get(address, None)
 
@@ -265,25 +284,26 @@ class BaseDialect:
 
     def render_order_item(
         self,
-        order_item: OrderItem,
+        order_item: BuildOrderItem,
         cte: CTE | UnionCTE,
         final: bool = False,
         alias: bool = True,
     ) -> str:
-        if final:
-            if not alias:
-                return f"{self.QUOTE_CHARACTER}{order_item.expr.safe_address}{self.QUOTE_CHARACTER} {order_item.order.value}"
+        # if final:
+        #     if not alias:
+        #         return f"{self.QUOTE_CHARACTER}{order_item.expr.safe_address}{self.QUOTE_CHARACTER} {order_item.order.value}"
 
-            return f"{cte.name}.{self.QUOTE_CHARACTER}{order_item.expr.safe_address}{self.QUOTE_CHARACTER} {order_item.order.value}"
+        #     return f"{cte.name}.{self.QUOTE_CHARACTER}{order_item.expr.safe_address}{self.QUOTE_CHARACTER} {order_item.order.value}"
 
-        return f"{self.render_concept_sql(order_item.expr, cte=cte, alias=False)} {order_item.order.value}"
+        return f"{self.render_expr(order_item.expr, cte=cte, qualify=False)} {order_item.order.value}"
 
     def render_concept_sql(
         self,
-        c: Concept,
+        c: BuildConcept,
         cte: CTE | UnionCTE,
         alias: bool = True,
         raise_invalid: bool = False,
+        qualify: bool = True,
     ) -> str:
         result = None
         if c.pseudonyms:
@@ -297,20 +317,26 @@ class BaseDialect:
                         f"{LOGGER_PREFIX} [{c.address}] Attempting rendering w/ candidate {candidate.address}"
                     )
                     result = self._render_concept_sql(
-                        candidate, cte, raise_invalid=True
+                        candidate, cte, raise_invalid=True, qualify=qualify
                     )
                     if result:
                         break
                 except ValueError:
                     continue
         if not result:
-            result = self._render_concept_sql(c, cte, raise_invalid=raise_invalid)
+            result = self._render_concept_sql(
+                c, cte, raise_invalid=raise_invalid, qualify=qualify
+            )
         if alias:
             return f"{result} as {self.QUOTE_CHARACTER}{c.safe_address}{self.QUOTE_CHARACTER}"
         return result
 
     def _render_concept_sql(
-        self, c: Concept, cte: CTE | UnionCTE, raise_invalid: bool = False
+        self,
+        c: BuildConcept,
+        cte: CTE | UnionCTE,
+        raise_invalid: bool = False,
+        qualify: bool = True,
     ) -> str:
         # only recurse while it's in sources of the current cte
         logger.debug(
@@ -322,9 +348,9 @@ class BaseDialect:
             logger.debug(
                 f"{LOGGER_PREFIX} [{c.address}] rendering concept with lineage that is not already existing, have {cte.source_map}"
             )
-            if isinstance(c.lineage, WindowItem):
+            if isinstance(c.lineage, WINDOW_ITEMS):
                 rendered_order_components = [
-                    f"{self.render_concept_sql(x.expr, cte, alias=False, raise_invalid=raise_invalid)} {x.order.value}"
+                    f"{self.render_expr(x.expr, cte, raise_invalid=raise_invalid)} {x.order.value}"
                     for x in c.lineage.order_by
                 ]
                 rendered_over_components = [
@@ -345,17 +371,17 @@ class BaseDialect:
                     sort=",".join(rendered_order_components),
                     offset=c.lineage.index,
                 )
-            elif isinstance(c.lineage, FilterItem):
+            elif isinstance(c.lineage, FILTER_ITEMS):
                 # for cases when we've optimized this
                 if cte.condition == c.lineage.where.conditional:
                     rval = self.render_expr(c.lineage.content, cte=cte)
                 else:
                     rval = f"CASE WHEN {self.render_expr(c.lineage.where.conditional, cte=cte)} THEN {self.render_concept_sql(c.lineage.content, cte=cte, alias=False, raise_invalid=raise_invalid)} ELSE NULL END"
-            elif isinstance(c.lineage, RowsetItem):
+            elif isinstance(c.lineage, BuildRowsetItem):
                 rval = f"{self.render_concept_sql(c.lineage.content, cte=cte, alias=False, raise_invalid=raise_invalid)}"
-            elif isinstance(c.lineage, MultiSelectStatement):
+            elif isinstance(c.lineage, BuildMultiSelectLineage):
                 rval = f"{self.render_concept_sql(c.lineage.find_source(c, cte), cte=cte, alias=False, raise_invalid=raise_invalid)}"
-            elif isinstance(c.lineage, AggregateWrapper):
+            elif isinstance(c.lineage, AGGREGATE_ITEMS):
                 args = [
                     self.render_expr(v, cte)  # , alias=False)
                     for v in c.lineage.function.arguments
@@ -369,21 +395,21 @@ class BaseDialect:
                     )
                     rval = f"{self.FUNCTION_GRAIN_MATCH_MAP[c.lineage.function.operator](args)}"
             elif (
-                isinstance(c.lineage, Function)
+                isinstance(c.lineage, FUNCTION_ITEMS)
                 and c.lineage.operator == FunctionType.UNION
             ):
                 local_matched = [
                     x
                     for x in c.lineage.arguments
-                    if isinstance(x, Concept) and x.address in cte.output_columns
+                    if isinstance(x, BuildConcept) and x.address in cte.output_columns
                 ]
+                # if we're sorting by the output of the union
                 if not local_matched:
-                    raise SyntaxError(
-                        "Could not find appropriate source element for union"
-                    )
-                rval = self.render_expr(local_matched[0], cte)
+                    rval = c.safe_address
+                else:
+                    rval = self.render_expr(local_matched[0], cte)
             elif (
-                isinstance(c.lineage, Function)
+                isinstance(c.lineage, FUNCTION_ITEMS)
                 and c.lineage.operator == FunctionType.CONSTANT
                 and CONFIG.rendering.parameters is True
                 and c.datatype.data_type != DataType.MAP
@@ -393,9 +419,9 @@ class BaseDialect:
                 args = []
                 for arg in c.lineage.arguments:
                     if (
-                        isinstance(arg, Concept)
+                        isinstance(arg, BuildConcept)
                         and arg.lineage
-                        and isinstance(arg.lineage, Function)
+                        and isinstance(arg.lineage, FUNCTION_ITEMS)
                         and arg.lineage.operator
                         in (
                             FunctionType.ADD,
@@ -406,7 +432,7 @@ class BaseDialect:
                     ):
                         args.append(
                             self.render_expr(
-                                Parenthetical(content=arg),
+                                BuildParenthetical(content=arg),
                                 cte=cte,
                                 raise_invalid=raise_invalid,
                             )
@@ -422,13 +448,13 @@ class BaseDialect:
                     rval = f"{self.FUNCTION_GRAIN_MATCH_MAP[c.lineage.operator](args)}"
         else:
             logger.debug(
-                f"{LOGGER_PREFIX} [{c.address}] Rendering basic lookup from {cte.source_map.get(c.address, INVALID_REFERENCE_STRING('Missing source reference'))}"
+                f"{LOGGER_PREFIX} [{c.address}] Rendering basic lookup from {cte.source_map.get(c.address,None)}"
             )
 
             raw_content = cte.get_alias(c)
             if isinstance(raw_content, RawColumnExpr):
                 rval = raw_content.text
-            elif isinstance(raw_content, Function):
+            elif isinstance(raw_content, FUNCTION_ITEMS):
                 rval = self.render_expr(
                     raw_content, cte=cte, raise_invalid=raise_invalid
                 )
@@ -440,23 +466,34 @@ class BaseDialect:
                     self.QUOTE_CHARACTER,
                 )
                 if not rval:
-                    if raise_invalid:
-                        raise ValueError(
-                            f"Invalid reference string found in query: {rval}, this should never occur. Please report this issue."
+                    # unions won't have a specific source mapped; just use a generic column reference
+                    # we shouldn't ever have an expression at this point, so will be safe
+                    if isinstance(cte, UnionCTE):
+                        rval = c.safe_address
+                    else:
+                        if raise_invalid:
+                            raise ValueError(
+                                f"Invalid reference string found in query: {rval}, this should never occur. Please report this issue."
+                            )
+                        rval = INVALID_REFERENCE_STRING(
+                            f"Missing source reference to {c.address}"
                         )
-                    rval = INVALID_REFERENCE_STRING(
-                        f"Missing source reference to {c.address}"
-                    )
         return rval
 
     def render_expr(
         self,
         e: Union[
-            Function,
-            Conditional,
-            Comparison,
-            SubselectComparison,
-            Concept,
+            BuildConcept,
+            BuildFunction,
+            BuildConditional,
+            BuildAggregateWrapper,
+            BuildComparison,
+            BuildCaseWhen,
+            BuildCaseElse,
+            BuildSubselectComparison,
+            BuildWindowItem,
+            BuildFilterItem,
+            BuildParenthetical,
             str,
             int,
             list,
@@ -465,9 +502,6 @@ class BaseDialect:
             date,
             datetime,
             DataType,
-            Function,
-            Parenthetical,
-            AggregateWrapper,
             MagicConstants,
             MapWrapper[Any, Any],
             MapType,
@@ -477,18 +511,14 @@ class BaseDialect:
             ListWrapper[Any],
             TupleWrapper[Any],
             DatePart,
-            CaseWhen,
-            CaseElse,
-            WindowItem,
-            FilterItem,
-            # FilterItem
         ],
         cte: Optional[CTE | UnionCTE] = None,
         cte_map: Optional[Dict[str, CTE | UnionCTE]] = None,
         raise_invalid: bool = False,
+        qualify: bool = True,
     ) -> str:
-        if isinstance(e, SubselectComparison):
-            if isinstance(e.right, Concept):
+        if isinstance(e, SUBSELECT_COMPARISON_ITEMS):
+            if isinstance(e.right, BuildConcept):
                 # we won't always have an existnce map
                 # so fall back to the normal map
                 lookup_cte = cte
@@ -513,7 +543,10 @@ 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, TupleWrapper, Parenthetical, list)):
+            elif isinstance(
+                e.right,
+                (ListWrapper, TupleWrapper, BuildParenthetical, 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(
@@ -528,12 +561,12 @@ class BaseDialect:
                 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)})"
             else:
                 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(e, Comparison):
+        elif isinstance(e, COMPARISON_ITEMS):
             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(e, Conditional):
+        elif isinstance(e, CONDITIONAL_ITEMS):
             # conditions need to be nested in parentheses
             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(e, WindowItem):
+        elif isinstance(e, WINDOW_ITEMS):
             rendered_order_components = [
                 f"{self.render_expr(x.expr, cte, cte_map=cte_map, raise_invalid=raise_invalid)} {x.order.value}"
                 for x in e.order_by
@@ -543,22 +576,22 @@ class BaseDialect:
                 for x in e.over
             ]
             return f"{self.WINDOW_FUNCTION_MAP[e.type](concept = self.render_expr(e.content, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid), window=','.join(rendered_over_components), sort=','.join(rendered_order_components))}"  # noqa: E501
-        elif isinstance(e, Parenthetical):
+        elif isinstance(e, PARENTHETICAL_ITEMS):
             # conditions need to be nested in parentheses
             if isinstance(e.content, list):
                 return f"( {','.join([self.render_expr(x, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) for x in e.content])} )"
             return f"( {self.render_expr(e.content, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} )"
-        elif isinstance(e, CaseWhen):
+        elif isinstance(e, CASE_WHEN_ITEMS):
             return f"WHEN {self.render_expr(e.comparison, cte=cte, cte_map=cte_map) } THEN {self.render_expr(e.expr, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) }"
-        elif isinstance(e, CaseElse):
+        elif isinstance(e, CASE_ELSE_ITEMS):
             return f"ELSE {self.render_expr(e.expr, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) }"
-        elif isinstance(e, Function):
+        elif isinstance(e, FUNCTION_ITEMS):
             arguments = []
             for arg in e.arguments:
                 if (
-                    isinstance(arg, Concept)
+                    isinstance(arg, BuildConcept)
                     and arg.lineage
-                    and isinstance(arg.lineage, Function)
+                    and isinstance(arg.lineage, FUNCTION_ITEMS)
                     and arg.lineage.operator
                     in (
                         FunctionType.ADD,
@@ -569,7 +602,7 @@ class BaseDialect:
                 ):
                     arguments.append(
                         self.render_expr(
-                            Parenthetical(content=arg),
+                            BuildParenthetical(content=arg),
                             cte=cte,
                             cte_map=cte_map,
                             raise_invalid=raise_invalid,
@@ -586,15 +619,15 @@ class BaseDialect:
                 return self.FUNCTION_MAP[e.operator](arguments)
 
             return self.FUNCTION_GRAIN_MATCH_MAP[e.operator](arguments)
-        elif isinstance(e, AggregateWrapper):
+        elif isinstance(e, AGGREGATE_ITEMS):
             return self.render_expr(
                 e.function, cte, cte_map=cte_map, raise_invalid=raise_invalid
             )
-        elif isinstance(e, FilterItem):
+        elif isinstance(e, FILTER_ITEMS):
             return f"CASE WHEN {self.render_expr(e.where.conditional,cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} THEN {self.render_expr(e.content, cte, cte_map=cte_map, raise_invalid=raise_invalid)} ELSE NULL END"
-        elif isinstance(e, Concept):
+        elif isinstance(e, BuildConcept):
             if (
-                isinstance(e.lineage, Function)
+                isinstance(e.lineage, FUNCTION_ITEMS)
                 and e.lineage.operator == FunctionType.CONSTANT
                 and CONFIG.rendering.parameters is True
                 and e.datatype.data_type != DataType.MAP
@@ -602,7 +635,11 @@ class BaseDialect:
                 return f":{e.safe_address}"
             if cte:
                 return self.render_concept_sql(
-                    e, cte, alias=False, raise_invalid=raise_invalid
+                    e,
+                    cte,
+                    alias=False,
+                    raise_invalid=raise_invalid,
+                    qualify=qualify,
                 )
             elif cte_map:
                 return f"{cte_map[e.address].name}.{self.QUOTE_CHARACTER}{e.safe_address}{self.QUOTE_CHARACTER}"
@@ -643,6 +680,7 @@ class BaseDialect:
                 [self.render_cte(child).statement for child in cte.internal_ctes]
             )
             if cte.order_by:
+
                 ordering = [
                     self.render_order_item(i, cte, final=True, alias=False)
                     for i in cte.order_by.items
@@ -703,8 +741,8 @@ class BaseDialect:
             final_joins = []
         else:
             final_joins = cte.joins or []
-        where: Conditional | Parenthetical | Comparison | None = None
-        having: Conditional | Parenthetical | Comparison | None = None
+        where: BuildConditional | BuildParenthetical | BuildComparison | None = None
+        having: BuildConditional | BuildParenthetical | BuildComparison | None = None
         materialized = {x for x, v in cte.source_map.items() if v}
         if cte.condition:
             if not cte.group_to_grain or is_scalar_condition(
@@ -807,6 +845,7 @@ class BaseDialect:
             | ProcessedRawSQLStatement
             | ProcessedCopyStatement
         ] = []
+        factory = Factory(environment=environment)
         for statement in statements:
             if isinstance(statement, PersistStatement):
                 if hooks:
@@ -837,12 +876,15 @@ class BaseDialect:
             elif isinstance(statement, ShowStatement):
                 # TODO - encapsulate this a little better
                 if isinstance(statement.content, SelectStatement):
+
                     output.append(
                         ProcessedShowStatement(
                             output_columns=[
-                                environment.concepts[
-                                    DEFAULT_CONCEPTS["query_text"].address
-                                ]
+                                factory.build(
+                                    environment.concepts[
+                                        DEFAULT_CONCEPTS["query_text"].address
+                                    ]
+                                )
                             ],
                             output_values=[
                                 process_query(

trilogy/dialect/common.py

@@ -1,13 +1,12 @@
 from typing import Callable
 
 from trilogy.core.enums import Modifier, UnnestMode
-from trilogy.core.models import (
+from trilogy.core.models.build import BuildConcept, BuildFunction
+from trilogy.core.models.datasource import RawColumnExpr
+from trilogy.core.models.execute import (
     CTE,
-    Concept,
-    Function,
     InstantiatedUnnestJoin,
     Join,
-    RawColumnExpr,
 )
 
 
@@ -20,8 +19,8 @@ def null_wrapper(lval: str, rval: str, modifiers: list[Modifier]) -> str:
 def render_unnest(
     unnest_mode: UnnestMode,
     quote_character: str,
-    concept: Concept,
-    render_func: Callable[[Concept, CTE, bool], str],
+    concept: BuildConcept,
+    render_func: Callable[[BuildConcept, CTE, bool], str],
     cte: CTE,
 ):
     if unnest_mode == UnnestMode.CROSS_JOIN:
@@ -33,7 +32,7 @@ def render_join_concept(
     name: str,
     quote_character: str,
     cte: CTE,
-    concept: Concept,
+    concept: BuildConcept,
     render_expr,
     inlined_ctes: set[str],
 ):
@@ -43,7 +42,7 @@ def render_join_concept(
         if isinstance(raw_content, RawColumnExpr):
             rval = raw_content.text
             return rval
-        elif isinstance(raw_content, Function):
+        elif isinstance(raw_content, BuildFunction):
             rval = render_expr(raw_content, cte=cte)
             return rval
         return f"{name}.{quote_character}{raw_content}{quote_character}"
@@ -53,8 +52,8 @@ def render_join_concept(
 def render_join(
     join: Join | InstantiatedUnnestJoin,
     quote_character: str,
-    render_func: Callable[[Concept, CTE, bool], str],
-    render_expr_func: Callable[[Concept, CTE], str],
+    render_func: Callable[[BuildConcept, CTE, bool], str],
+    render_expr_func: Callable[[BuildConcept, CTE], str],
     cte: CTE,
     unnest_mode: UnnestMode = UnnestMode.CROSS_APPLY,
 ) -> str | None:

trilogy/dialect/duckdb.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Mapping
 from jinja2 import Template
 
 from trilogy.core.enums import FunctionType, UnnestMode, WindowType
-from trilogy.core.models import DataType
+from trilogy.core.models.core import DataType
 from trilogy.dialect.base import BaseDialect
 
 WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}

trilogy/dialect/enums.py

@@ -1,8 +1,10 @@
 from enum import Enum
 from typing import TYPE_CHECKING, Callable, List, Optional
 
+from trilogy.core.models.environment import Environment
+
 if TYPE_CHECKING:
-    from trilogy import Environment, Executor
+    from trilogy import Executor
     from trilogy.hooks.base_hook import BaseHook
 
 from trilogy.constants import logger
@@ -98,7 +100,7 @@ class Dialects(Enum):
         conf: DialectConfig | None = None,
         _engine_factory: Callable | None = None,
     ) -> "Executor":
-        from trilogy import Environment, Executor
+        from trilogy import Executor
 
         if _engine_factory is not None:
             return Executor(

trilogy/dialect/presto.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Mapping
 from jinja2 import Template
 
 from trilogy.core.enums import FunctionType, UnnestMode, WindowType
-from trilogy.core.models import DataType
+from trilogy.core.models.core import DataType
 from trilogy.dialect.base import BaseDialect
 
 WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}

trilogy/dialect/sql_server.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Mapping
 from jinja2 import Template
 
 from trilogy.core.enums import FunctionType, WindowType
-from trilogy.core.models import (
+from trilogy.core.statements.execute import (
     ProcessedQuery,
     ProcessedQueryPersist,
     ProcessedRawSQLStatement,