pytrilogy 0.0.2.49__py3-none-any.whl → 0.0.2.51__py3-none-any.whl

trilogy/core/processing/nodes/select_node_v2.py

@@ -34,7 +34,6 @@ class SelectNode(StrategyNode):
         input_concepts: List[Concept],
         output_concepts: List[Concept],
         environment: Environment,
-        g,
         datasource: Datasource | None = None,
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
@@ -52,7 +51,6 @@ class SelectNode(StrategyNode):
             input_concepts=input_concepts,
             output_concepts=output_concepts,
             environment=environment,
-            g=g,
             whole_grain=whole_grain,
             parents=parents,
             depth=depth,
@@ -197,7 +195,6 @@ class SelectNode(StrategyNode):
             input_concepts=list(self.input_concepts),
             output_concepts=list(self.output_concepts),
             environment=self.environment,
-            g=self.g,
             datasource=self.datasource,
             depth=self.depth,
             parents=self.parents,
@@ -221,7 +218,6 @@ class ConstantNode(SelectNode):
             input_concepts=list(self.input_concepts),
             output_concepts=list(self.output_concepts),
             environment=self.environment,
-            g=self.g,
             datasource=self.datasource,
             depth=self.depth,
             partial_concepts=list(self.partial_concepts),

trilogy/core/processing/nodes/union_node.py

@@ -18,7 +18,6 @@ class UnionNode(StrategyNode):
         input_concepts: List[Concept],
         output_concepts: List[Concept],
         environment,
-        g,
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
@@ -27,7 +26,6 @@ class UnionNode(StrategyNode):
             input_concepts=input_concepts,
             output_concepts=output_concepts,
             environment=environment,
-            g=g,
             whole_grain=whole_grain,
             parents=parents,
             depth=depth,
@@ -43,7 +41,6 @@ class UnionNode(StrategyNode):
             input_concepts=list(self.input_concepts),
             output_concepts=list(self.output_concepts),
             environment=self.environment,
-            g=self.g,
             whole_grain=self.whole_grain,
             parents=self.parents,
             depth=self.depth,

trilogy/core/processing/nodes/unnest_node.py

@@ -23,7 +23,6 @@ class UnnestNode(StrategyNode):
         input_concepts: List[Concept],
         output_concepts: List[Concept],
         environment,
-        g,
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
@@ -32,7 +31,6 @@ class UnnestNode(StrategyNode):
             input_concepts=input_concepts,
             output_concepts=output_concepts,
             environment=environment,
-            g=g,
             whole_grain=whole_grain,
             parents=parents,
             depth=depth,
@@ -62,7 +60,6 @@ class UnnestNode(StrategyNode):
             input_concepts=list(self.input_concepts),
             output_concepts=list(self.output_concepts),
             environment=self.environment,
-            g=self.g,
             whole_grain=self.whole_grain,
             parents=self.parents,
             depth=self.depth,

trilogy/core/processing/nodes/window_node.py

@@ -12,7 +12,6 @@ class WindowNode(StrategyNode):
         input_concepts: List[Concept],
         output_concepts: List[Concept],
         environment,
-        g,
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
@@ -21,7 +20,6 @@ class WindowNode(StrategyNode):
             input_concepts=input_concepts,
             output_concepts=output_concepts,
             environment=environment,
-            g=g,
             whole_grain=whole_grain,
             parents=parents,
             depth=depth,
@@ -36,7 +34,6 @@ class WindowNode(StrategyNode):
             input_concepts=list(self.input_concepts),
             output_concepts=list(self.output_concepts),
             environment=self.environment,
-            g=self.g,
             whole_grain=self.whole_grain,
             parents=self.parents,
             depth=self.depth,

trilogy/core/processing/utility.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import date, datetime
 from enum import Enum
 from logging import Logger
 from typing import Any, Dict, List, Set, Tuple
@@ -380,6 +381,8 @@ def is_scalar_condition(
         int
         | str
         | float
+        | date
+        | datetime
         | list[Any]
         | WindowItem
         | FilterItem

trilogy/core/query_processor.py

@@ -391,7 +391,6 @@ def get_query_node(
             input_concepts=ds.output_concepts,
             parents=[ds],
             environment=ds.environment,
-            g=ds.g,
             partial_concepts=ds.partial_concepts,
             conditions=final,
         )

trilogy/dialect/base.py

@@ -1,3 +1,4 @@
+from datetime import date, datetime
 from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
 from jinja2 import Template
@@ -102,13 +103,15 @@ WINDOW_FUNCTION_MAP = {
     WindowType.AVG: window_factory("avg", include_concept=True),
 }
 
-DATATYPE_MAP = {
+DATATYPE_MAP: dict[DataType, str] = {
     DataType.STRING: "string",
     DataType.INTEGER: "int",
     DataType.FLOAT: "float",
     DataType.BOOL: "bool",
     DataType.NUMERIC: "numeric",
     DataType.MAP: "map",
+    DataType.DATE: "date",
+    DataType.DATETIME: "datetime",
 }
 
 
@@ -131,6 +134,7 @@ FUNCTION_MAP = {
     FunctionType.SPLIT: lambda x: f"split({x[0]}, {x[1]})",
     FunctionType.IS_NULL: lambda x: f"isnull({x[0]})",
     FunctionType.BOOL: lambda x: f"CASE WHEN {x[0]} THEN TRUE ELSE FALSE END",
+    FunctionType.PARENTHETICAL: lambda x: f"({x[0]})",
     # Complex
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}][1]",
@@ -138,6 +142,8 @@ FUNCTION_MAP = {
     FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
     FunctionType.STRUCT: lambda x: f"{{{', '.join(struct_arg(x))}}}",
     FunctionType.ARRAY: lambda x: f"[{', '.join(x)}]",
+    FunctionType.DATE_LITERAL: lambda x: f"date '{x}'",
+    FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
     # math
     FunctionType.ADD: lambda x: " + ".join(x),
     FunctionType.SUBTRACT: lambda x: " - ".join(x),
@@ -454,6 +460,8 @@ class BaseDialect:
             list,
             bool,
             float,
+            date,
+            datetime,
             DataType,
             Function,
             Parenthetical,
@@ -612,7 +620,7 @@ class BaseDialect:
         elif isinstance(e, list):
             return f"{self.FUNCTION_MAP[FunctionType.ARRAY]([self.render_expr(x, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) for x in e])}"
         elif isinstance(e, DataType):
-            return str(e.value)
+            return self.DATATYPE_MAP.get(e, e.value)
         elif isinstance(e, DatePart):
             return str(e.value)
         elif isinstance(e, NumericType):
@@ -620,6 +628,10 @@ class BaseDialect:
         elif isinstance(e, MagicConstants):
             if e == MagicConstants.NULL:
                 return "null"
+        elif isinstance(e, date):
+            return self.FUNCTION_MAP[FunctionType.DATE_LITERAL](e)
+        elif isinstance(e, datetime):
+            return self.FUNCTION_MAP[FunctionType.DATETIME_LITERAL](e)
         else:
             raise ValueError(f"Unable to render type {type(e)} {e}")
 

trilogy/dialect/duckdb.py

@@ -3,6 +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.dialect.base import BaseDialect
 
 WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
@@ -30,6 +31,8 @@ FUNCTION_MAP = {
     FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
     FunctionType.DATE_DIFF: lambda x: f"date_diff('{x[2]}', {x[0]}, {x[1]})",
     FunctionType.CONCAT: lambda x: f"({' || '.join(x)})",
+    FunctionType.DATE_LITERAL: lambda x: f"date '{x}'",
+    FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
 }
 
 # if an aggregate function is called on a source that is at the same grain as the aggregate
@@ -44,6 +47,9 @@ FUNCTION_GRAIN_MATCH_MAP = {
     FunctionType.MIN: lambda args: f"{args[0]}",
 }
 
+DATATYPE_MAP: dict[DataType, str] = {}
+
+
 DUCKDB_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
@@ -84,6 +90,7 @@ class DuckDBDialect(BaseDialect):
         **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
         **FUNCTION_GRAIN_MATCH_MAP,
     }
+    DATATYPE_MAP = {**BaseDialect.DATATYPE_MAP, **DATATYPE_MAP}
     QUOTE_CHARACTER = '"'
     SQL_TEMPLATE = DUCKDB_TEMPLATE
     UNNEST_MODE = UnnestMode.DIRECT

trilogy/hooks/graph_hook.py

@@ -1,7 +1,19 @@
+import sys
+from os import environ
+
 import networkx as nx
 
 from trilogy.hooks.base_hook import BaseHook
 
+if not environ.get("TCL_LIBRARY"):
+    minor = sys.version_info.minor
+    if minor == 13:
+        environ["TCL_LIBRARY"] = r"C:\Program Files\Python313\tcl\tcl8.6"
+    elif minor == 12:
+        environ["TCL_LIBRARY"] = r"C:\Program Files\Python312\tcl\tcl8.6"
+    else:
+        pass
+
 
 class GraphHook(BaseHook):
     def __init__(self):
@@ -11,11 +23,14 @@ class GraphHook(BaseHook):
         except ImportError:
             raise ImportError("GraphHook requires matplotlib and scipy to be installed")
 
+        # https://github.com/python/cpython/issues/125235#issuecomment-2412948604
+
     def query_graph_built(
         self,
         graph: nx.DiGraph,
         target: str | None = None,
         highlight_nodes: list[str] | None = None,
+        remove_isolates: bool = True,
     ):
         from matplotlib import pyplot as plt
 
@@ -24,7 +39,8 @@ class GraphHook(BaseHook):
         for node in nodes:
             if "__preql_internal" in node:
                 graph.remove_node(node)
-        graph.remove_nodes_from(list(nx.isolates(graph)))
+        if remove_isolates:
+            graph.remove_nodes_from(list(nx.isolates(graph)))
         color_map = []
         highlight_nodes = highlight_nodes or []
         for node in graph:

trilogy/parsing/common.py

@@ -1,9 +1,16 @@
+from datetime import date, datetime
 from typing import List, Tuple
 
 from trilogy.constants import (
     VIRTUAL_CONCEPT_PREFIX,
 )
-from trilogy.core.enums import FunctionType, Modifier, PurposeLineage, WindowType
+from trilogy.core.enums import (
+    FunctionType,
+    Granularity,
+    Modifier,
+    PurposeLineage,
+    WindowType,
+)
 from trilogy.core.functions import arg_to_datatype, function_args_to_output_purpose
 from trilogy.core.models import (
     AggregateWrapper,
@@ -37,14 +44,22 @@ def process_function_args(
     args,
     meta: Meta | None,
     environment: Environment,
-):
-    final: List[Concept | Function] = []
+) -> List[Concept | Function | str | int | float | date | datetime]:
+    final: List[Concept | Function | str | int | float | date | datetime] = []
     for arg in args:
         # if a function has an anonymous function argument
         # create an implicit concept
-        while isinstance(arg, Parenthetical):
-            arg = arg.content
-        if isinstance(arg, Function):
+        if isinstance(arg, Parenthetical):
+            processed = process_function_args([arg.content], meta, environment)
+            final.append(
+                Function(
+                    operator=FunctionType.PARENTHETICAL,
+                    arguments=processed,
+                    output_datatype=arg_to_datatype(processed[0]),
+                    output_purpose=function_args_to_output_purpose(processed),
+                )
+            )
+        elif isinstance(arg, Function):
             # if it's not an aggregate function, we can skip the virtual concepts
             # to simplify anonymous function handling
             if (
@@ -57,7 +72,7 @@ def process_function_args(
             concept = function_to_concept(
                 arg,
                 name=f"{VIRTUAL_CONCEPT_PREFIX}_{arg.operator.value}_{id_hash}",
-                namespace=environment.namespace,
+                environment=environment,
             )
             # to satisfy mypy, concept will always have metadata
             if concept.metadata and meta:
@@ -71,7 +86,7 @@ def process_function_args(
             concept = arbitrary_to_concept(
                 arg,
                 name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                namespace=environment.namespace,
+                environment=environment,
             )
             if concept.metadata and meta:
                 concept.metadata.line_number = meta.line
@@ -130,10 +145,39 @@ def constant_to_concept(
     )
 
 
+def concepts_to_grain_concepts(
+    concepts: List[Concept] | List[str] | set[str], environment: Environment | None
+) -> list[Concept]:
+    environment = Environment() if environment is None else environment
+    pconcepts: list[Concept] = [
+        c if isinstance(c, Concept) else environment.concepts[c] for c in concepts
+    ]
+
+    final: List[Concept] = []
+    for sub in pconcepts:
+        if sub.purpose in (Purpose.PROPERTY, Purpose.METRIC) and sub.keys:
+            if any([c.address in pconcepts for c in sub.keys]):
+                continue
+        if sub.purpose in (Purpose.METRIC,):
+            if all([c in pconcepts for c in sub.grain.components]):
+                continue
+        if sub.granularity == Granularity.SINGLE_ROW:
+            continue
+        final.append(sub)
+    final = unique(final, "address")
+    v2 = sorted(final, key=lambda x: x.name)
+    return v2
+
+
 def function_to_concept(
-    parent: Function, name: str, namespace: str, metadata: Metadata | None = None
+    parent: Function,
+    name: str,
+    environment: Environment,
+    namespace: str | None = None,
+    metadata: Metadata | None = None,
 ) -> Concept:
     pkeys: List[Concept] = []
+    namespace = namespace or environment.namespace
     for x in parent.arguments:
         pkeys += [
             x
@@ -153,7 +197,7 @@ def function_to_concept(
             key_grain += [*x.keys]
         else:
             key_grain.append(x)
-    keys = tuple(Grain(components=key_grain).components_copy)
+    keys = tuple(concepts_to_grain_concepts(key_grain, environment))
     if not pkeys:
         purpose = Purpose.CONSTANT
     else:
@@ -247,7 +291,7 @@ def window_item_to_concept(
         lineage=parent,
         metadata=fmetadata,
         # filters are implicitly at the grain of the base item
-        grain=Grain(components=grain),
+        grain=Grain.from_concepts(grain),
         namespace=namespace,
         keys=keys,
         modifiers=modifiers,
@@ -259,9 +303,8 @@ def agg_wrapper_to_concept(
     namespace: str,
     name: str,
     metadata: Metadata | None = None,
-    purpose: Purpose | None = None,
 ) -> Concept:
-    local_purpose, keys = get_purpose_and_keys(
+    _, keys = get_purpose_and_keys(
         Purpose.METRIC, tuple(parent.by) if parent.by else None
     )
     # anything grouped to a grain should be a property
@@ -275,7 +318,7 @@ def agg_wrapper_to_concept(
         purpose=Purpose.METRIC,
         metadata=fmetadata,
         lineage=parent,
-        grain=Grain(components=parent.by) if parent.by else Grain(),
+        grain=Grain.from_concepts(parent.by) if parent.by else Grain(),
         namespace=namespace,
         keys=tuple(parent.by) if parent.by else keys,
         modifiers=modifiers,
@@ -295,15 +338,17 @@ def arbitrary_to_concept(
         | float
         | str
     ),
-    namespace: str,
+    environment: Environment,
+    namespace: str | None = None,
     name: str | None = None,
     metadata: Metadata | None = None,
     purpose: Purpose | None = None,
 ) -> Concept:
+    namespace = namespace or environment.namespace
     if isinstance(parent, AggregateWrapper):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_agg_{parent.function.operator.value}_{string_to_hash(str(parent))}"
-        return agg_wrapper_to_concept(parent, namespace, name, metadata, purpose)
+        return agg_wrapper_to_concept(parent, namespace, name, metadata)
     elif isinstance(parent, WindowItem):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_window_{parent.type.value}_{string_to_hash(str(parent))}"
@@ -315,7 +360,13 @@ def arbitrary_to_concept(
     elif isinstance(parent, Function):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
-        return function_to_concept(parent, name, namespace, metadata=metadata)
+        return function_to_concept(
+            parent,
+            name,
+            metadata=metadata,
+            environment=environment,
+            namespace=namespace,
+        )
     elif isinstance(parent, ListWrapper):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"

trilogy/parsing/parse_engine.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import date, datetime
 from os.path import dirname, join
 from pathlib import Path
 from re import IGNORECASE
@@ -462,7 +463,7 @@ class ParseToObjects(Transformer):
             datatype=args[2],
             purpose=args[0],
             metadata=metadata,
-            grain=Grain(components=parents),
+            grain=Grain(components={x.address for x in parents}),
             namespace=namespace,
             keys=parents,
             modifiers=modifiers,
@@ -529,6 +530,7 @@ class ParseToObjects(Transformer):
                 source_value,
                 name=name,
                 namespace=namespace,
+                environment=self.environment,
                 purpose=purpose,
                 metadata=metadata,
             )
@@ -597,7 +599,7 @@ class ParseToObjects(Transformer):
                 output_purpose=Purpose.CONSTANT,
                 arguments=[constant],
             ),
-            grain=Grain(components=[]),
+            grain=Grain(components=set()),
             namespace=namespace,
         )
         if concept.metadata:
@@ -622,7 +624,9 @@ class ParseToObjects(Transformer):
         return args
 
     def grain_clause(self, args) -> Grain:
-        return Grain(components=[self.environment.concepts[a] for a in args[0]])
+        return Grain(
+            components=set([self.environment.concepts[a].address for a in args[0]])
+        )
 
     def whole_grain_clause(self, args) -> WholeGrainWrapper:
         return WholeGrainWrapper(where=args[0])
@@ -669,6 +673,12 @@ class ParseToObjects(Transformer):
         )
         for column in columns:
             column.concept = column.concept.with_grain(datasource.grain)
+        if datasource.where:
+            for x in datasource.where.concept_arguments:
+                if x.address not in datasource.output_concepts:
+                    raise ValueError(
+                        f"Datasource {name} where condition depends on concept {x.address} that does not exist on the datasource, line {meta.line}."
+                    )
         self.environment.add_datasource(datasource, meta=meta)
         return datasource
 
@@ -708,7 +718,11 @@ class ParseToObjects(Transformer):
             )
         elif isinstance(transformation, Function):
             concept = function_to_concept(
-                transformation, namespace=namespace, name=output, metadata=metadata
+                transformation,
+                namespace=namespace,
+                name=output,
+                metadata=metadata,
+                environment=self.environment,
             )
         else:
             raise SyntaxError("Invalid transformation")
@@ -764,10 +778,8 @@ class ParseToObjects(Transformer):
         def handle_order_item(x, namespace: str):
             if not isinstance(x, Concept):
                 x = arbitrary_to_concept(
-                    x,
-                    namespace=namespace,
+                    x, namespace=namespace, environment=self.environment
                 )
-                self.environment.add_concept(x)
             return x
 
         return [
@@ -1022,12 +1034,32 @@ class ParseToObjects(Transformer):
             order_by=order_by,
             meta=Metadata(line_number=meta.line),
         )
-        for parse_pass in [1, 2]:
+        for parse_pass in [
+            1,
+            2,
+        ]:
             # the first pass will result in all concepts being defined
             # the second will get grains appropriately
             # eg if someone does sum(x)->a, b+c -> z - we don't know if Z is a key to group by or an aggregate
             # until after the first pass, and so don't know the grain of a
-            nselect = []
+
+            if parse_pass == 1:
+                grain = Grain.from_concepts(
+                    [
+                        x.content
+                        for x in output.selection
+                        if isinstance(x.content, Concept)
+                    ],
+                    where_clause=output.where_clause,
+                )
+            if parse_pass == 2:
+                grain = Grain.from_concepts(
+                    output.output_components, where_clause=output.where_clause
+                )
+            print(
+                f"end pass {parse_pass} grain {grain} from {output.output_components}"
+            )
+            output.grain = grain
             for item in select_items:
                 # we don't know the grain of an aggregate at assignment time
                 # so rebuild at this point in the tree
@@ -1057,7 +1089,7 @@ class ParseToObjects(Transformer):
                         environment=self.environment,
                     )
                     output.local_concepts[item.content.address] = item.content
-                nselect.append(item)
+
         if order_by:
             output.order_by = order_by.with_select_context(
                 local_concepts=output.local_concepts,
@@ -1174,7 +1206,7 @@ class ParseToObjects(Transformer):
         if isinstance(args[0], AggregateWrapper):
             left = arbitrary_to_concept(
                 args[0],
-                namespace=self.environment.namespace,
+                environment=self.environment,
             )
             self.environment.add_concept(left)
         else:
@@ -1182,7 +1214,7 @@ class ParseToObjects(Transformer):
         if isinstance(args[2], AggregateWrapper):
             right = arbitrary_to_concept(
                 args[2],
-                namespace=self.environment.namespace,
+                environment=self.environment,
             )
             self.environment.add_concept(right)
         else:
@@ -1220,10 +1252,7 @@ class ParseToObjects(Transformer):
         ):
             right = right.content
         if isinstance(right, (Function, FilterItem, WindowItem, AggregateWrapper)):
-            right = arbitrary_to_concept(
-                right,
-                namespace=self.environment.namespace,
-            )
+            right = arbitrary_to_concept(right, environment=self.environment)
             self.environment.add_concept(right, meta=meta)
         return SubselectComparison(
             left=args[0],
@@ -1292,10 +1321,7 @@ class ParseToObjects(Transformer):
             elif isinstance(item, WindowType):
                 type = item
             else:
-                concept = arbitrary_to_concept(
-                    item,
-                    namespace=self.environment.namespace,
-                )
+                concept = arbitrary_to_concept(item, environment=self.environment)
                 self.environment.add_concept(concept, meta=meta)
         assert concept
         return WindowItem(
@@ -1783,6 +1809,30 @@ class ParseToObjects(Transformer):
     @v_args(meta=True)
     def fcast(self, meta, args) -> Function:
         args = process_function_args(args, meta=meta, environment=self.environment)
+        if isinstance(args[0], str):
+            processed: date | datetime | int | float | bool | str
+            if args[1] == DataType.DATE:
+                processed = date.fromisoformat(args[0])
+            elif args[1] == DataType.DATETIME:
+                processed = datetime.fromisoformat(args[0])
+            elif args[1] == DataType.TIMESTAMP:
+                processed = datetime.fromisoformat(args[0])
+            elif args[1] == DataType.INTEGER:
+                processed = int(args[0])
+            elif args[1] == DataType.FLOAT:
+                processed = float(args[0])
+            elif args[1] == DataType.BOOL:
+                processed = args[0].capitalize() == "True"
+            elif args[1] == DataType.STRING:
+                processed = args[0]
+            else:
+                raise SyntaxError(f"Invalid cast type {args[1]}")
+            return Function(
+                operator=FunctionType.CONSTANT,
+                output_datatype=args[1],
+                output_purpose=Purpose.CONSTANT,
+                arguments=[processed],
+            )
         output_datatype = args[1]
         return Function(
             operator=FunctionType.CAST,

trilogy/parsing/render.py

@@ -158,7 +158,14 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Grain"):
-        components = ",".join(self.to_string(x) for x in arg.components)
+        final = []
+        for comp in arg.components:
+            if comp.startswith(DEFAULT_NAMESPACE):
+                final.append(comp.split(".", 1)[1])
+            else:
+                final.append(comp)
+        final = sorted(final)
+        components = ",".join(x for x in final)
         return f"grain ({components})"
 
     @to_string.register

trilogy/parsing/trilogy.lark

@@ -193,7 +193,9 @@
     _math_functions: fmul | fdiv | fadd | fsub | fround | fmod | fabs
     
     //generic
-    fcast: "cast"i "(" expr "as"i data_type ")"
+    _fcast_primary: "cast"i "(" expr "as"i data_type ")"
+    _fcast_alt: expr "::" data_type
+    fcast: _fcast_primary | _fcast_alt
     concat: ("concat"i "(" (expr ",")* expr ")") | (expr "||" expr)
     fcoalesce: "coalesce"i "(" (expr ",")* expr ")"
     fcase_when: "WHEN"i conditional "THEN"i expr