datajunction-server 0.0.1a99.dev1__tar.gz → 0.0.1a99.dev2__tar.gz

{datajunction_server-0.0.1a99.dev1 → datajunction_server-0.0.1a99.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datajunction-server
-Version: 0.0.1a99.dev1
+Version: 0.0.1a99.dev2
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: Homepage, https://datajunction.io
 Project-URL: Repository, https://github.com/DataJunction/dj

datajunction_server-0.0.1a99.dev2/datajunction_server/__about__.py

@@ -0,0 +1,5 @@
+"""
+Version for Hatch
+"""
+
+__version__ = "0.0.1a99.dev2"

{datajunction_server-0.0.1a99.dev1 → datajunction_server-0.0.1a99.dev2}/datajunction_server/api/nodes.py

@@ -108,6 +108,7 @@ from datajunction_server.sql.dag import (
     get_dimensions,
     get_dimension_attributes,
     get_downstream_nodes,
+    get_filter_only_dimensions,
     get_upstream_nodes,
 )
 from datajunction_server.sql.parsing.backends.antlr4 import parse, parse_rule
@@ -1565,7 +1566,9 @@ async def list_all_dimension_attributes(
     """
     List all available dimension attributes for the given node.
     """
-    return await get_dimension_attributes(session, name)
+    dimensions = await get_dimension_attributes(session, name)
+    filter_only_dimensions = await get_filter_only_dimensions(session, name)
+    return dimensions + filter_only_dimensions
 
 
 @router.get(

{datajunction_server-0.0.1a99.dev1 → datajunction_server-0.0.1a99.dev2}/datajunction_server/sql/dag.py

@@ -24,7 +24,7 @@ from datajunction_server.errors import DJDoesNotExistException, DJGraphCycleExce
 from datajunction_server.models.attribute import ColumnAttributes
 from datajunction_server.models.node import DimensionAttributeOutput
 from datajunction_server.models.node_type import NodeType
-from datajunction_server.utils import SEPARATOR, get_settings
+from datajunction_server.utils import SEPARATOR, get_settings, refresh_if_needed
 
 settings = get_settings()
 
@@ -227,6 +227,39 @@ async def get_upstream_nodes(
     ]
 
 
+async def build_reference_link(
+    session: AsyncSession,
+    col: Column,
+    path: list[str],
+    role: list[str] | None = None,
+) -> DimensionAttributeOutput | None:
+    """
+    Builds a reference link dimension attribute output for a column.
+    """
+    if not (col.dimension_id and col.dimension_column):
+        return None
+
+    await session.refresh(col.dimension, ["current"])
+    await session.refresh(col.dimension.current, ["columns"])
+
+    dim_cols = col.dimension.current.columns
+    if dim_col := next(
+        (dc for dc in dim_cols if dc.name == col.dimension_column),
+        None,
+    ):
+        return DimensionAttributeOutput(
+            name=f"{col.dimension.name}.{col.dimension_column}" + f"[{'->'.join(role)}]"
+            if role
+            else "",
+            node_name=col.dimension.name,
+            node_display_name=col.dimension.current.display_name,
+            properties=dim_col.attribute_names(),
+            type=str(col.type),
+            path=path,
+        )
+    return None
+
+
 async def get_dimension_attributes(
     session: AsyncSession,
     node_name: str,
@@ -236,69 +269,100 @@ async def get_dimension_attributes(
     """
     Get all dimension attributes for a given node.
     """
-    dims = await get_dimension_nodes(session, node_name, include_deactivated)
-    dimensions_map = {dim.id: dim for dim, _ in dims}
+    node = cast(
+        Node,
+        await Node.get_by_name(
+            session,
+            node_name,
+            options=[joinedload(Node.current)],
+        ),
+    )
+    if node.type == NodeType.METRIC:
+        await refresh_if_needed(session, node.current, ["parents"])
+        node = node.current.parents[0]
+        await refresh_if_needed(session, node, ["current"])
 
+    # Discover all dimension nodes in the given node's dimensions graph
+    dimension_nodes_and_paths = await get_dimension_nodes(
+        session,
+        node,
+        include_deactivated,
+    )
+    dimensions_map = {dim.id: dim for dim, _, _ in dimension_nodes_and_paths}
+
+    # Add all reference links to the list of dimension attributes
     reference_links = []
+    await refresh_if_needed(session, node.current, ["columns"])
+    for col in node.current.columns:
+        if col.dimension_id and col.dimension_column:
+            await session.refresh(col, ["dimension"])
+            if ref_link := await build_reference_link(
+                session,
+                col,
+                path=[f"{node.name}.{col.name}"],
+            ):
+                reference_links.append(ref_link)
+
     if include_reference_links:
-        for dimension_node, path in dims:
+        for dimension_node, path, role in dimension_nodes_and_paths:
             for col in dimension_node.current.columns:
-                if not (col.dimension_id and col.dimension_column):
-                    continue
-
-                await session.refresh(col.dimension, ["current"])
-                await session.refresh(col.dimension.current, ["columns"])
-
-                dim_cols = col.dimension.current.columns
-                if dim_col := next(
-                    (dc for dc in dim_cols if dc.name == col.dimension_column),
-                    None,
-                ):
-                    reference_links.append(
-                        DimensionAttributeOutput(
-                            name=f"{col.dimension.name}.{col.dimension_column}",
-                            node_name=col.dimension.name,
-                            node_display_name=col.dimension.display_name,
-                            properties=dim_col.attribute_names(),
-                            type=str(col.type),
-                            path=(
-                                [node_name] if dimension_node.name != node_name else []
-                            )
-                            + [dimensions_map[int(node_id)].name for node_id in path],
-                        ),
-                    )
-
-    return reference_links + [
+                if col.dimension_id and col.dimension_column:
+                    join_path = (
+                        [node.name] if dimension_node.name != node.name else []
+                    ) + [dimensions_map[int(node_id)].name for node_id in path]
+                    if ref_link := await build_reference_link(
+                        session,
+                        col,
+                        join_path,
+                        role,
+                    ):
+                        reference_links.append(ref_link)
+
+    # Build all dimension attributes from the dimension nodes in the graph
+    graph_dimensions = [
         DimensionAttributeOutput(
-            name=f"{dim.name}.{col.name}",
+            name=f"{dim.name}.{col.name}" + (f"[{'->'.join(role)}]" if role else ""),
             node_name=dim.name,
             node_display_name=dim.current.display_name,
             properties=col.attribute_names(),
             type=str(col.type),
             path=[node_name] + [dimensions_map[int(node_id)].name for node_id in path],
         )
-        for dim, path in dims
+        for dim, path, role in dimension_nodes_and_paths
         for col in dim.current.columns
     ]
 
+    # Build all local dimension attributes from the original node
+    local_dimensions = [
+        DimensionAttributeOutput(
+            name=f"{node.name}.{col.name}",
+            node_name=node.name,
+            node_display_name=node.current.display_name,
+            properties=col.attribute_names(),
+            type=str(col.type),
+            path=[],
+        )
+        for col in node.current.columns
+    ]
+    local_dimensions = [
+        dim
+        for dim in local_dimensions
+        if "primary_key" in (dim.properties or [])
+        or "dimension" in (dim.properties or [])
+        or node.type == NodeType.DIMENSION
+    ]
+    return reference_links + graph_dimensions + local_dimensions
+
 
 async def get_dimension_nodes(
     session: AsyncSession,
-    node_name: str,
+    node: Node,
     include_deactivated: bool = True,
-) -> list[tuple[Node, list[str]]]:
+) -> list[tuple[Node, list[str], list[str] | None]]:
     """
-    Gets all dimension nodes in the given node's dimensions graph using a recursive
-    CTE query to build out dimension links.
+    Discovers all dimension nodes in the given node's dimensions graph using a recursive
+    CTE query to build out the dimension links.
     """
-    node = cast(
-        Node,
-        await Node.get_by_name(
-            session,
-            node_name,
-            options=[joinedload(Node.current)],
-        ),
-    )
     dag = (
         (
             select(
@@ -306,6 +370,7 @@ async def get_dimension_nodes(
                 NodeRevision.id,
                 NodeRevision.node_id,
                 array([NodeRevision.node_id]).label("join_path"),  # start path
+                array([DimensionLink.role]).label("role"),
             )
             .where(DimensionLink.node_revision_id == node.current.id)
             .join(Node, DimensionLink.dimension_id == Node.id)
@@ -329,6 +394,7 @@ async def get_dimension_nodes(
             func.array_cat(dag.c.join_path, array([NodeRevision.node_id])).label(
                 "join_path",
             ),
+            func.array_cat(dag.c.role, array([DimensionLink.role])).label("role"),
         )
         .join(DimensionLink, dag.c.id == DimensionLink.node_revision_id)
         .join(Node, DimensionLink.dimension_id == Node.id)
@@ -339,7 +405,7 @@ async def get_dimension_nodes(
         ),
     )
 
-    node_selector = select(Node, paths.c.join_path)
+    node_selector = select(Node, paths.c.join_path, paths.c.role)
     if not include_deactivated:
         node_selector = node_selector.where(is_(Node.deactivated_at, None))
     statement = (
@@ -351,7 +417,10 @@ async def get_dimension_nodes(
         )
         .options(*_node_output_options())
     )
-    return [(node, path) for node, path in (await session.execute(statement)).all()]
+    return [
+        (node, path, [r for r in role if r])
+        for node, path, role in (await session.execute(statement)).all()
+    ]
 
 
 async def get_dimensions_dag(

{datajunction_server-0.0.1a99.dev1 → datajunction_server-0.0.1a99.dev2}/tests/api/dimension_links_test.py

@@ -326,13 +326,19 @@ async def test_link_complex_dimension_without_role(
     assert str(parse(query)) == str(parse(expected))
 
     response = await dimensions_link_client.get("/nodes/default.events/dimensions")
-    assert [(attr["name"], attr["path"]) for attr in response.json()] == [
-        ("default.users.account_type", ["default.events"]),
-        ("default.users.registration_country", ["default.events"]),
-        ("default.users.residence_country", ["default.events"]),
-        ("default.users.snapshot_date", ["default.events"]),
-        ("default.users.user_id", ["default.events"]),
-    ]
+    assert sorted(
+        [(attr["name"], attr["path"]) for attr in response.json()],
+        key=lambda x: x[0],
+    ) == sorted(
+        [
+            ("default.users.account_type", ["default.events", "default.users"]),
+            ("default.users.registration_country", ["default.events", "default.users"]),
+            ("default.users.residence_country", ["default.events", "default.users"]),
+            ("default.users.snapshot_date", ["default.events", "default.users"]),
+            ("default.users.user_id", ["default.events", "default.users"]),
+        ],
+        key=lambda x: x[0],
+    )
 
 
 @pytest.mark.asyncio
@@ -382,90 +388,114 @@ async def test_link_complex_dimension_with_role(
     }
 
     response = await dimensions_link_client.get("/nodes/default.events")
-    assert sorted(response.json()["dimension_links"], key=lambda x: x["role"]) == [
-        {
-            "dimension": {"name": "default.users"},
-            "join_cardinality": "one_to_one",
-            "join_sql": "default.events.user_id = default.users.user_id AND "
-            "default.events.event_start_date = default.users.snapshot_date",
-            "join_type": "left",
-            "role": "user_direct",
-            "foreign_keys": {
-                "default.events.event_start_date": "default.users.snapshot_date",
-                "default.events.user_id": "default.users.user_id",
+    assert sorted(
+        response.json()["dimension_links"],
+        key=lambda x: x["role"],
+    ) == sorted(
+        [
+            {
+                "dimension": {"name": "default.users"},
+                "join_cardinality": "one_to_one",
+                "join_sql": "default.events.user_id = default.users.user_id AND "
+                "default.events.event_start_date = default.users.snapshot_date",
+                "join_type": "left",
+                "role": "user_direct",
+                "foreign_keys": {
+                    "default.events.event_start_date": "default.users.snapshot_date",
+                    "default.events.user_id": "default.users.user_id",
+                },
             },
-        },
-        {
-            "dimension": {"name": "default.users"},
-            "join_cardinality": "one_to_many",
-            "join_sql": "default.events.user_id = default.users.user_id AND "
-            "default.events.event_start_date BETWEEN "
-            "default.users.snapshot_date AND "
-            "CAST(DATE_ADD(CAST(default.users.snapshot_date AS DATE), 10) AS "
-            "INT)",
-            "join_type": "left",
-            "role": "user_windowed",
-            "foreign_keys": {
-                "default.events.event_start_date": None,
-                "default.events.user_id": "default.users.user_id",
+            {
+                "dimension": {"name": "default.users"},
+                "join_cardinality": "one_to_many",
+                "join_sql": "default.events.user_id = default.users.user_id AND "
+                "default.events.event_start_date BETWEEN "
+                "default.users.snapshot_date AND "
+                "CAST(DATE_ADD(CAST(default.users.snapshot_date AS DATE), 10) AS "
+                "INT)",
+                "join_type": "left",
+                "role": "user_windowed",
+                "foreign_keys": {
+                    "default.events.event_start_date": None,
+                    "default.events.user_id": "default.users.user_id",
+                },
             },
-        },
-    ]
+        ],
+        key=lambda x: x["role"],  # type: ignore
+    )
 
     # Verify that the dimensions on the downstream metric have roles specified
     response = await dimensions_link_client.get(
         "/nodes/default.elapsed_secs/dimensions",
     )
-    assert [(attr["name"], attr["path"]) for attr in response.json()] == [
+    assert sorted(
+        [(attr["name"], attr["path"]) for attr in response.json()],
+        key=lambda x: x[0],
+    ) == [
         (
             "default.countries.country_code[user_direct->registration_country]",
-            ["default.events.user_direct", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
         ),
         (
             "default.countries.country_code[user_windowed->registration_country]",
-            ["default.events.user_windowed", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
         ),
         (
             "default.countries.name[user_direct->registration_country]",
-            ["default.events.user_direct", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
         ),
         (
             "default.countries.name[user_windowed->registration_country]",
-            ["default.events.user_windowed", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
         ),
         (
             "default.countries.population[user_direct->registration_country]",
-            ["default.events.user_direct", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
         ),
         (
             "default.countries.population[user_windowed->registration_country]",
-            ["default.events.user_windowed", "default.users.registration_country"],
+            ["default.elapsed_secs", "default.users", "default.countries"],
+        ),
+        (
+            "default.users.account_type[user_direct]",
+            ["default.elapsed_secs", "default.users"],
+        ),
+        (
+            "default.users.account_type[user_windowed]",
+            ["default.elapsed_secs", "default.users"],
         ),
-        ("default.users.account_type[user_direct]", ["default.events.user_direct"]),
-        ("default.users.account_type[user_windowed]", ["default.events.user_windowed"]),
         (
             "default.users.registration_country[user_direct]",
-            ["default.events.user_direct"],
+            ["default.elapsed_secs", "default.users"],
         ),
         (
             "default.users.registration_country[user_windowed]",
-            ["default.events.user_windowed"],
+            ["default.elapsed_secs", "default.users"],
         ),
         (
             "default.users.residence_country[user_direct]",
-            ["default.events.user_direct"],
+            ["default.elapsed_secs", "default.users"],
         ),
         (
             "default.users.residence_country[user_windowed]",
-            ["default.events.user_windowed"],
+            ["default.elapsed_secs", "default.users"],
+        ),
+        (
+            "default.users.snapshot_date[user_direct]",
+            ["default.elapsed_secs", "default.users"],
         ),
-        ("default.users.snapshot_date[user_direct]", ["default.events.user_direct"]),
         (
             "default.users.snapshot_date[user_windowed]",
-            ["default.events.user_windowed"],
+            ["default.elapsed_secs", "default.users"],
+        ),
+        (
+            "default.users.user_id[user_direct]",
+            ["default.elapsed_secs", "default.users"],
+        ),
+        (
+            "default.users.user_id[user_windowed]",
+            ["default.elapsed_secs", "default.users"],
         ),
-        ("default.users.user_id[user_direct]", ["default.events.user_direct"]),
-        ("default.users.user_id[user_windowed]", ["default.events.user_windowed"]),
     ]
 
     # Get SQL for the downstream metric grouped by the user dimension of role "user_windowed"
@@ -876,14 +906,16 @@ async def test_measures_sql_with_reference_dimension_links(
         "/nodes/default.elapsed_secs/dimensions",
     )
     dimensions_data = response.json()
-    assert [dim["name"] for dim in dimensions_data] == [
-        "default.users.account_type",
-        "default.users.registration_country",
-        "default.users.registration_country",
-        "default.users.residence_country",
-        "default.users.snapshot_date",
-        "default.users.user_id",
-    ]
+    assert set([dim["name"] for dim in dimensions_data]) == set(
+        [
+            "default.users.account_type",
+            "default.users.registration_country",
+            "default.users.registration_country",
+            "default.users.residence_country",
+            "default.users.snapshot_date",
+            "default.users.user_id",
+        ],
+    )
 
     sql_params = {
         "metrics": ["default.elapsed_secs"],