pytrilogy 0.0.3.36__tar.gz → 0.0.3.38__tar.gz

{pytrilogy-0.0.3.36/pytrilogy.egg-info → pytrilogy-0.0.3.38}/PKG-INFO

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

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/tests/test_functions.py

@@ -212,6 +212,7 @@ def test_math_functions(test_environment):
     property order_add <- revenue + 2;
     property order_id.order_nested <- revenue * 2/2;
     property order_id.rounded <- round(revenue + 2.01,2);
+    constant random <- random(1);
     select
         order_id,
         inflated_order_value,
@@ -219,7 +220,8 @@ def test_math_functions(test_environment):
         fixed_order_value,
         order_sub,
         order_add,
-        rounded
+        rounded,
+        random,
     ;"""
     env, parsed = parse(declarations, environment=test_environment)
     select: SelectStatement = parsed[-1]
@@ -227,6 +229,22 @@ def test_math_functions(test_environment):
         dialect.compile_statement(process_query(test_environment, select))
 
 
+def test_random_randomness(test_environment):
+    declarations = """
+    auto x <- unnest([1,2,3,4]);
+    select
+        x,
+        random(x) -> random_1,
+    ;"""
+    env, parsed = parse(declarations, environment=test_environment)
+    z = (
+        Dialects.DUCK_DB.default_executor(environment=test_environment)
+        .execute_query(parsed[-1])
+        .fetchall()
+    )
+    assert z[0].random_1 != z[1].random_1, f"{z[0].random_1} == {z[1].random_1}"
+
+
 def test_string_functions(test_environment):
     declarations = """
     property test_name <- concat(category_name, '_test');

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/tests/test_metadata.py

@@ -1,7 +1,4 @@
-from pathlib import Path
-
 from trilogy import parse
-from trilogy.core.models.environment import Environment
 
 
 def test_metadata():

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/tests/test_typing.py

@@ -214,3 +214,24 @@ sum(
     )
 
     assert env.environment.concepts["total"].datatype.traits == ["money"]
+
+
+def test_custom_trait_unnest_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+import std.geography;
+
+const array <- ['VT', 'MA', 'NY', 'CA']::array<string::us_state_short>;
+
+"""
+    )
+
+    _ = env.execute_query(
+        """
+SELECT
+    unnest(array)->state;
+"""
+    )
+
+    assert env.environment.concepts["state"].datatype.traits == ["us_state_short"]

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.36"
+__version__ = "0.0.3.38"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/enums.py

@@ -155,6 +155,7 @@ class FunctionType(Enum):
     ROUND = "round"
     ABS = "abs"
     SQRT = "sqrt"
+    RANDOM = "random"
 
     # Aggregates
     ## group is not a real aggregate - it just means group by this + some other set of fields

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/functions.py

@@ -191,6 +191,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     ),
     FunctionType.GROUP: FunctionConfig(
         arg_count=-1,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
     ),
     FunctionType.COUNT: FunctionConfig(
         output_purpose=Purpose.METRIC,
@@ -620,6 +621,12 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.INTEGER,
         arg_count=1,
     ),
+    FunctionType.RANDOM: FunctionConfig(
+        valid_inputs=[],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.FLOAT,
+        arg_count=1,
+    ),
     FunctionType.ROUND: FunctionConfig(
         valid_inputs=[
             {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/models/author.py

@@ -180,8 +180,14 @@ class UndefinedConcept(ConceptRef):
 
 def address_with_namespace(address: str, namespace: str) -> str:
     existing_ns = address.split(".", 1)[0]
+    if "." in address:
+        existing_name = address.split(".", 1)[1]
+    else:
+        existing_name = address
+    if existing_name == ALL_ROWS_CONCEPT:
+        return address
     if existing_ns == DEFAULT_NAMESPACE:
-        return f"{namespace}.{address.split('.',1)[1]}"
+        return f"{namespace}.{existing_name}"
     return f"{namespace}.{address}"
 
 
@@ -1129,7 +1135,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         return self.lineage.concept_arguments if self.lineage else []
 
     @classmethod
-    def calculate_derivation(self, lineage, purpose):
+    def calculate_derivation(self, lineage, purpose: Purpose) -> Derivation:
         from trilogy.core.models.build import (
             BuildAggregateWrapper,
             BuildFilterItem,

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/models/build.py

@@ -65,6 +65,7 @@ from trilogy.core.models.author import (
     RowsetLineage,
     SelectLineage,
     SubselectComparison,
+    UndefinedConcept,
     WhereClause,
     WindowItem,
 )
@@ -800,9 +801,6 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
     modifiers: List[Modifier] = Field(default_factory=list)  # type: ignore
     pseudonyms: set[str] = Field(default_factory=set)
 
-    def with_select_context(self, *args, **kwargs):
-        return self
-
     @property
     def is_aggregate(self) -> bool:
         return self.build_is_aggregate
@@ -1503,7 +1501,7 @@ class Factory:
         return base
 
     @build.register
-    def _(self, base: Function) -> BuildFunction:
+    def _(self, base: Function) -> BuildFunction | BuildAggregateWrapper:
         from trilogy.parsing.common import arbitrary_to_concept
 
         raw_args: list[Concept | FuncArgs] = []
@@ -1517,6 +1515,54 @@ class Factory:
                 raw_args.append(narg)
             else:
                 raw_args.append(arg)
+        if base.operator == FunctionType.GROUP:
+            group_base = raw_args[0]
+            final_args: List[Concept | ConceptRef] = []
+            if isinstance(group_base, ConceptRef):
+                if group_base.address in self.environment.concepts and not isinstance(
+                    self.environment.concepts[group_base.address], UndefinedConcept
+                ):
+                    group_base = self.environment.concepts[group_base.address]
+            if (
+                isinstance(group_base, Concept)
+                and isinstance(group_base.lineage, AggregateWrapper)
+                and not group_base.lineage.by
+            ):
+                arguments = raw_args[1:]
+                for x in arguments:
+                    if isinstance(x, (ConceptRef, Concept)):
+                        final_args.append(x)
+                    elif isinstance(x, (AggregateWrapper, FilterItem, WindowItem)):
+                        newx = arbitrary_to_concept(
+                            x,
+                            environment=self.environment,
+                        )
+                        final_args.append(newx)
+                    else:
+                        # constants, etc, can be ignored for group
+                        continue
+                group_base = group_base.model_copy(
+                    deep=True,
+                    update={
+                        "lineage": AggregateWrapper(
+                            function=group_base.lineage.function,
+                            by=final_args,
+                        )
+                    },
+                )
+                group_base = group_base.with_grain(
+                    Grain.from_concepts(final_args, environment=self.environment)
+                )
+                rval = self.build(group_base)
+                return BuildFunction.model_construct(
+                    operator=base.operator,
+                    arguments=[rval, *[self.build(c) for c in raw_args[1:]]],
+                    output_datatype=base.output_datatype,
+                    output_purpose=base.output_purpose,
+                    valid_inputs=base.valid_inputs,
+                    arg_count=base.arg_count,
+                )
+
         new = BuildFunction.model_construct(
             operator=base.operator,
             arguments=[self.build(c) for c in raw_args],
@@ -1568,7 +1614,10 @@ class Factory:
         new_lineage, final_grain, _ = base.get_select_grain_and_keys(
             self.grain, self.environment
         )
-        build_lineage = self.build(new_lineage)
+        if new_lineage:
+            build_lineage = self.build(new_lineage)
+        else:
+            build_lineage = None
         derivation = Concept.calculate_derivation(build_lineage, base.purpose)
         granularity = Concept.calculate_granularity(
             derivation, final_grain, build_lineage
@@ -1929,6 +1978,18 @@ class Factory:
     def _(self, base: TraitDataType):
         return base
 
+    @build.register
+    def _(self, base: ListType):
+        return base
+
+    @build.register
+    def _(self, base: StructType):
+        return base
+
+    @build.register
+    def _(self, base: MapType):
+        return base
+
     @build.register
     def _(self, base: Datasource):
         local_cache: dict[str, BuildConcept] = {}

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/concept_strategies_v3.py

@@ -110,11 +110,14 @@ def get_priority_concept(
     depth: int,
 ) -> BuildConcept:
     # optimized search for missing concepts
-    pass_one = [
-        c
-        for c in all_concepts
-        if c.address not in attempted_addresses and c.address not in found_concepts
-    ]
+    pass_one = sorted(
+        [
+            c
+            for c in all_concepts
+            if c.address not in attempted_addresses and c.address not in found_concepts
+        ],
+        key=lambda x: x.address,
+    )
     # sometimes we need to scan intermediate concepts to get merge keys or filter keys,
     # so do an exhaustive search
     # pass_two = [c for c in all_concepts+filter_only if c.address not in attempted_addresses]
@@ -388,6 +391,9 @@ def generate_node(
                     # conditions=conditions,
                 )
             else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping search, already in a recursion fot these concepts"
+                )
                 return None
         return ConstantNode(
             input_concepts=[],
@@ -453,9 +459,10 @@ def generate_node(
                 f"{depth_to_prefix(depth)}{LOGGER_PREFIX} including any filters, there are non-root concepts we should expand first: {non_root}. Recursing with all of these as mandatory"
             )
 
-            if not history.check_started(
-                root_targets, accept_partial=accept_partial, conditions=conditions
-            ):
+            # if not history.check_started(
+            #     root_targets, accept_partial=accept_partial, conditions=conditions
+            # ) or 1==1:
+            if True:
                 history.log_start(
                     root_targets, accept_partial=accept_partial, conditions=conditions
                 )
@@ -470,7 +477,10 @@ def generate_node(
                     # which we do whenever we hit a root node
                     # conditions=conditions,
                 )
-
+            else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping root search, already in a recursion for these concepts"
+                )
         check = history.gen_select_node(
             concept,
             local_optional,
@@ -546,7 +556,10 @@ def generate_node(
                         f"{depth_to_prefix(depth)}{LOGGER_PREFIX} resolved concepts through synonyms"
                     )
                     return resolved
-
+            else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping synonym search, already in a recursion for these concepts"
+                )
             return None
     else:
         raise ValueError(f"Unknown derivation {concept.derivation} on {concept}")
@@ -1041,7 +1054,6 @@ def _search_concepts(
                 environment=environment,
                 depth=depth,
             )
-            logger.info(f"gcheck result is {result}")
             if result.required:
                 logger.info(
                     f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Adding group node"
@@ -1104,7 +1116,6 @@ def source_query_concepts(
         history=history,
         conditions=conditions,
     )
-
     if not root:
         error_strings = [
             f"{c.address}<{c.purpose}>{c.derivation}>" for c in output_concepts
@@ -1130,5 +1141,4 @@ def source_query_concepts(
         )
     else:
         candidate = root
-
     return candidate

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/node_generators/filter_node.py

@@ -48,9 +48,10 @@ def gen_filter_node(
         if isinstance(x.lineage, FILTER_TYPES):
             if concept.lineage.where == where:
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent with same filter conditions "
+                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent from optional {x} with same filter conditions "
                 )
-                parent_row_concepts.append(x.lineage.content)
+                if x.lineage.content.address not in parent_row_concepts:
+                    parent_row_concepts.append(x.lineage.content)
                 optional_included.append(x)
                 continue
         if conditions and conditions == where:

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/node_generators/group_to_node.py

@@ -3,6 +3,8 @@ from typing import List
 from trilogy.constants import logger
 from trilogy.core.models.build import BuildConcept, BuildFunction, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
+
+# C:\Users\ethan\coding_projects\pytrilogy\trilogy\core\processing\node_generators\group_to_node.py
 from trilogy.core.processing.nodes import (
     GroupNode,
     History,
@@ -30,6 +32,7 @@ def gen_group_to_node(
             f"Group to should have function lineage, is {type(concept.lineage)}"
         )
     group_arg = concept.lineage.arguments[0]
+
     parent_concepts: List[BuildConcept] = concept.lineage.concept_arguments
     logger.info(
         f"{padding(depth)}{LOGGER_PREFIX} group by node has required parents {[x.address for x in parent_concepts]}"

pytrilogy-0.0.3.38/trilogy/core/processing/node_generators/union_node.py

@@ -0,0 +1,91 @@
+from typing import List
+
+from trilogy.constants import logger
+from trilogy.core.enums import FunctionType
+from trilogy.core.models.build import BuildConcept, BuildFunction, BuildWhereClause
+from trilogy.core.processing.nodes import History, StrategyNode, UnionNode
+from trilogy.core.processing.utility import padding
+
+LOGGER_PREFIX = "[GEN_UNION_NODE]"
+
+
+def is_union(c: BuildConcept):
+    return (
+        isinstance(c.lineage, BuildFunction)
+        and c.lineage.operator == FunctionType.UNION
+    )
+
+
+def build_layers(
+    concepts: list[BuildConcept],
+) -> tuple[list[list[BuildConcept]], list[BuildConcept]]:
+    sources = {
+        x.address: x.lineage.concept_arguments if x.lineage else [] for x in concepts
+    }
+    root = concepts[0]
+
+    built_layers = []
+    layers = root.lineage.concept_arguments if root.lineage else []
+    sourced = set()
+    while layers:
+        layer = []
+        current = layers.pop()
+        sourced.add(current.address)
+        layer.append(current)
+        for key, values in sources.items():
+            if key == current.address:
+                continue
+            for value in values:
+                if value.address in (current.keys or []) or current.address in (
+                    value.keys or []
+                ):
+                    layer.append(value)
+                    sourced.add(value.address)
+        built_layers.append(layer)
+    complete = [
+        x for x in concepts if all([x.address in sourced for x in sources[x.address]])
+    ]
+    return built_layers, complete
+
+
+def gen_union_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    environment,
+    g,
+    depth: int,
+    source_concepts,
+    history: History | None = None,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    all_unions = [x for x in local_optional if is_union(x)] + [concept]
+    logger.info(f"{padding(depth)}{LOGGER_PREFIX} found unions {all_unions}")
+    parent_nodes = []
+    layers, resolved = build_layers(all_unions)
+    for layer in layers:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} fetching layer {layer} with resolved {resolved}"
+        )
+        parent: StrategyNode = source_concepts(
+            mandatory_list=layer,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
+            conditions=conditions,
+        )
+        parent.hide_output_concepts(parent.output_concepts)
+        parent.add_output_concepts(resolved)
+        parent_nodes.append(parent)
+        if not parent:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} could not find union node parents"
+            )
+            return None
+
+    return UnionNode(
+        input_concepts=resolved,
+        output_concepts=resolved,
+        environment=environment,
+        parents=parent_nodes,
+    )

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/nodes/__init__.py

@@ -45,6 +45,11 @@ class History(BaseModel):
         self.history[
             self._concepts_to_lookup(search, accept_partial, conditions=conditions)
         ] = output
+        self.log_end(
+            search,
+            accept_partial=accept_partial,
+            conditions=conditions,
+        )
 
     def get_history(
         self,
@@ -83,6 +88,20 @@ class History(BaseModel):
             )
         )
 
+    def log_end(
+        self,
+        search: list[BuildConcept],
+        accept_partial: bool = False,
+        conditions: BuildWhereClause | None = None,
+    ):
+        self.started.discard(
+            self._concepts_to_lookup(
+                search,
+                accept_partial=accept_partial,
+                conditions=conditions,
+            )
+        )
+
     def check_started(
         self,
         search: list[BuildConcept],

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/nodes/merge_node.py

@@ -272,6 +272,8 @@ class MergeNode(StrategyNode):
                     f"{self.logging_prefix}{LOGGER_PREFIX} Merge node has only one parent with the same"
                     " outputs as this merge node, dropping merge node "
                 )
+                # push up any conditions we need
+                final.ordering = self.ordering
                 return final
 
         # if we have multiple candidates, see if one is good enough
@@ -293,6 +295,7 @@ class MergeNode(StrategyNode):
                     f" has all required output properties with partial {[c.address for c in dataset.partial_concepts]}"
                     f" and self has no conditions ({self.conditions})"
                 )
+                dataset.ordering = self.ordering
                 return dataset
 
         pregrain = BuildGrain()

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/processing/utility.py

@@ -603,15 +603,29 @@ def find_nullable_concepts(
 def sort_select_output_processed(
     cte: CTE | UnionCTE, query: ProcessedQuery
 ) -> CTE | UnionCTE:
-    output_addresses = [
-        c.address for c in query.output_columns if c.address not in query.hidden_columns
-    ]
+    output_addresses = [c.address for c in query.output_columns]
 
     mapping = {x.address: x for x in cte.output_columns}
 
-    new_output = []
+    new_output: list[BuildConcept] = []
     for x in output_addresses:
         new_output.append(mapping[x])
+
+    for oc in cte.output_columns:
+        # add hidden back
+        if oc.address not in output_addresses:
+            new_output.append(oc)
+
+    cte.hidden_concepts = set(
+        [
+            c.address
+            for c in cte.output_columns
+            if (
+                c.address not in query.output_columns
+                or c.address in query.hidden_columns
+            )
+        ]
+    )
     cte.output_columns = new_output
     return cte
 
@@ -619,18 +633,28 @@ def sort_select_output_processed(
 def sort_select_output(
     cte: CTE | UnionCTE, query: SelectStatement | MultiSelectStatement | ProcessedQuery
 ) -> CTE | UnionCTE:
+
     if isinstance(query, ProcessedQuery):
         return sort_select_output_processed(cte, query)
+
     output_addresses = [
         c.address
         for c in query.output_components
-        if c.address not in query.hidden_components
+        # if c.address not in query.hidden_components
     ]
 
     mapping = {x.address: x for x in cte.output_columns}
 
-    new_output = []
+    new_output: list[BuildConcept] = []
     for x in output_addresses:
         new_output.append(mapping[x])
     cte.output_columns = new_output
+    cte.hidden_concepts = set(
+        [
+            c.address
+            for c in query.output_components
+            if c.address in query.hidden_components
+        ]
+    )
+
     return cte

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/query_processor.py

@@ -431,7 +431,9 @@ def get_query_datasources(
     hooks: Optional[List[BaseHook]] = None,
 ) -> QueryDatasource:
     ds = get_query_node(environment, statement.as_lineage(environment))
+
     final_qds = ds.resolve()
+
     if hooks:
         for hook in hooks:
             hook.process_root_strategy_node(ds)
@@ -510,6 +512,7 @@ def process_query(
         hook.process_root_datasource(root_datasource)
     # this should always return 1 - TODO, refactor
     root_cte = datasource_to_cte(root_datasource, environment.cte_name_map)
+
     for hook in hooks:
         hook.process_root_cte(root_cte)
     raw_ctes: List[CTE | UnionCTE] = list(reversed(flatten_ctes(root_cte)))

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/core/statements/author.py

@@ -135,6 +135,7 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
         )
 
         output.grain = output.calculate_grain(environment)
+
         for x in selection:
             if x.is_undefined and environment.concepts.fail_on_missing:
                 environment.concepts.raise_undefined(
@@ -166,6 +167,7 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
         targets = []
         for x in self.selection:
             targets.append(x.concept)
+
         result = Grain.from_concepts(
             targets, where_clause=self.where_clause, environment=environment
         )

{pytrilogy-0.0.3.36 → pytrilogy-0.0.3.38}/trilogy/dialect/base.py

@@ -132,6 +132,11 @@ DATATYPE_MAP: dict[DataType, str] = {
     DataType.MAP: "map",
     DataType.DATE: "date",
     DataType.DATETIME: "datetime",
+    DataType.LIST: "list",
+}
+
+COMPLEX_DATATYPE_MAP = {
+    DataType.LIST: lambda x: f"{x}[]",
 }
 
 
@@ -166,12 +171,14 @@ FUNCTION_MAP = {
     FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
     # math
     FunctionType.ADD: lambda x: " + ".join(x),
+    FunctionType.ABS: lambda x: f"abs({x[0]})",
     FunctionType.SUBTRACT: lambda x: " - ".join(x),
     FunctionType.DIVIDE: lambda x: " / ".join(x),
     FunctionType.MULTIPLY: lambda x: " * ".join(x),
     FunctionType.ROUND: lambda x: f"round({x[0]},{x[1]})",
     FunctionType.MOD: lambda x: f"({x[0]} % {x[1]})",
     FunctionType.SQRT: lambda x: f"sqrt({x[0]})",
+    FunctionType.RANDOM: lambda x: "random()",
     # aggregate types
     FunctionType.COUNT_DISTINCT: lambda x: f"count(distinct {x[0]})",
     FunctionType.COUNT: lambda x: f"count({x[0]})",
@@ -283,6 +290,7 @@ class BaseDialect:
     QUOTE_CHARACTER = "`"
     SQL_TEMPLATE = GENERIC_SQL_TEMPLATE
     DATATYPE_MAP = DATATYPE_MAP
+    COMPLEX_DATATYPE_MAP = COMPLEX_DATATYPE_MAP
     UNNEST_MODE = UnnestMode.CROSS_APPLY
 
     def __init__(self, rendering: Rendering | None = None):
@@ -682,6 +690,8 @@ class BaseDialect:
             return self.FUNCTION_MAP[FunctionType.DATETIME_LITERAL](e)
         elif isinstance(e, TraitDataType):
             return self.render_expr(e.type, cte=cte, cte_map=cte_map)
+        elif isinstance(e, ListType):
+            return f"{self.COMPLEX_DATATYPE_MAP[DataType.LIST](self.render_expr(e.value_data_type, cte=cte, cte_map=cte_map))}"
         else:
             raise ValueError(f"Unable to render type {type(e)} {e}")