pytrilogy 0.0.3.54__py3-none-any.whl → 0.0.3.56__py3-none-any.whl

trilogy/core/processing/discovery_validation.py

@@ -0,0 +1,155 @@
+from collections import defaultdict
+from enum import Enum
+from typing import List
+
+from trilogy.core.models.build import (
+    BuildConcept,
+    BuildWhereClause,
+)
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.processing.nodes import (
+    StrategyNode,
+)
+from trilogy.core.processing.utility import (
+    get_disconnected_components,
+)
+
+
+class ValidationResult(Enum):
+    COMPLETE = 1
+    DISCONNECTED = 2
+    INCOMPLETE = 3
+    INCOMPLETE_CONDITION = 4
+
+
+def validate_concept(
+    concept: BuildConcept,
+    node: StrategyNode,
+    found_addresses: set[str],
+    non_partial_addresses: set[str],
+    partial_addresses: set[str],
+    virtual_addresses: set[str],
+    found_map: dict[str, set[BuildConcept]],
+    accept_partial: bool,
+    seen: set[str],
+    environment: BuildEnvironment,
+):
+    found_map[str(node)].add(concept)
+    seen.add(concept.address)
+    if concept not in node.partial_concepts:
+        found_addresses.add(concept.address)
+        non_partial_addresses.add(concept.address)
+        # remove it from our partial tracking
+        if concept.address in partial_addresses:
+            partial_addresses.remove(concept.address)
+        if concept.address in virtual_addresses:
+            virtual_addresses.remove(concept.address)
+    if concept in node.partial_concepts:
+        if concept.address in non_partial_addresses:
+            return None
+        partial_addresses.add(concept.address)
+        if accept_partial:
+            found_addresses.add(concept.address)
+            found_map[str(node)].add(concept)
+    for v_address in concept.pseudonyms:
+        if v_address in seen:
+            return
+        v = environment.concepts[v_address]
+        if v.address in seen:
+            return
+        if v.address == concept.address:
+            return
+        validate_concept(
+            v,
+            node,
+            found_addresses,
+            non_partial_addresses,
+            partial_addresses,
+            virtual_addresses,
+            found_map,
+            accept_partial,
+            seen=seen,
+            environment=environment,
+        )
+
+
+def validate_stack(
+    environment: BuildEnvironment,
+    stack: List[StrategyNode],
+    concepts: List[BuildConcept],
+    mandatory_with_filter: List[BuildConcept],
+    conditions: BuildWhereClause | None = None,
+    accept_partial: bool = False,
+) -> tuple[ValidationResult, set[str], set[str], set[str], set[str]]:
+    found_map: dict[str, set[BuildConcept]] = defaultdict(set)
+    found_addresses: set[str] = set()
+    non_partial_addresses: set[str] = set()
+    partial_addresses: set[str] = set()
+    virtual_addresses: set[str] = set()
+    seen: set[str] = set()
+
+    for node in stack:
+        resolved = node.resolve()
+
+        for concept in resolved.output_concepts:
+            if concept.address in resolved.hidden_concepts:
+                continue
+
+            validate_concept(
+                concept,
+                node,
+                found_addresses,
+                non_partial_addresses,
+                partial_addresses,
+                virtual_addresses,
+                found_map,
+                accept_partial,
+                seen,
+                environment,
+            )
+        for concept in node.virtual_output_concepts:
+            if concept.address in non_partial_addresses:
+                continue
+            found_addresses.add(concept.address)
+            virtual_addresses.add(concept.address)
+    if not conditions:
+        conditions_met = True
+    else:
+        conditions_met = all(
+            [node.preexisting_conditions == conditions.conditional for node in stack]
+        ) or all([c.address in found_addresses for c in mandatory_with_filter])
+    # zip in those we know we found
+    if not all([c.address in found_addresses for c in concepts]) or not conditions_met:
+        if not all([c.address in found_addresses for c in concepts]):
+            return (
+                ValidationResult.INCOMPLETE,
+                found_addresses,
+                {c.address for c in concepts if c.address not in found_addresses},
+                partial_addresses,
+                virtual_addresses,
+            )
+        return (
+            ValidationResult.INCOMPLETE_CONDITION,
+            found_addresses,
+            {c.address for c in concepts if c.address not in mandatory_with_filter},
+            partial_addresses,
+            virtual_addresses,
+        )
+
+    graph_count, _ = get_disconnected_components(found_map)
+    if graph_count in (0, 1):
+        return (
+            ValidationResult.COMPLETE,
+            found_addresses,
+            set(),
+            partial_addresses,
+            virtual_addresses,
+        )
+    # if we have too many subgraphs, we need to keep searching
+    return (
+        ValidationResult.DISCONNECTED,
+        found_addresses,
+        set(),
+        partial_addresses,
+        virtual_addresses,
+    )

trilogy/core/processing/node_generators/__init__.py

@@ -4,6 +4,7 @@ from .group_node import gen_group_node
 from .group_to_node import gen_group_to_node
 from .multiselect_node import gen_multiselect_node
 from .node_merge_node import gen_merge_node
+from .recursive_node import gen_recursive_node
 from .rowset_node import gen_rowset_node
 from .select_node import gen_select_node
 from .synonym_node import gen_synonym_node
@@ -24,4 +25,5 @@ __all__ = [
     "gen_rowset_node",
     "gen_multiselect_node",
     "gen_synonym_node",
+    "gen_recursive_node",
 ]

trilogy/core/processing/node_generators/recursive_node.py

@@ -0,0 +1,87 @@
+from typing import List
+
+from trilogy.constants import DEFAULT_NAMESPACE, RECURSIVE_GATING_CONCEPT, logger
+from trilogy.core.models.build import (
+    BuildComparison,
+    BuildConcept,
+    BuildFunction,
+    BuildGrain,
+    BuildWhereClause,
+    ComparisonOperator,
+    DataType,
+    Derivation,
+    Purpose,
+)
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.processing.nodes import History, RecursiveNode, StrategyNode
+from trilogy.core.processing.utility import padding
+
+LOGGER_PREFIX = "[GEN_RECURSIVE_NODE]"
+
+GATING_CONCEPT = BuildConcept(
+    name=RECURSIVE_GATING_CONCEPT,
+    namespace=DEFAULT_NAMESPACE,
+    grain=BuildGrain(),
+    build_is_aggregate=False,
+    datatype=DataType.BOOL,
+    purpose=Purpose.KEY,
+    derivation=Derivation.BASIC,
+)
+
+
+def gen_recursive_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    history: History,
+    environment: BuildEnvironment,
+    g,
+    depth: int,
+    source_concepts,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    arguments = []
+    if isinstance(concept.lineage, BuildFunction):
+        arguments = concept.lineage.concept_arguments
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} Fetching recursive node for {concept.name} with arguments {arguments} and conditions {conditions}"
+    )
+    parent = source_concepts(
+        mandatory_list=arguments,
+        environment=environment,
+        g=g,
+        depth=depth + 1,
+        history=history,
+        # conditions=conditions,
+    )
+    if not parent:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} could not find recursive node parents"
+        )
+        return None
+    outputs = (
+        [concept]
+        + arguments
+        + [
+            GATING_CONCEPT,
+        ]
+    )
+    base = RecursiveNode(
+        input_concepts=arguments,
+        output_concepts=outputs,
+        environment=environment,
+        parents=([parent] if (arguments or local_optional) else []),
+        # preexisting_conditions=conditions
+    )
+    # TODO:
+    # recursion will result in a union; group up to our final targets
+    wrapped_base = StrategyNode(
+        input_concepts=outputs,
+        output_concepts=outputs,
+        environment=environment,
+        parents=[base],
+        depth=depth,
+        conditions=BuildComparison(
+            left=GATING_CONCEPT, right=True, operator=ComparisonOperator.IS
+        ),
+    )
+    return wrapped_base

trilogy/core/processing/node_generators/select_node.py

@@ -19,8 +19,7 @@ LOGGER_PREFIX = "[GEN_SELECT_NODE]"
 
 
 def gen_select_node(
-    concept: BuildConcept,
-    local_optional: list[BuildConcept],
+    concepts: list[BuildConcept],
     environment: BuildEnvironment,
     g,
     depth: int,
@@ -28,12 +27,11 @@ def gen_select_node(
     fail_if_not_found: bool = True,
     conditions: BuildWhereClause | None = None,
 ) -> StrategyNode | None:
-    all_concepts = [concept] + local_optional
-    all_lcl = LooseBuildConceptList(concepts=all_concepts)
+    all_lcl = LooseBuildConceptList(concepts=concepts)
     materialized_lcl = LooseBuildConceptList(
         concepts=[
             x
-            for x in all_concepts
+            for x in concepts
             if x.address in environment.materialized_concepts
             or x.derivation == Derivation.CONSTANT
         ]
@@ -41,15 +39,15 @@ def gen_select_node(
     if materialized_lcl != all_lcl:
         missing = all_lcl.difference(materialized_lcl)
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} Skipping select node generation for {concept.address}"
+            f"{padding(depth)}{LOGGER_PREFIX} Skipping select node generation for {concepts}"
             f" as it + optional includes non-materialized concepts (looking for all {all_lcl}, missing {missing}) "
         )
         if fail_if_not_found:
-            raise NoDatasourceException(f"No datasource exists for {concept}")
+            raise NoDatasourceException(f"No datasource exists for {concepts}")
         return None
 
     return gen_select_merge_node(
-        [concept] + local_optional,
+        concepts,
         g=g,
         environment=environment,
         depth=depth,

trilogy/core/processing/nodes/__init__.py

@@ -10,6 +10,7 @@ from .base_node import NodeJoin, StrategyNode, WhereSafetyNode
 from .filter_node import FilterNode
 from .group_node import GroupNode
 from .merge_node import MergeNode
+from .recursive_node import RecursiveNode
 from .select_node_v2 import ConstantNode, SelectNode
 from .union_node import UnionNode
 from .unnest_node import UnnestNode
@@ -149,7 +150,6 @@ class History(BaseModel):
         environment: BuildEnvironment,
         g,
         depth: int,
-        source_concepts,
         fail_if_not_found: bool = False,
         accept_partial: bool = False,
         accept_partial_optional: bool = False,
@@ -168,8 +168,7 @@ class History(BaseModel):
         if fingerprint in self.select_history:
             return self.select_history[fingerprint]
         gen = gen_select_node(
-            concept,
-            local_optional,
+            [concept] + local_optional,
             environment,
             g,
             depth + 1,
@@ -189,9 +188,10 @@ __all__ = [
     "WindowNode",
     "StrategyNode",
     "NodeJoin",
-    "ConstantNode",
     "UnnestNode",
+    "ConstantNode",
     "UnionNode",
     "History",
     "WhereSafetyNode",
+    "RecursiveNode",
 ]

trilogy/core/processing/nodes/recursive_node.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from trilogy.core.enums import SourceType
+from trilogy.core.models.build import BuildConcept
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.models.execute import QueryDatasource
+from trilogy.core.processing.nodes.base_node import StrategyNode
+
+
+class RecursiveNode(StrategyNode):
+    """Union nodes represent combining two keyspaces"""
+
+    source_type = SourceType.RECURSIVE
+
+    def __init__(
+        self,
+        input_concepts: List[BuildConcept],
+        output_concepts: List[BuildConcept],
+        environment: BuildEnvironment,
+        whole_grain: bool = False,
+        parents: List["StrategyNode"] | None = None,
+        depth: int = 0,
+    ):
+        super().__init__(
+            input_concepts=input_concepts,
+            output_concepts=output_concepts,
+            environment=environment,
+            whole_grain=whole_grain,
+            parents=parents,
+            depth=depth,
+        )
+
+    def _resolve(self) -> QueryDatasource:
+        """We need to ensure that any filtered values are removed from the output to avoid inappropriate references"""
+        base = super()._resolve()
+        return base
+
+    def copy(self) -> "RecursiveNode":
+        return RecursiveNode(
+            input_concepts=list(self.input_concepts),
+            output_concepts=list(self.output_concepts),
+            environment=self.environment,
+            whole_grain=self.whole_grain,
+            parents=self.parents,
+            depth=self.depth,
+        )

trilogy/core/query_processor.py

@@ -26,6 +26,7 @@ from trilogy.core.models.execute import (
     InstantiatedUnnestJoin,
     Join,
     QueryDatasource,
+    RecursiveCTE,
     UnionCTE,
     UnnestJoin,
 )
@@ -340,7 +341,12 @@ def datasource_to_cte(
     base_name, base_alias = resolve_cte_base_name_and_alias_v2(
         human_id, query_datasource, source_map, final_joins
     )
-    cte = CTE(
+    cte_class = CTE
+
+    if query_datasource.source_type == SourceType.RECURSIVE:
+        cte_class = RecursiveCTE
+        # extra_kwargs['left_recursive_concept'] = query_datasource.left
+    cte = cte_class(
         name=human_id,
         source=query_datasource,
         # output columns are what are selected/grouped by

trilogy/dialect/base.py

@@ -48,7 +48,7 @@ from trilogy.core.models.core import (
 )
 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.models.execute import CTE, CompiledCTE, RecursiveCTE, UnionCTE
 from trilogy.core.processing.utility import (
     decompose_condition,
     is_scalar_condition,
@@ -173,6 +173,7 @@ FUNCTION_MAP = {
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.UNNEST: lambda x: f"unnest({x[0]})",
+    FunctionType.RECURSE_EDGE: lambda x: f"CASE WHEN {x[1]} IS NULL THEN {x[0]} ELSE {x[1]} END",
     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)}]",
@@ -247,7 +248,7 @@ FUNCTION_GRAIN_MATCH_MAP = {
 
 GENERIC_SQL_TEMPLATE = Template(
     """{%- if ctes %}
-WITH {% for cte in ctes %}
+WITH {% if recursive%} RECURSIVE {% endif %}{% for cte in ctes %}
 {{cte.name}} as (
 {{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}
@@ -734,6 +735,11 @@ class BaseDialect:
                 ]
                 base_statement += "\nORDER BY " + ",".join(ordering)
             return CompiledCTE(name=cte.name, statement=base_statement)
+        elif isinstance(cte, RecursiveCTE):
+            base_statement = "\nUNION ALL\n".join(
+                [self.render_cte(child, False).statement for child in cte.internal_ctes]
+            )
+            return CompiledCTE(name=cte.name, statement=base_statement)
         if self.UNNEST_MODE in (
             UnnestMode.CROSS_APPLY,
             UnnestMode.CROSS_JOIN,
@@ -1002,9 +1008,12 @@ class BaseDialect:
                 f" {selected}"
             )
 
+        recursive = any(isinstance(x, RecursiveCTE) for x in query.ctes)
+
         compiled_ctes = self.generate_ctes(query)
 
         final = self.SQL_TEMPLATE.render(
+            recursive=recursive,
             output=(
                 query.output_to if isinstance(query, ProcessedQueryPersist) else None
             ),

trilogy/dialect/bigquery.py

@@ -59,8 +59,9 @@ BQ_SQL_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
-{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% else%}
+{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}
 {{full_select}}
 {%- else -%}
@@ -68,10 +69,8 @@ SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM
-    {{ base }}{% endif %}{% if joins %}
-{% for join in joins %}
-{{ join }}
-{% endfor %}{% endif %}
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
 {% if where %}WHERE
     {{ where }}
 {% endif %}

trilogy/dialect/common.py

@@ -2,15 +2,19 @@ from typing import Callable
 
 from trilogy.core.enums import Modifier, UnnestMode
 from trilogy.core.models.build import (
+    BuildComparison,
     BuildConcept,
+    BuildConditional,
     BuildFunction,
     BuildParamaterizedConceptReference,
+    BuildParenthetical,
 )
 from trilogy.core.models.datasource import RawColumnExpr
 from trilogy.core.models.execute import (
     CTE,
     InstantiatedUnnestJoin,
     Join,
+    UnionCTE,
 )
 
 
@@ -49,7 +53,7 @@ def render_unnest(
 def render_join_concept(
     name: str,
     quote_character: str,
-    cte: CTE,
+    cte: CTE | UnionCTE,
     concept: BuildConcept,
     render_expr,
     inlined_ctes: set[str],
@@ -71,7 +75,16 @@ def render_join(
     join: Join | InstantiatedUnnestJoin,
     quote_character: str,
     render_expr_func: Callable[
-        [BuildConcept | BuildParamaterizedConceptReference | BuildFunction, CTE], str
+        [
+            BuildConcept
+            | BuildParamaterizedConceptReference
+            | BuildFunction
+            | BuildConditional
+            | BuildComparison
+            | BuildParenthetical,
+            CTE,
+        ],
+        str,
     ],
     cte: CTE,
     unnest_mode: UnnestMode = UnnestMode.CROSS_APPLY,
@@ -127,4 +140,7 @@ def render_join(
         base_joinkeys = ["1=1"]
 
     joinkeys = " AND ".join(sorted(base_joinkeys))
-    return f"{join.jointype.value.upper()} JOIN {right_base} on {joinkeys}"
+    base = f"{join.jointype.value.upper()} JOIN {right_base} on {joinkeys}"
+    if join.condition:
+        base = f"{base} and {render_expr_func(join.condition, cte)}"
+    return base

trilogy/dialect/duckdb.py

@@ -58,7 +58,7 @@ DUCKDB_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
 {{cte.name}} as (
 {{cte.statement}}){% if not loop.last %},{% else %}
 {% endif %}{% endfor %}{% endif %}

trilogy/dialect/snowflake.py

@@ -41,12 +41,14 @@ FUNCTION_GRAIN_MATCH_MAP = {
     FunctionType.AVG: lambda args: f"{args[0]}",
 }
 
-BQ_SQL_TEMPLATE = Template(
+
+SNOWFLAKE_SQL_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
-{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+"{{cte.name}}" as ({{cte.statement}}){% if not loop.last %},{% endif %}{% else %}
+{% endfor %}{% endif %}
 {%- if full_select -%}
 {{full_select}}
 {%- else -%}
@@ -55,10 +57,8 @@ SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM
-    {{ base }}{% endif %}{% if joins %}
-{% for join in joins %}
-{{ join }}
-{% endfor %}{% endif %}
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
 {% if where %}WHERE
     {{ where }}
 {% endif %}
@@ -84,5 +84,5 @@ class SnowflakeDialect(BaseDialect):
         **FUNCTION_GRAIN_MATCH_MAP,
     }
     QUOTE_CHARACTER = '"'
-    SQL_TEMPLATE = BQ_SQL_TEMPLATE
+    SQL_TEMPLATE = SNOWFLAKE_SQL_TEMPLATE
     UNNEST_MODE = UnnestMode.SNOWFLAKE

trilogy/parsing/common.py

@@ -397,7 +397,7 @@ def group_function_to_concept(
             modifiers=modifiers,
             grain=grain,
             metadata=fmetadata,
-            derivation=Derivation.BASIC,
+            derivation=Derivation.GROUP_TO,
             granularity=granularity,
         )
         return r
@@ -476,6 +476,9 @@ def function_to_concept(
     elif parent.operator == FunctionType.UNNEST:
         derivation = Derivation.UNNEST
         granularity = Granularity.MULTI_ROW
+    elif parent.operator == FunctionType.RECURSE_EDGE:
+        derivation = Derivation.RECURSIVE
+        granularity = Granularity.MULTI_ROW
     elif parent.operator in FunctionClass.SINGLE_ROW.value:
         derivation = Derivation.CONSTANT
         granularity = Granularity.SINGLE_ROW
@@ -651,7 +654,6 @@ def agg_wrapper_to_concept(
     fmetadata = metadata or Metadata()
     aggfunction = parent.function
     modifiers = get_upstream_modifiers(parent.concept_arguments, environment)
-    # derivation = Concept.calculate_derivation(parent, Purpose.PROPERTY)
     grain = Grain.from_concepts(parent.by, environment) if parent.by else Grain()
     granularity = Concept.calculate_granularity(Derivation.AGGREGATE, grain, parent)
 
@@ -775,7 +777,6 @@ def rowset_to_concepts(rowset: RowsetDerivationStatement, environment: Environme
     for x in pre_output:
         x.lineage = RowsetItem(
             content=orig_map[x.address].reference,
-            # where=rowset.select.where_clause,
             rowset=RowsetLineage(
                 name=rowset.name,
                 derived_concepts=[x.reference for x in pre_output],

trilogy/parsing/parse_engine.py

@@ -74,6 +74,7 @@ from trilogy.core.models.author import (
     Parenthetical,
     RowsetItem,
     SubselectComparison,
+    UndefinedConceptFull,
     WhereClause,
     Window,
     WindowItem,
@@ -962,6 +963,11 @@ class ParseToObjects(Transformer):
             targets = {sources[0].address: self.environment.concepts[target]}
 
         if self.parse_pass == ParsePass.VALIDATION:
+            for source_c in sources:
+                if isinstance(source_c, UndefinedConceptFull):
+                    raise SyntaxError(
+                        f"Cannot merge non-existent source concept {source_c.address} on line: {meta.line}"
+                    )
             new = MergeStatementV2(
                 sources=sources,
                 targets=targets,
@@ -1657,6 +1663,12 @@ class ParseToObjects(Transformer):
     def fnullif(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.NULLIF, meta)
 
+    @v_args(meta=True)
+    def frecurse_edge(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.RECURSE_EDGE, meta
+        )
+
     @v_args(meta=True)
     def unnest(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.UNNEST, meta)

trilogy/parsing/trilogy.lark

@@ -247,8 +247,10 @@
     fnot: "NOT"i expr
     fbool: "bool"i "(" expr ")"
     fnullif: "nullif"i "(" expr "," expr ")"
+    _FRECURSE_EDGE.1: "recurse_edge("i
+    frecurse_edge: _FRECURSE_EDGE expr "," expr ")"
 
-    _generic_functions: fcast |  concat  | fcoalesce | fnullif | fcase  | len | fnot | fbool
+    _generic_functions: fcast |  concat  | fcoalesce | fnullif | fcase  | len | fnot | fbool | frecurse_edge
 
     //constant
     CURRENT_DATE.1: /current_date\(\)/

trilogy/std/date.preql

@@ -2,7 +2,9 @@
 
 type year int;
 type month int;
+type week int;
 type day int;
 type hour int;
 type minute int;
-type second int;
+type second int;
+type day_of_week int;

trilogy/std/geography.preql

@@ -15,3 +15,7 @@ type city string; # City name
 type country string; # Country name
 type timezone string; # Timezone name
 type region string; # Region name
+
+
+## special formats
+type geojson string; # GeoJSON format for geographic data