pytrilogy 0.0.2.2__py3-none-any.whl → 0.0.2.4__py3-none-any.whl

trilogy/dialect/base.py

@@ -2,13 +2,13 @@ from typing import List, Union, Optional, Dict, Any, Sequence, Callable
 
 from jinja2 import Template
 
+from trilogy.core.processing.utility import is_scalar_condition
 from trilogy.constants import CONFIG, logger, MagicConstants
 from trilogy.core.internal import DEFAULT_CONCEPTS
 from trilogy.core.enums import (
     FunctionType,
     WindowType,
     DatePart,
-    PurposeLineage,
     ComparisonOperator,
 )
 from trilogy.core.models import (
@@ -36,6 +36,7 @@ from trilogy.core.models import (
     Environment,
     RawColumnExpr,
     ListWrapper,
+    MapWrapper,
     ShowStatement,
     RowsetItem,
     MultiSelectStatement,
@@ -45,6 +46,8 @@ from trilogy.core.models import (
     RawSQLStatement,
     ProcessedRawSQLStatement,
     NumericType,
+    MapType,
+    StructType,
     MergeStatementV2,
 )
 from trilogy.core.query_processor import process_query, process_persist
@@ -97,6 +100,7 @@ DATATYPE_MAP = {
     DataType.FLOAT: "float",
     DataType.BOOL: "bool",
     DataType.NUMERIC: "numeric",
+    DataType.MAP: "map",
 }
 
 
@@ -104,6 +108,10 @@ def render_case(args):
     return "CASE\n\t" + "\n\t".join(args) + "\n\tEND"
 
 
+def struct_arg(args):
+    return [f"{x[0]}: {x[1]}" for x in zip(args[::2], args[1::2])]
+
+
 FUNCTION_MAP = {
     # generic types
     FunctionType.ALIAS: lambda x: f"{x[0]}",
@@ -116,7 +124,10 @@ FUNCTION_MAP = {
     FunctionType.IS_NULL: lambda x: f"isnull({x[0]})",
     # complex
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
+    FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}][1]",
     FunctionType.UNNEST: lambda x: f"unnest({x[0]})",
+    FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
+    FunctionType.STRUCT: lambda x: f"{{{', '.join(struct_arg(x))}}}",
     # math
     FunctionType.ADD: lambda x: f"{x[0]} + {x[1]}",
     FunctionType.SUBTRACT: lambda x: f"{x[0]} - {x[1]}",
@@ -161,7 +172,6 @@ FUNCTION_MAP = {
     # constant types
     FunctionType.CURRENT_DATE: lambda x: "current_date()",
     FunctionType.CURRENT_DATETIME: lambda x: "current_datetime()",
-    FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
 }
 
 FUNCTION_GRAIN_MATCH_MAP = {
@@ -189,14 +199,15 @@ TOP {{ limit }}{% endif %}
 \t{{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM
 \t{{ base }}{% endif %}{% if joins %}{% for join in joins %}
-\t{{ join }}{% endfor %}{% endif %}
-{% if where %}WHERE
-\t{{ where }}
-{% endif %}{%- if group_by %}GROUP BY {% for group in group_by %}
-\t{{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
-{%- if order_by %}
-ORDER BY {% for order in order_by %}
-    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}
+\t{{ join }}{% endfor %}{% endif %}{% if where %}
+WHERE
+\t{{ where }}{% endif %}{%- if group_by %}
+GROUP BY {% for group in group_by %}
+\t{{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}{%- if order_by %}
+ORDER BY{% for order in order_by %}
+\t{{ order }}{% if not loop.last %},{% endif %}{% endfor %}
 {% endif %}{% endif %}
 """
 )
@@ -214,7 +225,13 @@ def safe_get_cte_value(coalesce, cte: CTE, c: Concept, quote_char: str):
     raw = cte.source_map.get(address, None)
 
     if not raw:
-        return INVALID_REFERENCE_STRING("Missing source reference")
+        for k, v in c.pseudonyms.items():
+            if cte.source_map.get(k):
+                c = v
+                raw = cte.source_map[k]
+                break
+        if not raw:
+            return INVALID_REFERENCE_STRING("Missing source reference")
     if isinstance(raw, str):
         rendered = cte.get_alias(c, raw)
         return f"{raw}.{safe_quote(rendered, quote_char)}"
@@ -291,6 +308,7 @@ class BaseDialect:
                     self.render_expr(v, cte)  # , alias=False)
                     for v in c.lineage.arguments
                 ]
+
                 if cte.group_to_grain:
                     rval = f"{self.FUNCTION_MAP[c.lineage.operator](args)}"
                 else:
@@ -335,11 +353,12 @@ class BaseDialect:
             Parenthetical,
             AggregateWrapper,
             MagicConstants,
+            MapWrapper[Any, Any],
+            MapType,
             NumericType,
+            StructType,
             ListType,
-            ListWrapper[int],
-            ListWrapper[str],
-            ListWrapper[float],
+            ListWrapper[Any],
             DatePart,
             CaseWhen,
             CaseElse,
@@ -361,11 +380,18 @@ class BaseDialect:
                     lookup_cte = cte_map.get(e.right.address)
                 assert lookup_cte, "Subselects must be rendered with a CTE in context"
                 if e.right.address not in lookup_cte.existence_source_map:
-                    lookup = lookup_cte.source_map[e.right.address]
+                    lookup = lookup_cte.source_map.get(
+                        e.right.address,
+                        [
+                            INVALID_REFERENCE_STRING(
+                                f"Missing source reference to {e.right.name}"
+                            )
+                        ],
+                    )
                 else:
                     lookup = lookup_cte.existence_source_map[e.right.address]
 
-                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} (select {lookup[0]}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {lookup[0]})"
+                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} (select {lookup[0]}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {lookup[0]} where {lookup[0]}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
             elif isinstance(e.right, (ListWrapper, Parenthetical, list)):
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
 
@@ -409,6 +435,7 @@ class BaseDialect:
         elif isinstance(e, CaseElse):
             return f"ELSE {self.render_expr(e.expr, cte=cte, cte_map=cte_map) }"
         elif isinstance(e, Function):
+
             if cte and cte.group_to_grain:
                 return self.FUNCTION_MAP[e.operator](
                     [self.render_expr(z, cte=cte, cte_map=cte_map) for z in e.arguments]
@@ -435,6 +462,8 @@ class BaseDialect:
             return str(e)
         elif isinstance(e, ListWrapper):
             return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}]"
+        elif isinstance(e, MapWrapper):
+            return f"MAP {{{','.join([f'{self.render_expr(k, cte=cte, cte_map=cte_map)}:{self.render_expr(v, cte=cte, cte_map=cte_map)}' for k, v in e.items()])}}}"
         elif isinstance(e, list):
             return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}]"
         elif isinstance(e, DataType):
@@ -496,8 +525,15 @@ class BaseDialect:
                     if j
                 ],
                 where=(
-                    self.render_expr(cte.condition, cte) if cte.condition else None
-                ),  # source_map=cte_output_map)
+                    self.render_expr(cte.condition, cte)
+                    if cte.condition and is_scalar_condition(cte.condition)
+                    else None
+                ),
+                having=(
+                    self.render_expr(cte.condition, cte)
+                    if cte.condition and not is_scalar_condition(cte.condition)
+                    else None
+                ),
                 order_by=(
                     [self.render_order_item(i, cte) for i in cte.order_by.items]
                     if cte.order_by
@@ -643,82 +679,20 @@ class BaseDialect:
                 f" {selected}"
             )
 
-        # where assignment
-        output_where = False
-        if query.where_clause:
-            # found = False
-            filter = set(
-                [
-                    str(x.address)
-                    for x in query.where_clause.row_arguments
-                    if not x.derivation == PurposeLineage.CONSTANT
-                ]
-            )
-            query_output = set([str(z.address) for z in query.output_columns])
-            # if it wasn't an output
-            # we would have forced it up earlier and we don't need to render at this point
-            if filter.issubset(query_output):
-                output_where = True
-            for ex_set in query.where_clause.existence_arguments:
-                for c in ex_set:
-                    if c.address not in cte_output_map:
-                        cts = [
-                            ct
-                            for ct in query.ctes
-                            if ct.name in query.base.existence_source_map[c.address]
-                        ]
-                        if not cts:
-                            raise ValueError(query.base.existence_source_map[c.address])
-                        cte_output_map[c.address] = cts[0]
-
         compiled_ctes = self.generate_ctes(query)
 
         # restort selections by the order they were written in
         sorted_select: List[str] = []
         for output_c in output_addresses:
             sorted_select.append(select_columns[output_c])
-        if not query.base.requires_nesting:
-            final = self.SQL_TEMPLATE.render(
-                output=(
-                    query.output_to
-                    if isinstance(query, ProcessedQueryPersist)
-                    else None
-                ),
-                full_select=compiled_ctes[-1].statement,
-                ctes=compiled_ctes[:-1],
-            )
-        else:
-            final = self.SQL_TEMPLATE.render(
-                output=(
-                    query.output_to
-                    if isinstance(query, ProcessedQueryPersist)
-                    else None
-                ),
-                select_columns=sorted_select,
-                base=query.base.name,
-                joins=[
-                    render_join(join, self.QUOTE_CHARACTER, None)
-                    for join in query.joins
-                ],
-                ctes=compiled_ctes,
-                limit=query.limit,
-                # move up to CTEs
-                where=(
-                    self.render_expr(
-                        query.where_clause.conditional, cte_map=cte_output_map
-                    )
-                    if query.where_clause and output_where
-                    else None
-                ),
-                order_by=(
-                    [
-                        self.render_order_item(i, query.base, final=True)
-                        for i in query.order_by.items
-                    ]
-                    if query.order_by
-                    else None
-                ),
-            )
+
+        final = self.SQL_TEMPLATE.render(
+            output=(
+                query.output_to if isinstance(query, ProcessedQueryPersist) else None
+            ),
+            full_select=compiled_ctes[-1].statement,
+            ctes=compiled_ctes[:-1],
+        )
 
         if CONFIG.strict_mode and INVALID_REFERENCE_STRING(1) in final:
             raise ValueError(

trilogy/dialect/bigquery.py

@@ -59,7 +59,9 @@ SELECT
     {{ where }}
 {% endif %}
 {%- if group_by %}GROUP BY {% for group in group_by %}
-    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
 {%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}

trilogy/dialect/duckdb.py

@@ -59,11 +59,12 @@ SELECT
     {{ join }}{% endfor %}{% endif %}
 {% if where %}WHERE
     {{ where }}
-{% endif -%}
-{%- if group_by %}
+{% endif -%}{%- if group_by %}
 GROUP BY {% for group in group_by %}
-    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
-{%- if order_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+    {{ having }}
+{% endif %}{%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if limit is not none %}

trilogy/dialect/postgres.py

@@ -64,7 +64,9 @@ SELECT
     {{ where }}
 {% endif %}
 {%- if group_by %}GROUP BY {% for group in group_by %}
-    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
 {%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}

trilogy/dialect/presto.py

@@ -15,6 +15,7 @@ FUNCTION_MAP = {
     FunctionType.LENGTH: lambda x: f"length({x[0]})",
     FunctionType.AVG: lambda x: f"avg({x[0]})",
     FunctionType.INDEX_ACCESS: lambda x: f"element_at({x[0]},{x[1]})",
+    FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.LIKE: lambda x: (
         f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
     ),
@@ -62,7 +63,9 @@ SELECT
     {{ where }}
 {% endif %}
 {%- if group_by %}GROUP BY {% for group in group_by %}
-    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
 {%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}

trilogy/dialect/snowflake.py

@@ -61,7 +61,9 @@ SELECT
     {{ where }}
 {% endif %}
 {%- if group_by %}GROUP BY {% for group in group_by %}
-    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
 {%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}

trilogy/dialect/sql_server.py

@@ -60,7 +60,9 @@ TOP {{ limit }}{% endif %}
 {%- if group_by %}
 GROUP BY {% for group in group_by %}
     {{group}}{% if not loop.last %},{% endif %}
-{% endfor %}{% endif %}
+{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
 {%- if order_by %}
 ORDER BY {% for order in order_by %}
     {{ order }}{% if not loop.last %},{% endif %}

trilogy/parsing/common.py

@@ -7,6 +7,7 @@ from trilogy.core.models import (
     Metadata,
     FilterItem,
     ListWrapper,
+    MapWrapper,
     WindowItem,
 )
 from typing import List, Tuple
@@ -41,7 +42,7 @@ def concept_list_to_keys(concepts: Tuple[Concept, ...]) -> Tuple[Concept, ...]:
 
 
 def constant_to_concept(
-    parent: ListWrapper | list | int | float | str,
+    parent: ListWrapper | MapWrapper | list | int | float | str,
     name: str,
     namespace: str,
     purpose: Purpose | None = None,
@@ -53,6 +54,7 @@ def constant_to_concept(
         output_purpose=Purpose.CONSTANT,
         arguments=[parent],
     )
+    assert const_function.arguments[0] == parent, const_function.arguments[0]
     fmetadata = metadata or Metadata()
     return Concept(
         name=name,
@@ -186,6 +188,7 @@ def arbitrary_to_concept(
         | FilterItem
         | Function
         | ListWrapper
+        | MapWrapper
         | int
         | float
         | str
@@ -195,6 +198,7 @@ def arbitrary_to_concept(
     metadata: Metadata | None = None,
     purpose: Purpose | None = None,
 ) -> Concept:
+
     if isinstance(parent, AggregateWrapper):
         return agg_wrapper_to_concept(parent, namespace, name, metadata, purpose)
     elif isinstance(parent, WindowItem):

trilogy/parsing/parse_engine.py

@@ -43,6 +43,7 @@ from trilogy.core.functions import (
     Min,
     Split,
     IndexAccess,
+    MapAccess,
     AttrAccess,
     Abs,
     Unnest,
@@ -94,6 +95,7 @@ from trilogy.core.models import (
     RawColumnExpr,
     arg_to_datatype,
     ListWrapper,
+    MapWrapper,
     MapType,
     ShowStatement,
     DataType,
@@ -104,6 +106,7 @@ from trilogy.core.models import (
     RowsetDerivationStatement,
     LooseConceptList,
     list_to_wrapper,
+    dict_to_map_wrapper,
     NumericType,
 )
 from trilogy.parsing.exceptions import ParseError
@@ -117,7 +120,7 @@ from trilogy.parsing.common import (
     arbitrary_to_concept,
 )
 
-CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper)
+CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper, MapWrapper)
 
 with open(join(dirname(__file__), "trilogy.lark"), "r") as f:
     PARSER = Lark(
@@ -253,7 +256,7 @@ class ParseToObjects(Transformer):
                 self.environment.add_concept(concept, meta=meta)
                 final.append(concept)
             elif isinstance(
-                arg, (FilterItem, WindowItem, AggregateWrapper, ListWrapper)
+                arg, (FilterItem, WindowItem, AggregateWrapper, ListWrapper, MapWrapper)
             ):
                 id_hash = string_to_hash(str(arg))
                 concept = arbitrary_to_concept(
@@ -330,7 +333,12 @@ class ParseToObjects(Transformer):
     def numeric_type(self, args) -> NumericType:
         return NumericType(precision=args[0], scale=args[1])
 
-    def data_type(self, args) -> DataType | ListType | StructType | NumericType:
+    def map_type(self, args) -> MapType:
+        return MapType(key_type=args[0], value_type=args[1])
+
+    def data_type(
+        self, args
+    ) -> DataType | ListType | StructType | MapType | NumericType:
         resolved = args[0]
         if isinstance(resolved, StructType):
             return resolved
@@ -338,6 +346,8 @@ class ParseToObjects(Transformer):
             return resolved
         elif isinstance(resolved, NumericType):
             return resolved
+        elif isinstance(resolved, MapType):
+            return resolved
         return DataType(args[0].lower())
 
     def array_comparison(self, args) -> ComparisonOperator:
@@ -491,7 +501,52 @@ class ParseToObjects(Transformer):
         while isinstance(source_value, Parenthetical):
             source_value = source_value.content
 
-        if isinstance(
+        if (
+            isinstance(source_value, Function)
+            and source_value.operator == FunctionType.STRUCT
+        ):
+            concept = arbitrary_to_concept(
+                source_value,
+                name=name,
+                namespace=namespace,
+                purpose=purpose,
+                metadata=metadata,
+            )
+
+            if concept.metadata:
+                concept.metadata.line_number = meta.line
+            self.environment.add_concept(concept, meta=meta)
+            assert isinstance(concept.datatype, StructType)
+            for key, value in concept.datatype.fields_map.items():
+                args = self.process_function_args([concept, key], meta=meta)
+                self.environment.add_concept(
+                    Concept(
+                        name=key,
+                        datatype=arg_to_datatype(value),
+                        purpose=Purpose.PROPERTY,
+                        namespace=self.environment.namespace + "." + name,
+                        lineage=AttrAccess(args),
+                    )
+                )
+            return ConceptDerivation(concept=concept)
+        elif (
+            isinstance(source_value, Function)
+            and source_value.operator == FunctionType.ALIAS
+        ):
+            concept = arbitrary_to_concept(
+                source_value,
+                name=name,
+                namespace=namespace,
+                purpose=purpose,
+                metadata=metadata,
+            )
+
+            if concept.metadata:
+                concept.metadata.line_number = meta.line
+            self.environment.add_concept(concept, meta=meta)
+            return ConceptDerivation(concept=concept)
+
+        elif isinstance(
             source_value, (FilterItem, WindowItem, AggregateWrapper, Function)
         ):
             concept = arbitrary_to_concept(
@@ -506,6 +561,7 @@ class ParseToObjects(Transformer):
                 concept.metadata.line_number = meta.line
             self.environment.add_concept(concept, meta=meta)
             return ConceptDerivation(concept=concept)
+
         elif isinstance(source_value, CONSTANT_TYPES):
             concept = constant_to_concept(
                 source_value,
@@ -549,7 +605,7 @@ class ParseToObjects(Transformer):
         else:
             metadata = None
         name = args[1]
-        constant: Union[str, float, int, bool] = args[2]
+        constant: Union[str, float, int, bool, MapWrapper, ListWrapper] = args[2]
         lookup, namespace, name, parent = parse_concept_reference(
             name, self.environment
         )
@@ -941,7 +997,15 @@ class ParseToObjects(Transformer):
                     isinstance(orderitem.expr, Concept)
                     and orderitem.expr.purpose == Purpose.METRIC
                 ):
-                    orderitem.expr = orderitem.expr.with_grain(output.grain)
+                    orderitem.expr = orderitem.expr.with_select_context(
+                        output.grain,
+                        conditional=(
+                            output.where_clause.conditional
+                            if output.where_clause
+                            and output.where_clause_category == SelectFiltering.IMPLICIT
+                            else None
+                        ),
+                    )
         return output
 
     @v_args(meta=True)
@@ -1007,6 +1071,23 @@ class ParseToObjects(Transformer):
     def array_lit(self, args):
         return list_to_wrapper(args)
 
+    def struct_lit(self, args):
+
+        zipped = dict(zip(args[::2], args[1::2]))
+        types = [arg_to_datatype(x) for x in args[1::2]]
+        return Function(
+            operator=FunctionType.STRUCT,
+            output_datatype=StructType(fields=types, fields_map=zipped),
+            output_purpose=function_args_to_output_purpose(args),
+            arguments=args,
+            arg_count=-1,
+        )
+
+    def map_lit(self, args):
+        parsed = dict(zip(args[::2], args[1::2]))
+        wrapped = dict_to_map_wrapper(parsed)
+        return wrapped
+
     def literal(self, args):
         return args[0]
 
@@ -1144,8 +1225,15 @@ class ParseToObjects(Transformer):
     @v_args(meta=True)
     def index_access(self, meta, args):
         args = self.process_function_args(args, meta=meta)
+        if args[0].datatype == DataType.MAP or isinstance(args[0].datatype, MapType):
+            return MapAccess(args)
         return IndexAccess(args)
 
+    @v_args(meta=True)
+    def map_key_access(self, meta, args):
+        args = self.process_function_args(args, meta=meta)
+        return MapAccess(args)
+
     @v_args(meta=True)
     def attr_access(self, meta, args):
         args = self.process_function_args(args, meta=meta)

trilogy/parsing/trilogy.lark

@@ -153,9 +153,10 @@
     unnest: _UNNEST expr ")"
     //indexing into an expression is a function
     index_access: expr "[" int_lit "]"
-    attr_access: expr  "[" _string_lit "]"
+    map_key_access: expr "[" _string_lit "]"
+    attr_access: expr  "." _string_lit 
 
-    expr:  _constant_functions | window_item | filter_item | subselect_comparison | between_comparison |  fgroup |  aggregate_functions | unnest | _static_functions |  literal |  concept_lit  | index_access | attr_access | parenthetical | expr_tuple | comparison |  alt_like 
+    expr:  _constant_functions | window_item | filter_item | subselect_comparison | between_comparison |  fgroup |  aggregate_functions | unnest | _static_functions |  literal |  concept_lit  | index_access |  map_key_access | attr_access | parenthetical | expr_tuple | comparison |  alt_like 
     
     // functions
     
@@ -274,12 +275,17 @@
     float_lit: /[0-9]*\.[0-9]+/
 
     array_lit: "[" (literal ",")* literal ","? "]"()
+
+    map_lit: "{" (literal ":" literal ",")* literal ":" literal ","? "}"
+
+   
+    struct_lit: "struct" "(" (IDENTIFIER "=" literal ",")* IDENTIFIER "=" literal ","? ")"
     
     !bool_lit: "True"i | "False"i
 
     !null_lit.1: "null"i
     
-    literal: null_lit | _string_lit | int_lit | float_lit | bool_lit | array_lit
+    literal: null_lit | _string_lit | int_lit | float_lit | bool_lit | array_lit | map_lit | struct_lit
 
     MODIFIER: "Optional"i | "Partial"i | "Nullable"i
 
@@ -291,8 +297,9 @@
 
     numeric_type: "numeric"i "(" int_lit "," int_lit ")"
 
+    map_type: "map"i "<" data_type "," data_type ">"
 
-    !data_type: "string"i | "number"i | "numeric"i | "map"i | "list"i | "array"i | "any"i | "int"i | "bigint"i | "date"i | "datetime"i | "timestamp"i | "float"i | "bool"i | numeric_type | struct_type | list_type
+    !data_type: "string"i | "number"i | "numeric"i | "map"i | "list"i | "array"i | "any"i | "int"i | "bigint"i | "date"i | "datetime"i | "timestamp"i | "float"i | "bool"i | numeric_type | map_type | struct_type | list_type
     
     PURPOSE:  "key"i | "metric"i  | CONST
     PROPERTY: "property"i