datajunction-server 0.0.1a61.dev7__tar.gz → 0.0.1a61.dev9__tar.gz

datajunction_server-0.0.1a61.dev9/.env

@@ -0,0 +1,2 @@
+QUERY_SERVICE=http://djqs:8001
+SECRET=a-fake-secretkey

{datajunction_server-0.0.1a61.dev7 → datajunction_server-0.0.1a61.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datajunction-server
-Version: 0.0.1a61.dev7
+Version: 0.0.1a61.dev9
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: repository, https://github.com/DataJunction/dj
 Author-email: DataJunction Authors <yian.shang@gmail.com>

datajunction_server-0.0.1a61.dev9/datajunction_server/__about__.py

@@ -0,0 +1,4 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a61.dev9"

{datajunction_server-0.0.1a61.dev7 → datajunction_server-0.0.1a61.dev9}/datajunction_server/construction/build_v2.py

@@ -907,71 +907,77 @@ async def build_ast(  # pylint: disable=too-many-arguments,too-many-locals
         ctes_mapping = new_cte_mapping
 
     node_to_tables_mapping = get_dj_node_references_from_select(query.select)
-    for referenced_node, table_expressions in node_to_tables_mapping.items():
+    for referenced_node, reference_expressions in node_to_tables_mapping.items():
         await session.refresh(referenced_node, ["dimension_links"])
 
-        # Try to find a materialized table attached to this node, if one exists.
-        table_reference = cast(
-            Optional[ast.Table],
-            get_table_for_node(
-                referenced_node,
-                build_criteria=build_criteria,
-            ),
-        )
-        if not table_reference:
-            # Build a new CTE with the query AST if there is no materialized table
-            if referenced_node.name not in ctes_mapping:
-                node_query = parse(cast(str, referenced_node.query))
-                query_ast = await build_ast(  # type: ignore
-                    session,
+        for ref_expr in reference_expressions:
+
+            # Try to find a materialized table attached to this node, if one exists.
+            physical_table = cast(
+                Optional[ast.Table],
+                get_table_for_node(
                     referenced_node,
-                    node_query,
-                    filters=filters,
-                    memoized_queries=memoized_queries,
                     build_criteria=build_criteria,
-                    access_control=access_control,
-                    ctes_mapping=ctes_mapping,
-                )
-                cte_name = ast.Name(amenable_name(referenced_node.name))
-                query_ast = query_ast.to_cte(cte_name, parent_ast=query)
-                new_cte_mapping[referenced_node.name] = query_ast
-
-            reference_cte = (
-                ctes_mapping[referenced_node.name]
-                if referenced_node.name in ctes_mapping
-                else new_cte_mapping[referenced_node.name]
-            )
-            query_ast = ast.Table(  # type: ignore
-                reference_cte.alias,  # type: ignore
-                _columns=reference_cte._columns,  # pylint: disable=protected-access
-                _dj_node=referenced_node,
-            )
-        else:
-            # Otherwise use the materialized table and apply filters where possible
-            alias = amenable_name(referenced_node.name)
-            query_ast = ast.Query(
-                select=ast.Select(
-                    projection=table_reference.columns,  # type: ignore
-                    from_=ast.From(relations=[ast.Relation(table_reference)]),
                 ),
-                alias=ast.Name(alias),
             )
-            query_ast.parenthesized = True
-            apply_filters_to_node(referenced_node, query_ast, to_filter_asts(filters))
-            if not query_ast.select.where:
-                query_ast = ast.Alias(  # type: ignore
-                    ast.Name(alias),
-                    child=table_reference,
-                    as_=True,
+            if not physical_table:
+                # Build a new CTE with the query AST if there is no materialized table
+                if referenced_node.name not in ctes_mapping:
+                    node_query = parse(cast(str, referenced_node.query))
+                    query_ast = await build_ast(  # type: ignore
+                        session,
+                        referenced_node,
+                        node_query,
+                        filters=filters,
+                        memoized_queries=memoized_queries,
+                        build_criteria=build_criteria,
+                        access_control=access_control,
+                        ctes_mapping=ctes_mapping,
+                    )
+                    cte_name = ast.Name(amenable_name(referenced_node.name))
+                    query_ast = query_ast.to_cte(cte_name, parent_ast=query)
+                    if referenced_node.name not in new_cte_mapping:
+                        new_cte_mapping[referenced_node.name] = query_ast
+
+                reference_cte = (
+                    ctes_mapping[referenced_node.name]
+                    if referenced_node.name in ctes_mapping
+                    else new_cte_mapping[referenced_node.name]
                 )
+                query_ast = ast.Table(  # type: ignore
+                    reference_cte.alias,  # type: ignore
+                    _columns=reference_cte._columns,  # pylint: disable=protected-access
+                    _dj_node=referenced_node,
+                )
+            else:
+                # Otherwise use the materialized table and apply filters where possible
+                alias = amenable_name(referenced_node.name)
+                query_ast = ast.Query(
+                    select=ast.Select(
+                        projection=physical_table.columns,  # type: ignore
+                        from_=ast.From(relations=[ast.Relation(physical_table)]),
+                    ),
+                    alias=ast.Name(alias),
+                )
+                query_ast.parenthesized = True
+                apply_filters_to_node(
+                    referenced_node,
+                    query_ast,
+                    to_filter_asts(filters),
+                )
+                if not query_ast.select.where:
+                    query_ast = ast.Alias(  # type: ignore
+                        ast.Name(alias),
+                        child=physical_table,
+                        as_=True,
+                    )
 
-        for table in table_expressions:
             # If the user has set an alias for the node reference, reuse the
             # same alias for the built query
-            if table.alias and hasattr(query_ast, "alias"):
-                query_ast.alias = table.alias
+            if ref_expr.alias and hasattr(query_ast, "alias"):
+                query_ast.alias = ref_expr.alias
             query.select.replace(
-                table,
+                ref_expr,
                 query_ast,
                 copy=False,
             )
@@ -992,10 +998,8 @@ async def build_ast(  # pylint: disable=too-many-arguments,too-many-locals
         query.ctes.extend(cte.ctes)
         cte.ctes = []
         query.ctes.append(cte)
-
     query.select.add_aliases_to_unnamed_columns()
-    for k, v in new_cte_mapping.items():
-        ctes_mapping[k] = v
+    ctes_mapping.update(new_cte_mapping)
     return query