pytrilogy 0.0.3.112__py3-none-any.whl → 0.0.3.115__py3-none-any.whl

trilogy/core/processing/node_generators/filter_node.py

@@ -96,6 +96,8 @@ def build_parent_concepts(
                 continue
         elif global_filter_is_local_filter:
             same_filter_optional.append(x)
+            # also append it to the parent row concepts
+            parent_row_concepts.append(x)
 
     # sometimes, it's okay to include other local optional above the filter
     # in case it is, prep our list
@@ -204,11 +206,16 @@ def gen_filter_node(
             f"{padding(depth)}{LOGGER_PREFIX} filter node row parents {[x.address for x in parent_row_concepts]} could not be found"
         )
         return None
+    else:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} filter node has row parents {[x.address for x in parent_row_concepts]} from node with output [{[x.address for x in row_parent.output_concepts]}] partial {row_parent.partial_concepts}"
+        )
     if global_filter_is_local_filter:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} filter node conditions match global conditions adding row parent {row_parent.output_concepts} with condition {where.conditional}"
         )
         row_parent.add_parents(core_parent_nodes)
+        # all local optional will be in the parent already, so we can set outputs
         row_parent.set_output_concepts([concept] + local_optional)
         return row_parent
     if optimized_pushdown:

trilogy/core/processing/node_generators/unnest_node.py

@@ -9,6 +9,7 @@ from trilogy.core.models.build import (
 from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.nodes import (
     History,
+    MergeNode,
     StrategyNode,
     UnnestNode,
     WhereSafetyNode,
@@ -18,6 +19,32 @@ from trilogy.core.processing.utility import padding
 LOGGER_PREFIX = "[GEN_UNNEST_NODE]"
 
 
+def get_pseudonym_parents(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    source_concepts,
+    environment: BuildEnvironment,
+    g,
+    depth,
+    history,
+    conditions,
+) -> List[StrategyNode]:
+    for x in concept.pseudonyms:
+        attempt = source_concepts(
+            mandatory_list=[environment.alias_origin_lookup[x]] + local_optional,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
+            conditions=conditions,
+            accept_partial=True,
+        )
+        if not attempt:
+            continue
+        return [attempt]
+    return []
+
+
 def gen_unnest_node(
     concept: BuildConcept,
     local_optional: List[BuildConcept],
@@ -29,14 +56,34 @@ def gen_unnest_node(
     conditions: BuildWhereClause | None = None,
 ) -> StrategyNode | None:
     arguments = []
+    join_nodes: list[StrategyNode] = []
     depth_prefix = "\t" * depth
     if isinstance(concept.lineage, BuildFunction):
         arguments = concept.lineage.concept_arguments
+    search_optional = local_optional
+    if (not arguments) and (local_optional and concept.pseudonyms):
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} unnest node for {concept} has no parents; creating solo unnest node"
+        )
+        join_nodes += get_pseudonym_parents(
+            concept,
+            local_optional,
+            source_concepts,
+            environment,
+            g,
+            depth,
+            history,
+            conditions,
+        )
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} unnest node for {concept} got join nodes {join_nodes}"
+        )
+        search_optional = []
 
-    equivalent_optional = [x for x in local_optional if x.lineage == concept.lineage]
+    equivalent_optional = [x for x in search_optional if x.lineage == concept.lineage]
 
     non_equivalent_optional = [
-        x for x in local_optional if x not in equivalent_optional
+        x for x in search_optional if x not in equivalent_optional
     ]
     all_parents = arguments + non_equivalent_optional
     logger.info(
@@ -44,7 +91,8 @@ def gen_unnest_node(
     )
     local_conditions = False
     expected_outputs = [concept] + local_optional
-    if arguments or local_optional:
+    parent: StrategyNode | None = None
+    if arguments or search_optional:
         parent = source_concepts(
             mandatory_list=all_parents,
             environment=environment,
@@ -86,14 +134,37 @@ def gen_unnest_node(
     base = UnnestNode(
         unnest_concepts=[concept] + equivalent_optional,
         input_concepts=arguments + non_equivalent_optional,
-        output_concepts=[concept] + local_optional,
+        output_concepts=[concept] + search_optional,
         environment=environment,
         parents=([parent] if parent else []),
     )
+
+    conditional = conditions.conditional if conditions else None
+    if join_nodes:
+        logger.info(
+            f"{depth_prefix}{LOGGER_PREFIX} unnest node for {concept} needs to merge with join nodes {join_nodes}"
+        )
+        for x in join_nodes:
+            logger.info(
+                f"{depth_prefix}{LOGGER_PREFIX} join node {x} with partial {x.partial_concepts}"
+            )
+            pseudonyms = [
+                environment.alias_origin_lookup[p] for p in concept.pseudonyms
+            ]
+            x.add_partial_concepts(pseudonyms)
+        return MergeNode(
+            input_concepts=base.output_concepts
+            + [j for n in join_nodes for j in n.output_concepts],
+            output_concepts=[concept] + local_optional,
+            environment=environment,
+            parents=[base] + join_nodes,
+            conditions=conditional if local_conditions is True else None,
+            preexisting_conditions=(
+                conditional if conditional and local_conditions is False else None
+            ),
+        )
     # we need to sometimes nest an unnest node,
     # as unnest operations are not valid in all situations
-    # TODO: inline this node when we can detect it's safe
-    conditional = conditions.conditional if conditions else None
     new = WhereSafetyNode(
         input_concepts=base.output_concepts,
         output_concepts=base.output_concepts,

trilogy/core/statements/author.py

@@ -31,6 +31,7 @@ from trilogy.core.models.author import (
     Metadata,
     MultiSelectLineage,
     OrderBy,
+    Parenthetical,
     SelectLineage,
     UndefinedConcept,
     WhereClause,
@@ -48,7 +49,12 @@ from trilogy.utility import unique
 
 class ConceptTransform(BaseModel):
     function: (
-        Function | FilterItem | WindowItem | AggregateWrapper | FunctionCallWrapper
+        Function
+        | FilterItem
+        | WindowItem
+        | AggregateWrapper
+        | FunctionCallWrapper
+        | Parenthetical
     )
     output: Concept  # this has to be a full concept, as it may not exist in environment
     modifiers: List[Modifier] = Field(default_factory=list)
@@ -190,9 +196,17 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
         if self.where_clause:
             for x in self.where_clause.concept_arguments:
                 if isinstance(x, UndefinedConcept):
-                    environment.concepts.raise_undefined(
-                        x.address, x.metadata.line_number if x.metadata else None
-                    )
+                    validate = environment.concepts.get(x.address)
+                    if validate and self.where_clause:
+                        self.where_clause = (
+                            self.where_clause.with_reference_replacement(
+                                x.address, validate.reference
+                            )
+                        )
+                    else:
+                        environment.concepts.raise_undefined(
+                            x.address, x.metadata.line_number if x.metadata else None
+                        )
         all_in_output = [x for x in self.output_components]
         if self.where_clause:
             for cref in self.where_clause.concept_arguments:

trilogy/dialect/base.py

@@ -194,6 +194,13 @@ 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.DATE_SPINE: lambda x: f"""unnest(
+        generate_series(
+            {x[0]},
+            {x[1]},
+            INTERVAL '1 day'
+        )
+    )""",
     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))}}}",
@@ -213,6 +220,9 @@ FUNCTION_MAP = {
     FunctionType.ARRAY_TO_STRING: lambda args: (
         f"array_to_string({args[0]}, {args[1]})"
     ),
+    FunctionType.ARRAY_FILTER: lambda args: (
+        f"array_filter({args[0]}, {args[1]} -> {args[2]})"
+    ),
     # math
     FunctionType.ADD: lambda x: " + ".join(x),
     FunctionType.ABS: lambda x: f"abs({x[0]})",
@@ -237,6 +247,7 @@ FUNCTION_MAP = {
     FunctionType.AVG: lambda x: f"avg({x[0]})",
     FunctionType.MAX: lambda x: f"max({x[0]})",
     FunctionType.MIN: lambda x: f"min({x[0]})",
+    FunctionType.ANY: lambda x: f"any_value({x[0]})",
     # string types
     FunctionType.LIKE: lambda x: f" {x[0]} like {x[1]} ",
     FunctionType.UPPER: lambda x: f"UPPER({x[0]}) ",
@@ -263,9 +274,11 @@ FUNCTION_MAP = {
     FunctionType.MINUTE: lambda x: f"minute({x[0]})",
     FunctionType.HOUR: lambda x: f"hour({x[0]})",
     FunctionType.DAY: lambda x: f"day({x[0]})",
+    FunctionType.DAY_NAME: lambda x: f"dayname({x[0]})",
     FunctionType.DAY_OF_WEEK: lambda x: f"day_of_week({x[0]})",
     FunctionType.WEEK: lambda x: f"week({x[0]})",
     FunctionType.MONTH: lambda x: f"month({x[0]})",
+    FunctionType.MONTH_NAME: lambda x: f"monthname({x[0]})",
     FunctionType.QUARTER: lambda x: f"quarter({x[0]})",
     FunctionType.YEAR: lambda x: f"year({x[0]})",
     # string types
@@ -283,6 +296,7 @@ FUNCTION_GRAIN_MATCH_MAP = {
     FunctionType.AVG: lambda args: f"{args[0]}",
     FunctionType.MAX: lambda args: f"{args[0]}",
     FunctionType.MIN: lambda args: f"{args[0]}",
+    FunctionType.ANY: lambda args: f"{args[0]}",
 }
 
 

trilogy/dialect/duckdb.py

@@ -57,6 +57,15 @@ def render_log(args):
         raise ValueError("log function requires 1 or 2 arguments")
 
 
+def map_date_part_specifier(specifier: str) -> str:
+    """Map date part specifiers to DuckDB-compatible names"""
+    mapping = {
+        "day_of_week": "dow",
+        # Add other mappings if needed
+    }
+    return mapping.get(specifier, specifier)
+
+
 FUNCTION_MAP = {
     FunctionType.COUNT: lambda args: f"count({args[0]})",
     FunctionType.SUM: lambda args: f"sum({args[0]})",
@@ -84,11 +93,13 @@ FUNCTION_MAP = {
     FunctionType.ARRAY_AGG: lambda args: f"array_agg({args[0]})",
     # datetime is aliased
     FunctionType.CURRENT_DATETIME: lambda x: "cast(get_current_timestamp() as datetime)",
+    FunctionType.DATETIME: lambda x: f"cast({x[0]} as datetime)",
+    FunctionType.TIMESTAMP: lambda x: f"cast({x[0]} as timestamp)",
     FunctionType.DATE: lambda x: f"cast({x[0]} as date)",
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc('{x[1]}', {x[0]})",
     FunctionType.DATE_ADD: lambda x: f"date_add({x[0]}, {x[2]} * INTERVAL 1 {x[1]})",
     FunctionType.DATE_SUB: lambda x: f"date_add({x[0]}, -{x[2]} * INTERVAL 1 {x[1]})",
-    FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
+    FunctionType.DATE_PART: lambda x: f"date_part('{map_date_part_specifier(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}'",

trilogy/parsing/common.py

@@ -55,6 +55,21 @@ from trilogy.core.models.environment import Environment
 from trilogy.core.statements.author import RowsetDerivationStatement, SelectStatement
 from trilogy.utility import string_to_hash, unique
 
+ARBITRARY_INPUTS = (
+    AggregateWrapper
+    | FunctionCallWrapper
+    | WindowItem
+    | FilterItem
+    | Function
+    | Parenthetical
+    | ListWrapper
+    | MapWrapper
+    | int
+    | float
+    | str
+    | date
+)
+
 
 def process_function_arg(
     arg,
@@ -76,7 +91,7 @@ def process_function_arg(
         # to simplify anonymous function handling
         if (
             arg.operator not in FunctionClass.AGGREGATE_FUNCTIONS.value
-            and arg.operator != FunctionType.UNNEST
+            and arg.operator not in FunctionClass.ONE_TO_MANY.value
         ):
             return arg
         id_hash = string_to_hash(str(arg))
@@ -296,13 +311,18 @@ def concept_is_relevant(
     if concept.purpose in (Purpose.METRIC,):
         if all([c in others for c in concept.grain.components]):
             return False
+    if (
+        concept.derivation in (Derivation.BASIC,)
+        and isinstance(concept.lineage, Function)
+        and concept.lineage.operator == FunctionType.DATE_SPINE
+    ):
+        return True
     if concept.derivation in (Derivation.BASIC,) and isinstance(
         concept.lineage, (Function, CaseWhen)
     ):
         relevant = False
         for arg in concept.lineage.arguments:
             relevant = atom_is_relevant(arg, others, environment) or relevant
-
         return relevant
     if concept.derivation in (Derivation.BASIC,) and isinstance(
         concept.lineage, Parenthetical
@@ -514,7 +534,7 @@ def function_to_concept(
     elif parent.operator == FunctionType.UNION:
         derivation = Derivation.UNION
         granularity = Granularity.MULTI_ROW
-    elif parent.operator == FunctionType.UNNEST:
+    elif parent.operator in FunctionClass.ONE_TO_MANY.value:
         derivation = Derivation.UNNEST
         granularity = Granularity.MULTI_ROW
     elif parent.operator == FunctionType.RECURSE_EDGE:
@@ -625,7 +645,7 @@ def window_item_to_concept(
     fmetadata = metadata or Metadata()
     if not isinstance(parent.content, ConceptRef):
         raise NotImplementedError(
-            f"Window function wiht non ref content {parent.content} not yet supported"
+            f"Window function with non ref content {parent.content} not yet supported"
         )
     bcontent = environment.concepts[parent.content.address]
     if isinstance(bcontent, UndefinedConcept):
@@ -844,6 +864,7 @@ def generate_concept_name(
         | Function
         | ListWrapper
         | MapWrapper
+        | Parenthetical
         | int
         | float
         | str
@@ -865,24 +886,36 @@ def generate_concept_name(
             return f"{VIRTUAL_CONCEPT_PREFIX}_group_to_{string_to_hash(str(parent))}"
         else:
             return f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
+    elif isinstance(parent, Parenthetical):
+        return f"{VIRTUAL_CONCEPT_PREFIX}_paren_{string_to_hash(str(parent))}"
+    elif isinstance(parent, FunctionCallWrapper):
+        return f"{VIRTUAL_CONCEPT_PREFIX}_{parent.name}_{string_to_hash(str(parent))}"
     else:  # ListWrapper, MapWrapper, or primitive types
         return f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
 
 
+def parenthetical_to_concept(
+    parent: Parenthetical,
+    name: str,
+    namespace: str,
+    environment: Environment,
+    metadata: Metadata | None = None,
+) -> Concept:
+    if isinstance(
+        parent.content,
+        ARBITRARY_INPUTS,
+    ):
+
+        return arbitrary_to_concept(
+            parent.content, environment, namespace, name, metadata
+        )
+    raise NotImplementedError(
+        f"Parenthetical with non-supported content {parent.content} ({type(parent.content)}) not yet supported"
+    )
+
+
 def arbitrary_to_concept(
-    parent: (
-        AggregateWrapper
-        | FunctionCallWrapper
-        | WindowItem
-        | FilterItem
-        | Function
-        | ListWrapper
-        | MapWrapper
-        | int
-        | float
-        | str
-        | date
-    ),
+    parent: ARBITRARY_INPUTS,
     environment: Environment,
     namespace: str | None = None,
     name: str | None = None,
@@ -938,5 +971,7 @@ def arbitrary_to_concept(
         )
     elif isinstance(parent, ListWrapper):
         return constant_to_concept(parent, name, namespace, metadata)
+    elif isinstance(parent, Parenthetical):
+        return parenthetical_to_concept(parent, name, namespace, environment, metadata)
     else:
         return constant_to_concept(parent, name, namespace, metadata)

trilogy/parsing/parse_engine.py

@@ -223,7 +223,14 @@ def expr_to_boolean(
 def unwrap_transformation(
     input: Expr,
     environment: Environment,
-) -> Function | FilterItem | WindowItem | AggregateWrapper | FunctionCallWrapper:
+) -> (
+    Function
+    | FilterItem
+    | WindowItem
+    | AggregateWrapper
+    | FunctionCallWrapper
+    | Parenthetical
+):
     if isinstance(input, Function):
         return input
     elif isinstance(input, AggregateWrapper):
@@ -243,7 +250,7 @@ def unwrap_transformation(
     elif isinstance(input, FunctionCallWrapper):
         return input
     elif isinstance(input, Parenthetical):
-        return unwrap_transformation(input.content, environment)
+        return input
     else:
         return Function.model_construct(
             operator=FunctionType.CONSTANT,
@@ -779,7 +786,6 @@ class ParseToObjects(Transformer):
         lookup, namespace, name, parent = parse_concept_reference(
             name, self.environment
         )
-
         concept = Concept(
             name=name,
             datatype=arg_to_datatype(constant),
@@ -1813,6 +1819,10 @@ class ParseToObjects(Transformer):
     def array_agg(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.ARRAY_AGG, meta)
 
+    @v_args(meta=True)
+    def any(self, meta, args):
+        return self.function_factory.create_function(args, FunctionType.ANY, meta)
+
     @v_args(meta=True)
     def avg(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.AVG, meta)
@@ -1953,6 +1963,10 @@ class ParseToObjects(Transformer):
     def fday(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.DAY, meta)
 
+    @v_args(meta=True)
+    def fday_name(self, meta, args):
+        return self.function_factory.create_function(args, FunctionType.DAY_NAME, meta)
+
     @v_args(meta=True)
     def fday_of_week(self, meta, args):
         return self.function_factory.create_function(
@@ -1967,6 +1981,12 @@ class ParseToObjects(Transformer):
     def fmonth(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.MONTH, meta)
 
+    @v_args(meta=True)
+    def fmonth_name(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.MONTH_NAME, meta
+        )
+
     @v_args(meta=True)
     def fquarter(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.QUARTER, meta)
@@ -2006,6 +2026,12 @@ class ParseToObjects(Transformer):
             )
         return self.function_factory.create_function(args, FunctionType.CAST, meta)
 
+    @v_args(meta=True)
+    def fdate_spine(self, meta, args) -> Function:
+        return self.function_factory.create_function(
+            args, FunctionType.DATE_SPINE, meta
+        )
+
     # utility functions
     @v_args(meta=True)
     def fcast(self, meta, args) -> Function:
@@ -2175,6 +2201,33 @@ class ParseToObjects(Transformer):
             meta,
         )
 
+    @v_args(meta=True)
+    def farray_filter(self, meta, args) -> Function:
+        factory: CustomFunctionFactory = args[1]
+        if not len(factory.function_arguments) == 1:
+            raise InvalidSyntaxException(
+                "Array filter function must have exactly one argument;"
+            )
+        array_type = arg_to_datatype(args[0])
+        if not isinstance(array_type, ArrayType):
+            raise InvalidSyntaxException(
+                f"Array filter function must be applied to an array, not {array_type}"
+            )
+        return self.function_factory.create_function(
+            [
+                args[0],
+                factory.function_arguments[0],
+                factory(
+                    ArgBinding(
+                        name=factory.function_arguments[0].name,
+                        datatype=array_type.value_data_type,
+                    )
+                ),
+            ],
+            FunctionType.ARRAY_FILTER,
+            meta,
+        )
+
 
 def unpack_visit_error(e: VisitError, text: str | None = None):
     """This is required to get exceptions from imports, which would
@@ -2211,6 +2264,7 @@ ERROR_CODES: dict[int, str] = {
     101: "Using FROM keyword? Trilogy does not have a FROM clause (Datasource resolution is automatic).",
     # 200 codes relate to required explicit syntax (we could loosen these?)
     201: 'Missing alias? Alias must be specified with "AS" - e.g. `SELECT x+1 AS y`',
+    202: "Missing closing semicolon? Statements must be terminated with a semicolon `;`.",
     210: "Missing order direction? Order by must be explicit about direction - specify `asc` or `desc`.",
 }
 
@@ -2291,7 +2345,7 @@ def parse_text(
         )
 
     def _handle_unexpected_token(e: UnexpectedToken, text: str) -> None:
-        """Handle UnexpectedToken errors with specific logic."""
+        """Handle UnexpectedToken errors to make friendlier error messages."""
         # Handle ordering direction error
         pos = e.pos_in_stream or 0
         if e.expected == {"ORDERING_DIRECTION"}:
@@ -2303,12 +2357,27 @@ def parse_text(
         )
         if parsed_tokens == ["FROM"]:
             raise _create_syntax_error(101, pos, text)
-
-        # Attempt recovery for aliasing
+        # check if they are missing a semicolon
+        try:
+            e.interactive_parser.feed_token(Token("_TERMINATOR", ";"))
+            state = e.interactive_parser.lexer_thread.state
+            if state and state.last_token:
+                new_pos = state.last_token.end_pos or pos
+            else:
+                new_pos = pos
+            raise _create_syntax_error(202, new_pos, text)
+        except UnexpectedToken:
+            pass
+        # check if they forgot an as
         try:
             e.interactive_parser.feed_token(Token("AS", "AS"))
+            state = e.interactive_parser.lexer_thread.state
+            if state and state.last_token:
+                new_pos = state.last_token.end_pos or pos
+            else:
+                new_pos = pos
             e.interactive_parser.feed_token(Token("IDENTIFIER", e.token.value))
-            raise _create_syntax_error(201, pos, text)
+            raise _create_syntax_error(201, new_pos, text)
         except UnexpectedToken:
             pass
 

trilogy/parsing/render.py

@@ -662,7 +662,8 @@ class Renderer:
                     pair_strings.append(self.indent_lines(pair_line))
             inputs = ",\n".join(pair_strings)
             return f"struct(\n{inputs}\n{self.indent_context.current_indent})"
-
+        if arg.operator == FunctionType.ALIAS:
+            return f"{self.to_string(arg.arguments[0])}"
         inputs = ",".join(args)
         return f"{arg.operator.value}({inputs})"
 

trilogy/parsing/trilogy.lark

@@ -113,7 +113,7 @@
     filter_item: _filter_base | _filter_alt
 
     // rank/lag/lead
-    WINDOW_TYPE: ("row_number"i|"rank"i|"lag"i|"lead"i | "sum"i | "avg"i | "max"i | "min"i )  /[\s]+/
+    WINDOW_TYPE: ("row_number"i|"rank"i|"lag"i|"lead"i | "sum"i | "avg"i | "max"i | "min"i | "count"i  )  /[\s]+/
 
     window_item_over: ("OVER"i over_list)
    
@@ -323,8 +323,10 @@
     _ARRAY_TRANSFORM.1: "array_transform("i
     transform_lambda: "@" IDENTIFIER
     farray_transform: _ARRAY_TRANSFORM expr ","  transform_lambda   ")"
+    _ARRAY_FILTER.1: "array_filter("i
+    farray_filter: _ARRAY_FILTER expr "," transform_lambda ")"
 
-    _array_functions: farray_sum | farray_distinct | farray_sort | farray_transform | farray_to_string
+    _array_functions: farray_sum | farray_distinct | farray_sort | farray_transform | farray_to_string | farray_filter
 
     //map_functions
     _MAP_KEYS.1: "map_keys("i
@@ -358,11 +360,13 @@
     min: _MIN expr ")"
     _ARRAY_AGG.1: "array_agg("i
     array_agg: _ARRAY_AGG expr ")"
+    _ANY.1: "any("i
+    any: _ANY expr ")"
     
     //aggregates can force a grain
     aggregate_all: "*"
     aggregate_over: ("BY"i (aggregate_all | over_list))
-    aggregate_functions: (count | count_distinct | sum | avg | max | min | array_agg) aggregate_over?
+    aggregate_functions: (count | count_distinct | sum | avg | max | min | array_agg | any) aggregate_over?
 
     // date functions
     _DATE.1: "date("i
@@ -379,12 +383,16 @@
     fhour: _HOUR expr ")"
     _DAY.1: "day("i
     fday:  _DAY expr ")"
+    _DAY_NAME.1: "day_name("i
+    fday_name:  _DAY_NAME expr ")"
     _DAY_OF_WEEK.1: "day_of_week("i
     fday_of_week:  _DAY_OF_WEEK expr ")"
     _WEEK.1: "week("i
     fweek: _WEEK expr ")"
     _MONTH.1: "month("i
     fmonth: _MONTH expr ")"
+    _MONTH_NAME.1: "month_name("i
+    fmonth_name: _MONTH_NAME expr ")"
     _QUARTER.1: "quarter("i
     fquarter: _QUARTER expr ")"
     _YEAR.1: "year("i
@@ -401,8 +409,10 @@
     fdate_sub: _DATE_SUB expr "," DATE_PART "," expr ")"
     _DATE_DIFF.1: "date_diff("i
     fdate_diff: _DATE_DIFF expr "," expr "," DATE_PART ")"
+    _DATE_SPINE.1: "date_spine("i
+    fdate_spine: _DATE_SPINE expr "," expr  ")"
     
-    _date_functions: fdate | fdate_add | fdate_sub | fdate_diff | fdatetime | ftimestamp | fsecond | fminute | fhour | fday | fday_of_week | fweek | fmonth | fquarter | fyear | fdate_part | fdate_trunc
+    _date_functions: fdate | fdate_add | fdate_sub | fdate_diff | fdatetime | ftimestamp | fsecond | fminute | fhour | fday |fday_name | fday_of_week | fweek | fmonth | fmonth_name | fquarter | fyear | fdate_part | fdate_trunc | fdate_spine
     
     _static_functions:  _string_functions | _math_functions | _array_functions | _map_functions
 
@@ -430,7 +440,7 @@
     
     float_lit: /\-?[0-9]*\.[0-9]+/
 
-    array_lit: "[" (literal ",")* literal ","? "]"()
+    array_lit: "[" (expr ",")* expr ","? "]"()
 
     tuple_lit: "(" (literal ",")* literal ","? ")"