pytrilogy 0.0.2.1__py3-none-any.whl → 0.0.2.3__py3-none-any.whl

trilogy/core/processing/node_generators/basic_node.py

@@ -44,7 +44,7 @@ def gen_basic_node(
                         list(optional_set) + [concept],
                     )
                 )
-
+    # check for the concept by itself
     for attempt, basic_output in reversed(attempts):
         partials = []
         attempt = unique(attempt, "address")

trilogy/core/processing/node_generators/node_merge_node.py

@@ -4,7 +4,6 @@ from trilogy.core.models import Concept, Environment, Conditional
 from trilogy.core.processing.nodes import MergeNode, History, StrategyNode
 import networkx as nx
 from trilogy.core.graph_models import concept_to_node
-from trilogy.core.processing.utility import PathInfo
 from trilogy.constants import logger
 from trilogy.utility import unique
 from trilogy.core.exceptions import AmbiguousRelationshipResolutionException
@@ -63,7 +62,9 @@ def extract_ds_components(g: nx.DiGraph, nodelist: list[str]) -> list[list[str]]
                     if not str(x).startswith("ds~")
                 ]
             )
-
+    # if we had no ego graphs, return all concepts
+    if not graphs:
+        return [[extract_address(node) for node in nodelist]]
     graphs = filter_unique_graphs(graphs)
     for node in nodelist:
         parsed = extract_address(node)
@@ -82,6 +83,7 @@ def determine_induced_minimal_nodes(
     H: nx.Graph = nx.to_undirected(G).copy()
     nodes_to_remove = []
     concepts = nx.get_node_attributes(G, "concept")
+
     for node in G.nodes:
         if concepts.get(node):
             lookup = concepts[node]
@@ -107,9 +109,11 @@ def determine_induced_minimal_nodes(
         paths = nx.multi_source_dijkstra_path(H, nodelist)
     except nx.exception.NodeNotFound:
         return None
+
     H.remove_nodes_from(list(x for x in H.nodes if x not in paths))
     sG: nx.Graph = ax.steinertree.steiner_tree(H, nodelist).copy()
     final: nx.DiGraph = nx.subgraph(G, sG.nodes).copy()
+
     for edge in G.edges:
         if edge[1] in final.nodes and edge[0].startswith("ds~"):
             ds_name = extract_address(edge[0])
@@ -125,6 +129,7 @@ def determine_induced_minimal_nodes(
         [final.in_degree(node) > 0 for node in final.nodes if node.startswith("c~")]
     ):
         return None
+
     if not all([node in final.nodes for node in nodelist]):
         return None
     return final
@@ -308,111 +313,44 @@ def gen_merge_node(
     history: History | None = None,
     conditions: Conditional | None = None,
 ) -> Optional[MergeNode]:
-    join_candidates: List[PathInfo] = []
-
-    # inject new concepts into search, and identify if two dses can reach there
-    if not join_candidates:
-        for filter_downstream in [True, False]:
-            weak_resolve = resolve_weak_components(
-                all_concepts,
-                environment,
-                g,
-                filter_downstream=filter_downstream,
-                accept_partial=accept_partial,
-            )
-            if weak_resolve:
-                log_graph = [[y.address for y in x] for x in weak_resolve]
-                logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} Was able to resolve graph through weak component resolution - final graph {log_graph}"
-                )
-                return subgraphs_to_merge_node(
-                    weak_resolve,
-                    depth=depth,
-                    all_concepts=all_concepts,
-                    environment=environment,
-                    g=g,
-                    source_concepts=source_concepts,
-                    history=history,
-                    conditions=conditions,
-                )
-    if not join_candidates:
-        return None
-    join_additions: list[set[str]] = []
-    for candidate in join_candidates:
-        join_additions.append(candidate.reduced_concepts)
-
-    common: set[str] = set()
-    final_candidates: list[set[str]] = []
-    # find all values that show up in every join_additions
-    for ja in join_additions:
-        if not common:
-            common = ja
-        else:
-            common = common.intersection(ja)
-        if all(ja.issubset(y) for y in join_additions):
-            final_candidates.append(ja)
 
-    if not final_candidates:
-        filtered_paths = [x.difference(common) for x in join_additions]
-        raise AmbiguousRelationshipResolutionException(
-            f"Ambiguous concept join resolution fetching {[x.address for x in all_concepts]} - unique values in possible paths = {filtered_paths}. Include an additional concept to disambiguate",
-            join_additions,
-        )
-    if not join_candidates:
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} No additional join candidates could be found"
+    for filter_downstream in [True, False]:
+        weak_resolve = resolve_weak_components(
+            all_concepts,
+            environment,
+            g,
+            filter_downstream=filter_downstream,
+            accept_partial=accept_partial,
         )
-        return None
-    shortest: PathInfo = sorted(
-        [x for x in join_candidates if x.reduced_concepts in final_candidates],
-        key=lambda x: len(x.reduced_concepts),
-    )[0]
-    logger.info(f"{padding(depth)}{LOGGER_PREFIX} final path is {shortest.paths}")
-
-    return subgraphs_to_merge_node(
-        shortest.concept_subgraphs,
-        depth=depth,
-        all_concepts=all_concepts,
-        environment=environment,
-        g=g,
-        source_concepts=source_concepts,
-        history=history,
-        conditions=conditions,
-    )
-    # parents = []
-    # for graph in shortest.concept_subgraphs:
-    #     logger.info(
-    #         f"{padding(depth)}{LOGGER_PREFIX} fetching subgraph {[c.address for c in graph]}"
-    #     )
-    #     parent = source_concepts(
-    #         mandatory_list=graph,
-    #         environment=environment,
-    #         g=g,
-    #         depth=depth + 1,
-    #         history=history,
-    #     )
-    #     if not parent:
-    #         logger.info(
-    #             f"{padding(depth)}{LOGGER_PREFIX} Unable to instantiate target subgraph"
-    #         )
-    #         return None
-    #     logger.info(
-    #         f"{padding(depth)}{LOGGER_PREFIX} finished subgraph fetch for {[c.address for c in graph]}, have parent {type(parent)}"
-    #     )
-    #     parents.append(parent)
-
-    # return MergeNode(
-    #     input_concepts=[
-    #         environment.concepts[x]
-    #         for x in shortest.reduced_concepts
-    #         if environment.concepts[x].derivation != PurposeLineage.MERGE
-    #     ],
-    #     output_concepts=[
-    #         x for x in all_concepts if x.derivation != PurposeLineage.MERGE
-    #     ],
-    #     environment=environment,
-    #     g=g,
-    #     parents=parents,
-    #     depth=depth,
-    #     conditions=conditions,
-    # )
+        if weak_resolve:
+            log_graph = [[y.address for y in x] for x in weak_resolve]
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} Was able to resolve graph through weak component resolution - final graph {log_graph}"
+            )
+            return subgraphs_to_merge_node(
+                weak_resolve,
+                depth=depth,
+                all_concepts=all_concepts,
+                environment=environment,
+                g=g,
+                source_concepts=source_concepts,
+                history=history,
+                conditions=conditions,
+            )
+    # one concept handling may need to be kicked to alias
+    if len(all_concepts) == 1:
+        concept = all_concepts[0]
+        for k, v in concept.pseudonyms.items():
+            test = subgraphs_to_merge_node(
+                [[concept, v]],
+                g=g,
+                all_concepts=[concept],
+                environment=environment,
+                depth=depth,
+                source_concepts=source_concepts,
+                history=history,
+                conditions=conditions,
+            )
+            if test:
+                return test
+    return None

trilogy/core/processing/node_generators/select_node.py

@@ -89,6 +89,7 @@ def dm_to_strategy_node(
         accept_partial=accept_partial,
         datasource=datasource,
         grain=datasource.grain,
+        conditions=datasource.where.conditional if datasource.where else None,
     )
     # we need to nest the group node one further
     if force_group is True:
@@ -295,9 +296,6 @@ def gen_select_node_from_table(
                         g.nodes[ncandidate]
                     except KeyError:
                         raise nx.exception.NetworkXNoPath
-                        raise SyntaxError(
-                            f"Could not find node {ncandidate}, have {list(g.nodes())}"
-                        )
                 raise e
             except nx.exception.NetworkXNoPath:
                 all_found = False
@@ -372,6 +370,7 @@ def gen_select_node_from_table(
             accept_partial=accept_partial,
             datasource=datasource,
             grain=Grain(components=all_concepts),
+            conditions=datasource.where.conditional if datasource.where else None,
         )
         # we need to nest the group node one further
         if force_group is True:

trilogy/core/processing/utility.py

@@ -124,15 +124,20 @@ def resolve_join_order(joins: List[BaseJoin]) -> List[BaseJoin]:
     return final_joins
 
 
-def add_node_join_concept(graph, concept, datasource, concepts):
-    # we don't need to join on a concept if all of the keys exist in the grain
-    # if concept.keys and all([x in grain for x in concept.keys]):
-    #     continue
+def add_node_join_concept(
+    graph: nx.DiGraph,
+    concept: Concept,
+    datasource: Datasource | QueryDatasource,
+    concepts: List[Concept],
+):
+
     concepts.append(concept)
 
     graph.add_node(concept.address, type=NodeType.CONCEPT)
     graph.add_edge(datasource.identifier, concept.address)
-    for k, v in concept.pseudonyms.items():
+    for _, v in concept.pseudonyms.items():
+        if v in concepts:
+            continue
         if v.address != concept.address:
             add_node_join_concept(graph, v, datasource, concepts)
 
@@ -149,13 +154,6 @@ def get_node_joins(
         graph.add_node(datasource.identifier, type=NodeType.NODE)
         for concept in datasource.output_concepts:
             add_node_join_concept(graph, concept, datasource, concepts)
-            # we don't need to join on a concept if all of the keys exist in the grain
-            # if concept.keys and all([x in grain for x in concept.keys]):
-            #     continue
-            # concepts.append(concept)
-
-            # graph.add_node(concept.address, type=NodeType.CONCEPT)
-            # graph.add_edge(datasource.identifier, concept.address)
 
     # add edges for every constant to every datasource
     for datasource in datasources:
@@ -195,26 +193,6 @@ def get_node_joins(
         ),
     )
 
-    node_map = {
-        x[0:20]: len(
-            [
-                partial
-                for partial in identifier_map[x].partial_concepts
-                if partial in grain
-            ]
-            + [
-                output
-                for output in identifier_map[x].output_concepts
-                if output.address in grain_pseudonyms
-            ]
-        )
-        for x in node_list
-    }
-    print("NODE MAP")
-    print(node_map)
-    print([x.address for x in grain])
-    print(grain_pseudonyms)
-
     for left in node_list:
         # the constant dataset is a special case
         # and can never be on the left of a join

trilogy/core/query_processor.py

@@ -467,9 +467,11 @@ def process_query(
     for cte in raw_ctes:
         cte.parent_ctes = [seen[x.name] for x in cte.parent_ctes]
     deduped_ctes: List[CTE] = list(seen.values())
+    root_cte.order_by = statement.order_by
+    root_cte.limit = statement.limit
+    root_cte.hidden_concepts = [x for x in statement.hidden_components]
 
     final_ctes = optimize_ctes(deduped_ctes, root_cte, statement)
-
     return ProcessedQuery(
         order_by=statement.order_by,
         grain=statement.grain,

trilogy/dialect/base.py

@@ -8,7 +8,6 @@ from trilogy.core.enums import (
     FunctionType,
     WindowType,
     DatePart,
-    PurposeLineage,
     ComparisonOperator,
 )
 from trilogy.core.models import (
@@ -36,6 +35,7 @@ from trilogy.core.models import (
     Environment,
     RawColumnExpr,
     ListWrapper,
+    MapWrapper,
     ShowStatement,
     RowsetItem,
     MultiSelectStatement,
@@ -45,6 +45,7 @@ from trilogy.core.models import (
     RawSQLStatement,
     ProcessedRawSQLStatement,
     NumericType,
+    MapType,
     MergeStatementV2,
 )
 from trilogy.core.query_processor import process_query, process_persist
@@ -97,6 +98,7 @@ DATATYPE_MAP = {
     DataType.FLOAT: "float",
     DataType.BOOL: "bool",
     DataType.NUMERIC: "numeric",
+    DataType.MAP: "map",
 }
 
 
@@ -116,6 +118,7 @@ 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]})",
     # math
     FunctionType.ADD: lambda x: f"{x[0]} + {x[1]}",
@@ -189,14 +192,13 @@ 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 order_by %}
+ORDER BY{% for order in order_by %}
+\t{{ order }}{% if not loop.last %},{% endif %}{% endfor %}
 {% endif %}{% endif %}
 """
 )
@@ -214,7 +216,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 +299,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 +344,11 @@ class BaseDialect:
             Parenthetical,
             AggregateWrapper,
             MagicConstants,
+            MapWrapper[Any, Any],
+            MapType,
             NumericType,
             ListType,
-            ListWrapper[int],
-            ListWrapper[str],
-            ListWrapper[float],
+            ListWrapper[Any],
             DatePart,
             CaseWhen,
             CaseElse,
@@ -435,6 +444,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):
@@ -643,82 +654,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/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"
     ),

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

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:
@@ -490,7 +500,6 @@ class ParseToObjects(Transformer):
         # we need to strip off every parenthetical to see what is being assigned.
         while isinstance(source_value, Parenthetical):
             source_value = source_value.content
-
         if isinstance(
             source_value, (FilterItem, WindowItem, AggregateWrapper, Function)
         ):
@@ -549,7 +558,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
         )
@@ -605,6 +614,7 @@ class ParseToObjects(Transformer):
         columns: List[ColumnAssignment] = args[1]
         grain: Optional[Grain] = None
         address: Optional[Address] = None
+        where: Optional[WhereClause] = None
         for val in args[1:]:
             if isinstance(val, Address):
                 address = val
@@ -612,6 +622,8 @@ class ParseToObjects(Transformer):
                 grain = val
             elif isinstance(val, Query):
                 address = Address(location=f"({val.text})", is_query=True)
+            elif isinstance(val, WhereClause):
+                where = val
         if not address:
             raise ValueError(
                 "Malformed datasource, missing address or query declaration"
@@ -624,6 +636,7 @@ class ParseToObjects(Transformer):
             grain=grain,  # type: ignore
             address=address,
             namespace=self.environment.namespace,
+            where=where,
         )
         for column in columns:
             column.concept = column.concept.with_grain(datasource.grain)
@@ -1003,6 +1016,11 @@ class ParseToObjects(Transformer):
     def array_lit(self, args):
         return list_to_wrapper(args)
 
+    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]
 
@@ -1140,6 +1158,8 @@ 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)