datajunction-server 0.0.1a49.dev0__tar.gz → 0.0.1a49.dev2__tar.gz

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datajunction-server
-Version: 0.0.1a49.dev0
+Version: 0.0.1a49.dev2
 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.1a49.dev2/datajunction_server/__about__.py

@@ -0,0 +1,4 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a49.dev2"

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/api/data.py

@@ -260,7 +260,7 @@ async def get_data_stream_for_node(  # pylint: disable=R0914, R0913
     query, query_request = await get_node_sql(
         node_name,
         dimensions,
-        filters,
+        [filter_ for filter_ in filters if filter_],
         orderby,
         limit,
         session=session,

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/api/dimensions.py

@@ -17,9 +17,10 @@ from datajunction_server.internal.access.authorization import (
     validate_access_requests,
 )
 from datajunction_server.models import access
-from datajunction_server.models.node import NodeRevisionOutput
+from datajunction_server.models.node import NodeIndegreeOutput, NodeRevisionOutput
 from datajunction_server.models.node_type import NodeType
 from datajunction_server.sql.dag import (
+    get_dimension_dag_indegree,
     get_nodes_with_common_dimensions,
     get_nodes_with_dimension,
 )
@@ -30,7 +31,7 @@ _logger = logging.getLogger(__name__)
 router = SecureAPIRouter(tags=["dimensions"])
 
 
-@router.get("/dimensions/", response_model=List[str])
+@router.get("/dimensions/", response_model=List[NodeIndegreeOutput])
 async def list_dimensions(
     prefix: Optional[str] = None,
     *,
@@ -39,17 +40,27 @@ async def list_dimensions(
     validate_access: access.ValidateAccessFn = Depends(  # pylint: disable=W0621
         validate_access,
     ),
-) -> List[str]:
+) -> List[NodeIndegreeOutput]:
     """
     List all available dimensions.
     """
-    return await list_nodes(
+    node_names = await list_nodes(
         node_type=NodeType.DIMENSION,
         prefix=prefix,
         session=session,
         current_user=current_user,
         validate_access=validate_access,
     )
+    node_indegrees = {}
+    for node in node_names:
+        node_indegrees[node] = await get_dimension_dag_indegree(session, node)
+    return sorted(
+        [
+            NodeIndegreeOutput(name=node, indegree=node_indegrees[node])
+            for node in node_names
+        ],
+        key=lambda n: -n.indegree,
+    )
 
 
 @router.get("/dimensions/{name}/nodes/", response_model=List[NodeRevisionOutput])

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/construction/build.py

@@ -384,7 +384,7 @@ async def join_tables_for_dimensions(
 
 def build_filters(
     node: NodeRevision,
-    node_table: Optional[ast.Table],
+    node_table: Optional[ast.TableExpression],
     filters: Optional[List[str]],
 ) -> List[ast.Expression]:
     """
@@ -410,7 +410,7 @@ def build_filters(
             for dim in referenced_dimensions:
                 col_name = dimensions_to_columns_map[dim.identifier()].alias_or_name
                 dim.name = ast.Name(name=col_name)
-                if node_table:
+                if node_table:  # pragma: no cover
                     dim.add_table(node_table)
             filter_asts.append(
                 temp_select.where,  # type: ignore
@@ -435,8 +435,6 @@ async def _build_tables_on_select(
 
     for node, tbls in tables.items():
         await session.refresh(node, ["dimension_links"])
-        # Save any existing filters on the query
-        filter_asts = [select.where] if select.where else []
 
         # Try to find a physical table attached to this node, if one exists.
         physical_table = cast(
@@ -465,31 +463,51 @@ async def _build_tables_on_select(
             node_ast = ast.Alias(ast.Name(alias), child=query_ast.select, as_=True)  # type: ignore
             query_ast.select.parenthesized = True  # type: ignore
 
-            filter_asts.extend(build_filters(node, node_ast, filters))  # type: ignore
+            filter_asts = build_filters(node, node_ast, filters)  # type: ignore
         else:
             alias = amenable_name(node.name)
             node_ast = ast.Alias(ast.Name(alias), child=physical_table, as_=True)  # type: ignore
-            filter_asts.extend(build_filters(node, physical_table, filters))
-
-        if filter_asts:
-            print("filter_asts", node.name, filter_asts, select)
-            select.where = ast.BinaryOp.And(*filter_asts)
-            await select.compile(context)
+            filter_asts = build_filters(node, physical_table, filters)
 
         for tbl in tbls:
-            print("node_ast", type(node_ast), node_ast)
             if isinstance(node_ast.child, ast.Select) and isinstance(tbl, ast.Alias):  # type: ignore
                 node_ast.child.projection = [
                     col
                     for col in node_ast.child.projection
                     if col in set(tbl.child.select.projection)
                 ]
+            if (
+                isinstance(node_ast.child, ast.Table)
+                and isinstance(tbl, ast.Aliasable)
+                and hasattr(tbl, "alias")
+                and tbl.alias
+            ):
+                node_ast.alias.name = tbl.alias
+
             await node_ast.compile(context)
+
+            # This will push down the filter expression to CTEs, subqueries, and top-level queries.
+            # Each `tbl` is a TableExpression that references the node in question, where the
+            # provided filters might apply. We find the table reference's nearest parent SELECT
+            # clause and populate its WHERE clause with the filters.
+            if filter_asts:
+                if nearest_select := tbl.get_nearest_parent_of_type(
+                    ast.Select,
+                ):  # pragma: no cover
+                    if nearest_select.where:
+                        filter_asts.append(nearest_select.where)
+                    nearest_select.where = (
+                        ast.BinaryOp.And(  # pylint: disable=no-value-for-parameter
+                            *filter_asts
+                        )
+                    )
+
             select.replace(
                 tbl,
                 node_ast,
                 copy=False,
             )
+        await select.compile(context)
         for col in select.find_all(ast.Column):
             if (
                 col._table

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/database/dimensionlink.py

@@ -1,9 +1,10 @@
 """Dimension links table."""
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
-from sqlalchemy import JSON, BigInteger, Enum, ForeignKey, Integer
+from sqlalchemy import JSON, BigInteger, Enum, ForeignKey, Integer, select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.hybrid import hybrid_property
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.orm import Mapped, joinedload, mapped_column, relationship
 
 from datajunction_server.database.base import Base
 from datajunction_server.database.node import Node, NodeRevision
@@ -142,3 +143,21 @@ class DimensionLink(Base):  # pylint: disable=too-few-public-methods
             right.identifier(): left.identifier()
             for left, right in self.foreign_key_mapping().items()
         }
+
+    @classmethod
+    async def get_links_for_dimension_id(
+        cls,
+        session: AsyncSession,
+        dimension_id: int,
+    ) -> List["DimensionLink"]:
+        """
+        Get dimension links by dimension node id
+        """
+        statement = (
+            select(cls)
+            .where(cls.dimension_id == dimension_id)
+            .options(joinedload(DimensionLink.node_revision))
+        )
+        result = await session.execute(statement)
+        links = result.unique().scalars().all()
+        return links

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/database/node.py

@@ -218,7 +218,6 @@ class Node(Base):  # pylint: disable=too-few-public-methods
         secondary="tagnoderelationship",
         primaryjoin="TagNodeRelationship.node_id==Node.id",
         secondaryjoin="TagNodeRelationship.tag_id==Tag.id",
-        # lazy="selectin",
     )
 
     missing_table: Mapped[bool] = mapped_column(sa.Boolean, default=False)
@@ -335,7 +334,7 @@ class Node(Base):  # pylint: disable=too-few-public-methods
         )  # pragma: no cover
         result = await session.execute(statement)  # pragma: no cover
         node = result.unique().scalar_one_or_none()  # pragma: no cover
-        return node
+        return node  # pragma: no cover
 
     @classmethod
     async def find(

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/internal/nodes.py

@@ -1538,26 +1538,31 @@ async def remove_dimension_link(
     removed = False
 
     # Find cubes that are affected by this dimension link removal and update their statuses
-    affected_cubes = (
-        await get_nodes_with_dimension(
-            session,
-            dimension_node,
-            [NodeType.CUBE],
-        )
-        or []
+    downstream_cubes = await get_downstream_nodes(
+        session,
+        node_name,
+        node_type=NodeType.CUBE,
     )
-    for cube in affected_cubes:
-        if cube.status != NodeStatus.INVALID:  # pragma: no cover
-            cube.status = NodeStatus.INVALID
+    for cube in downstream_cubes:
+        for elem in cube.current.cube_elements:
+            await session.refresh(elem, ["node_revisions"])
+        cube_dimension_nodes = [
+            cube_elem_node.name
+            for (element, cube_elem_node) in cube.current.cube_elements_with_nodes()
+            if cube_elem_node.type == NodeType.DIMENSION
+        ]
+        if dimension_node.name in cube_dimension_nodes:
+            cube.current.status = NodeStatus.INVALID
             session.add(cube)
             session.add(
                 status_change_history(
-                    node,  # type: ignore
+                    cube.current,  # type: ignore
                     NodeStatus.VALID,
                     NodeStatus.INVALID,
                     current_user=current_user,
                 ),
             )
+        await session.commit()
 
     # Delete the dimension link if one exists
     for link in node.current.dimension_links:  # type: ignore

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/models/node.py

@@ -941,3 +941,12 @@ class NamespaceOutput(BaseModel):
 
     namespace: str
     num_nodes: int
+
+
+class NodeIndegreeOutput(BaseModel):
+    """
+    Node indegree output
+    """
+
+    name: str
+    indegree: int

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/datajunction_server/sql/dag.py

@@ -720,3 +720,20 @@ def topological_sort(nodes: List[Node]) -> List[Node]:
         raise DJException("Graph has at least one cycle")
 
     return sorted_nodes[::-1]
+
+
+async def get_dimension_dag_indegree(session, node_name: str):
+    """
+    For a given node, calculate the indegrees for its dimensions graph by finding the number
+    of dimension links that reference this node. Non-dimension nodes will always have an
+    indegree of 0.
+    """
+    node = await Node.get_by_name(session, node_name, raise_if_not_exists=True)
+    dimension_dag_indegree = 0
+    if node.type == NodeType.DIMENSION:  # type: ignore
+        links = await DimensionLink.get_links_for_dimension_id(
+            session,
+            dimension_id=node.id,  # type: ignore
+        )
+        dimension_dag_indegree = len({link.node_revision.name for link in links})
+    return dimension_dag_indegree

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/tests/api/cubes_test.py

@@ -13,7 +13,7 @@ from httpx import AsyncClient
 from datajunction_server.models.query import ColumnMetadata
 from datajunction_server.service_clients import QueryServiceClient
 from datajunction_server.sql.parsing.backends.antlr4 import parse
-from tests.sql.utils import compare_query_strings
+from tests.sql.utils import assert_query_strings_equal, compare_query_strings
 
 
 async def set_temporal_partition_cube(client: AsyncClient):
@@ -626,21 +626,21 @@ async def test_create_cube(
         avg(default_DOT_repair_orders_fact.price) default_DOT_avg_repair_price,
         sum(default_DOT_repair_orders_fact.total_repair_cost) default_DOT_total_repair_cost,
         sum(default_DOT_repair_orders_fact.price * default_DOT_repair_orders_fact.discount) default_DOT_total_repair_order_discounts
-     FROM (SELECT  default_DOT_repair_orders.repair_order_id,
-        default_DOT_repair_orders.municipality_id,
-        default_DOT_repair_orders.hard_hat_id,
-        default_DOT_repair_orders.dispatcher_id,
-        default_DOT_repair_orders.order_date,
-        default_DOT_repair_orders.dispatched_date,
-        default_DOT_repair_orders.required_date,
-        default_DOT_repair_order_details.discount,
-        default_DOT_repair_order_details.price,
-        default_DOT_repair_order_details.quantity,
-        default_DOT_repair_order_details.repair_type_id,
-        default_DOT_repair_order_details.price * default_DOT_repair_order_details.quantity AS total_repair_cost,
-        default_DOT_repair_orders.dispatched_date - default_DOT_repair_orders.order_date AS time_to_dispatch,
-        default_DOT_repair_orders.dispatched_date - default_DOT_repair_orders.required_date AS dispatch_delay
-     FROM roads.repair_orders AS default_DOT_repair_orders JOIN roads.repair_order_details AS default_DOT_repair_order_details ON default_DOT_repair_orders.repair_order_id = default_DOT_repair_order_details.repair_order_id)
+     FROM (SELECT  repair_orders.repair_order_id,
+        repair_orders.municipality_id,
+        repair_orders.hard_hat_id,
+        repair_orders.dispatcher_id,
+        repair_orders.order_date,
+        repair_orders.dispatched_date,
+        repair_orders.required_date,
+        repair_order_details.discount,
+        repair_order_details.price,
+        repair_order_details.quantity,
+        repair_order_details.repair_type_id,
+        repair_order_details.price * repair_order_details.quantity AS total_repair_cost,
+        repair_orders.dispatched_date - repair_orders.order_date AS time_to_dispatch,
+        repair_orders.dispatched_date - repair_orders.required_date AS dispatch_delay
+     FROM roads.repair_orders AS repair_orders JOIN roads.repair_order_details AS repair_order_details ON repair_orders.repair_order_id = repair_order_details.repair_order_id)
      AS default_DOT_repair_orders_fact LEFT JOIN (SELECT  default_DOT_dispatchers.dispatcher_id,
         default_DOT_dispatchers.company_name
      FROM roads.dispatchers AS default_DOT_dispatchers)
@@ -653,10 +653,10 @@ async def test_create_cube(
         default_DOT_hard_hats.country
      FROM roads.hard_hats AS default_DOT_hard_hats)
      AS default_DOT_hard_hat ON default_DOT_repair_orders_fact.hard_hat_id = default_DOT_hard_hat.hard_hat_id
-    LEFT JOIN (SELECT  default_DOT_municipality.municipality_id AS municipality_id,
-        default_DOT_municipality.local_region
-     FROM roads.municipality AS default_DOT_municipality LEFT  JOIN roads.municipality_municipality_type AS default_DOT_municipality_municipality_type ON default_DOT_municipality.municipality_id = default_DOT_municipality_municipality_type.municipality_id
-    LEFT JOIN roads.municipality_type AS default_DOT_municipality_type ON default_DOT_municipality_municipality_type.municipality_type_id = default_DOT_municipality_type.municipality_type_desc)
+    LEFT JOIN (SELECT  m.municipality_id AS municipality_id,
+        m.local_region
+    FROM roads.municipality AS m LEFT JOIN roads.municipality_municipality_type AS mmt ON m.municipality_id = mmt.municipality_id
+    LEFT JOIN roads.municipality_type AS mt ON mmt.municipality_type_id = mt.municipality_type_desc)
      AS default_DOT_municipality_dim ON default_DOT_repair_orders_fact.municipality_id = default_DOT_municipality_dim.municipality_id
      WHERE  default_DOT_hard_hat.state = 'AZ'
      GROUP BY  default_DOT_hard_hat.country, default_DOT_hard_hat.postal_code, default_DOT_hard_hat.city, default_DOT_hard_hat.hire_date, default_DOT_hard_hat.state, default_DOT_dispatcher.company_name, default_DOT_municipality_dim.local_region
@@ -687,10 +687,10 @@ async def test_create_cube(
         default_DOT_hard_hats.country
      FROM roads.hard_hats AS default_DOT_hard_hats)
      AS default_DOT_hard_hat ON default_DOT_repair_order.hard_hat_id = default_DOT_hard_hat.hard_hat_id
-    LEFT JOIN (SELECT  default_DOT_municipality.municipality_id AS municipality_id,
-        default_DOT_municipality.local_region
-     FROM roads.municipality AS default_DOT_municipality LEFT  JOIN roads.municipality_municipality_type AS default_DOT_municipality_municipality_type ON default_DOT_municipality.municipality_id = default_DOT_municipality_municipality_type.municipality_id
-    LEFT JOIN roads.municipality_type AS default_DOT_municipality_type ON default_DOT_municipality_municipality_type.municipality_type_id = default_DOT_municipality_type.municipality_type_desc)
+    LEFT JOIN (SELECT  m.municipality_id AS municipality_id,
+        m.local_region
+    FROM roads.municipality AS m LEFT JOIN roads.municipality_municipality_type AS mmt ON m.municipality_id = mmt.municipality_id
+    LEFT JOIN roads.municipality_type AS mt ON mmt.municipality_type_id = mt.municipality_type_desc)
      AS default_DOT_municipality_dim ON default_DOT_repair_order.municipality_id = default_DOT_municipality_dim.municipality_id
      WHERE  default_DOT_hard_hat.state = 'AZ'
      GROUP BY  default_DOT_hard_hat.country, default_DOT_hard_hat.postal_code, default_DOT_hard_hat.city, default_DOT_hard_hat.hire_date, default_DOT_hard_hat.state, default_DOT_dispatcher.company_name, default_DOT_municipality_dim.local_region
@@ -724,7 +724,7 @@ async def test_create_cube(
         = default_DOT_repair_order_details.default_DOT_dispatcher_DOT_company_name
         AND default_DOT_repair_orders_fact.default_DOT_municipality_dim_DOT_local_region
         = default_DOT_repair_order_details.default_DOT_municipality_dim_DOT_local_region"""
-    assert str(parse(str(expected_query))) == str(parse(str(results["sql"])))
+    assert_query_strings_equal(results["sql"], expected_query)
 
 
 @pytest.mark.asyncio
@@ -754,21 +754,21 @@ default_DOT_repair_orders_fact AS (SELECT  default_DOT_repair_orders_fact.repair
     default_DOT_hard_hat.state default_DOT_hard_hat_DOT_state,
     default_DOT_dispatcher.company_name default_DOT_dispatcher_DOT_company_name,
     default_DOT_municipality_dim.local_region default_DOT_municipality_dim_DOT_local_region
- FROM (SELECT  default_DOT_repair_orders.repair_order_id,
-    default_DOT_repair_orders.municipality_id,
-    default_DOT_repair_orders.hard_hat_id,
-    default_DOT_repair_orders.dispatcher_id,
-    default_DOT_repair_orders.order_date,
-    default_DOT_repair_orders.dispatched_date,
-    default_DOT_repair_orders.required_date,
-    default_DOT_repair_order_details.discount,
-    default_DOT_repair_order_details.price,
-    default_DOT_repair_order_details.quantity,
-    default_DOT_repair_order_details.repair_type_id,
-    default_DOT_repair_order_details.price * default_DOT_repair_order_details.quantity AS total_repair_cost,
-    default_DOT_repair_orders.dispatched_date - default_DOT_repair_orders.order_date AS time_to_dispatch,
-    default_DOT_repair_orders.dispatched_date - default_DOT_repair_orders.required_date AS dispatch_delay
- FROM roads.repair_orders AS default_DOT_repair_orders JOIN roads.repair_order_details AS default_DOT_repair_order_details ON default_DOT_repair_orders.repair_order_id = default_DOT_repair_order_details.repair_order_id)
+ FROM (SELECT  repair_orders.repair_order_id,
+    repair_orders.municipality_id,
+    repair_orders.hard_hat_id,
+    repair_orders.dispatcher_id,
+    repair_orders.order_date,
+    repair_orders.dispatched_date,
+    repair_orders.required_date,
+    repair_order_details.discount,
+    repair_order_details.price,
+    repair_order_details.quantity,
+    repair_order_details.repair_type_id,
+    repair_order_details.price * repair_order_details.quantity AS total_repair_cost,
+    repair_orders.dispatched_date - repair_orders.order_date AS time_to_dispatch,
+    repair_orders.dispatched_date - repair_orders.required_date AS dispatch_delay
+ FROM roads.repair_orders AS repair_orders JOIN roads.repair_order_details AS repair_order_details ON repair_orders.repair_order_id = repair_order_details.repair_order_id)
  AS default_DOT_repair_orders_fact LEFT JOIN (SELECT  default_DOT_dispatchers.dispatcher_id,
     default_DOT_dispatchers.company_name
  FROM roads.dispatchers AS default_DOT_dispatchers)
@@ -781,13 +781,11 @@ LEFT JOIN (SELECT  default_DOT_hard_hats.hard_hat_id,
     default_DOT_hard_hats.country
  FROM roads.hard_hats AS default_DOT_hard_hats)
  AS default_DOT_hard_hat ON default_DOT_repair_orders_fact.hard_hat_id = default_DOT_hard_hat.hard_hat_id
-LEFT JOIN (SELECT  default_DOT_municipality.municipality_id AS municipality_id,
-    default_DOT_municipality.local_region
- FROM roads.municipality AS default_DOT_municipality LEFT JOIN roads.municipality_municipality_type AS default_DOT_municipality_municipality_type ON default_DOT_municipality.municipality_id = default_DOT_municipality_municipality_type.municipality_id
-LEFT JOIN roads.municipality_type AS default_DOT_municipality_type ON default_DOT_municipality_municipality_type.municipality_type_id = default_DOT_municipality_type.municipality_type_desc)
- AS default_DOT_municipality_dim ON default_DOT_repair_orders_fact.municipality_id = default_DOT_municipality_dim.municipality_id
-
-),
+LEFT JOIN (SELECT  m.municipality_id AS municipality_id,
+    m.local_region
+ FROM roads.municipality AS m LEFT JOIN roads.municipality_municipality_type AS mmt ON m.municipality_id = mmt.municipality_id
+LEFT JOIN roads.municipality_type AS mt ON mmt.municipality_type_id = mt.municipality_type_desc)
+ AS default_DOT_municipality_dim ON default_DOT_repair_orders_fact.municipality_id = default_DOT_municipality_dim.municipality_id),
 default_DOT_repair_order_details AS (SELECT  default_DOT_repair_order_details.price default_DOT_repair_order_details_DOT_price,
     default_DOT_hard_hat.country default_DOT_hard_hat_DOT_country,
     default_DOT_hard_hat.postal_code default_DOT_hard_hat_DOT_postal_code,
@@ -814,12 +812,11 @@ LEFT JOIN (SELECT  default_DOT_hard_hats.hard_hat_id,
     default_DOT_hard_hats.country
  FROM roads.hard_hats AS default_DOT_hard_hats)
  AS default_DOT_hard_hat ON default_DOT_repair_order.hard_hat_id = default_DOT_hard_hat.hard_hat_id
-LEFT JOIN (SELECT  default_DOT_municipality.municipality_id AS municipality_id,
-    default_DOT_municipality.local_region
- FROM roads.municipality AS default_DOT_municipality LEFT JOIN roads.municipality_municipality_type AS default_DOT_municipality_municipality_type ON default_DOT_municipality.municipality_id = default_DOT_municipality_municipality_type.municipality_id
-LEFT JOIN roads.municipality_type AS default_DOT_municipality_type ON default_DOT_municipality_municipality_type.municipality_type_id = default_DOT_municipality_type.municipality_type_desc)
- AS default_DOT_municipality_dim ON default_DOT_repair_order.municipality_id = default_DOT_municipality_dim.municipality_id
-)
+LEFT JOIN (SELECT  m.municipality_id AS municipality_id,
+    m.local_region
+ FROM roads.municipality AS m LEFT JOIN roads.municipality_municipality_type AS mmt ON m.municipality_id = mmt.municipality_id
+LEFT JOIN roads.municipality_type AS mt ON mmt.municipality_type_id = mt.municipality_type_desc)
+ AS default_DOT_municipality_dim ON default_DOT_repair_order.municipality_id = default_DOT_municipality_dim.municipality_id)
 SELECT  default_DOT_repair_orders_fact.default_DOT_repair_orders_fact_DOT_repair_order_id,
     default_DOT_repair_orders_fact.default_DOT_repair_orders_fact_DOT_discount,
     default_DOT_repair_orders_fact.default_DOT_repair_orders_fact_DOT_price,
@@ -1374,12 +1371,13 @@ GROUP BY
 
 
 @pytest.mark.asyncio
-async def test_unlink_node_column_dimension(
+async def test_remove_dimension_link_invalidate_cube(
     client_with_repairs_cube: AsyncClient,  # pylint: disable=redefined-outer-name
 ):
     """
-    When a node column link to a dimension is removed, the cube should be invalidated
+    Verify that removing a dimension link can invalidate a cube.
     """
+    # Delete an irrelevant dimension link
     response = await client_with_repairs_cube.request(
         "DELETE",
         "/nodes/default.repair_order/link/",
@@ -1392,9 +1390,46 @@ async def test_unlink_node_column_dimension(
         "message": "Dimension link default.hard_hat to node default.repair_order has "
         "been removed.",
     }
+    # The cube remains valid
     response = await client_with_repairs_cube.get("/nodes/default.repairs_cube")
     data = response.json()
-    assert data["status"] == "invalid"
+    assert data["status"] == "valid"
+
+    # Add an unaffected cube
+    await client_with_repairs_cube.post(
+        "/nodes/cube/",
+        json={
+            "metrics": ["default.num_repair_orders"],
+            "dimensions": [
+                "default.dispatcher.company_name",
+                "default.municipality_dim.local_region",
+            ],
+            "filters": ["default.dispatcher.company_name='Pothole Pete'"],
+            "description": "Cube of various metrics related to repairs",
+            "mode": "published",
+            "name": "default.repairs_cube_unaffected",
+        },
+    )
+
+    # Delete the link between default.repair_orders_fact and default.hard_hat
+    response = await client_with_repairs_cube.request(
+        "DELETE",
+        "/nodes/default.repair_orders_fact/link",
+        json={
+            "dimension_node": "default.hard_hat",
+        },
+    )
+    assert response.status_code == 201
+
+    # The cube that has default.hard_hat dimensions should be invalid
+    response = await client_with_repairs_cube.get("/nodes/default.repairs_cube")
+    assert response.json()["status"] == "invalid"
+
+    # The cube without default.hard_hat dimensions should remain valid
+    response = await client_with_repairs_cube.get(
+        "/nodes/default.repairs_cube_unaffected",
+    )
+    assert response.json()["status"] == "valid"
 
 
 @pytest.mark.asyncio

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/tests/api/data_test.py

@@ -666,31 +666,7 @@ class TestDataForNode:
                 ],
                 "row_count": 0,
                 "rows": [[25]],
-                "sql": "SELECT  count(default_DOT_repair_orders_fact.repair_order_id) "
-                "default_DOT_num_repair_orders \n"
-                " FROM (SELECT  default_DOT_repair_orders.repair_order_id,\n"
-                "\tdefault_DOT_repair_orders.municipality_id,\n"
-                "\tdefault_DOT_repair_orders.hard_hat_id,\n"
-                "\tdefault_DOT_repair_orders.dispatcher_id,\n"
-                "\tdefault_DOT_repair_orders.order_date,\n"
-                "\tdefault_DOT_repair_orders.dispatched_date,\n"
-                "\tdefault_DOT_repair_orders.required_date,\n"
-                "\tdefault_DOT_repair_order_details.discount,\n"
-                "\tdefault_DOT_repair_order_details.price,\n"
-                "\tdefault_DOT_repair_order_details.quantity,\n"
-                "\tdefault_DOT_repair_order_details.repair_type_id,\n"
-                "\tdefault_DOT_repair_order_details.price * "
-                "default_DOT_repair_order_details.quantity AS total_repair_cost,\n"
-                "\tdefault_DOT_repair_orders.dispatched_date - "
-                "default_DOT_repair_orders.order_date AS time_to_dispatch,\n"
-                "\tdefault_DOT_repair_orders.dispatched_date - "
-                "default_DOT_repair_orders.required_date AS dispatch_delay \n"
-                " FROM roads.repair_orders AS default_DOT_repair_orders JOIN "
-                "roads.repair_order_details AS default_DOT_repair_order_details ON "
-                "default_DOT_repair_orders.repair_order_id = "
-                "default_DOT_repair_order_details.repair_order_id)\n"
-                " AS default_DOT_repair_orders_fact\n"
-                "\n",
+                "sql": mock.ANY,
             },
         ]
 

{datajunction_server-0.0.1a49.dev0 → datajunction_server-0.0.1a49.dev2}/tests/api/dimensions_test.py

@@ -18,7 +18,15 @@ async def test_list_dimension(client_with_roads: AsyncClient) -> None:
     data = response.json()
 
     assert response.status_code == 200
-    assert len(data) > 5
+    assert data == [
+        {"indegree": 3, "name": "default.dispatcher"},
+        {"indegree": 2, "name": "default.repair_order"},
+        {"indegree": 2, "name": "default.hard_hat"},
+        {"indegree": 2, "name": "default.municipality_dim"},
+        {"indegree": 1, "name": "default.contractor"},
+        {"indegree": 1, "name": "default.us_state"},
+        {"indegree": 0, "name": "default.local_hard_hats"},
+    ]
 
 
 @pytest.mark.asyncio