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

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

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

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

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

@@ -5,7 +5,7 @@ Data related APIs.
 from http import HTTPStatus
 from typing import Annotated, Dict, List, Optional
 
-from fastapi import Depends, Header, Query, Request
+from fastapi import BackgroundTasks, Depends, Header, Query, Request
 from fastapi.responses import JSONResponse
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload, selectinload
@@ -181,6 +181,7 @@ async def get_data(  # pylint: disable=too-many-locals
     validate_access: access.ValidateAccessFn = Depends(  # pylint: disable=W0621
         validate_access,
     ),
+    background_tasks: BackgroundTasks,
 ) -> QueryWithResults:
     """
     Gets data for a node
@@ -196,6 +197,7 @@ async def get_data(  # pylint: disable=too-many-locals
         engine_version=engine_version,
         current_user=current_user,
         validate_access=validate_access,
+        background_tasks=background_tasks,
     )
     node = await Node.get_by_name(session, node_name, raise_if_not_exists=True)
     available_engines = node.current.catalog.engines  # type: ignore
@@ -250,6 +252,7 @@ async def get_data_stream_for_node(  # pylint: disable=R0914, R0913
     validate_access: access.ValidateAccessFn = Depends(  # pylint: disable=W0621
         validate_access,
     ),
+    background_tasks: BackgroundTasks,
 ) -> QueryWithResults:
     """
     Return data for a node using server side events
@@ -265,6 +268,7 @@ async def get_data_stream_for_node(  # pylint: disable=R0914, R0913
         engine_version=engine_version,
         current_user=current_user,
         validate_access=validate_access,
+        background_tasks=background_tasks,
     )
     if query_request and query_request.query_id:
         return EventSourceResponse(

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

@@ -21,6 +21,7 @@ from datajunction_server.construction.build import (
     build_materialized_cube_node,
     build_metric_nodes,
     build_node,
+    get_default_criteria,
     rename_columns,
     validate_shared_dimensions,
 )
@@ -50,10 +51,9 @@ from datajunction_server.errors import (
 from datajunction_server.internal.engines import get_engine
 from datajunction_server.models import access
 from datajunction_server.models.attribute import RESERVED_ATTRIBUTE_NAMESPACE
-from datajunction_server.models.engine import Dialect
 from datajunction_server.models.history import status_change_history
 from datajunction_server.models.metric import TranslatedSQL
-from datajunction_server.models.node import BuildCriteria, NodeStatus
+from datajunction_server.models.node import NodeStatus
 from datajunction_server.models.node_type import NodeType
 from datajunction_server.models.query import ColumnMetadata, QueryWithResults
 from datajunction_server.naming import LOOKUP_CHARS
@@ -204,19 +204,7 @@ async def get_query(  # pylint: disable=too-many-arguments
     Get a query for a metric, dimensions, and filters
     """
     node = await Node.get_by_name(session, node_name)
-
-    # Builds the node for the engine's dialect if one is set or defaults to Spark
-    if (
-        not engine
-        and node.current  # type: ignore
-        and node.current.catalog  # type: ignore
-        and node.current.catalog.engines  # type: ignore
-    ):
-        engine = node.current.catalog.engines[0]  # type: ignore
-    build_criteria = BuildCriteria(
-        dialect=(engine.dialect if engine and engine.dialect else Dialect.SPARK),
-    )
-
+    build_criteria = get_default_criteria(node.current, engine)  # type: ignore
     query_ast = await build_node(
         session=session,
         node=node.current,  # type: ignore

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

@@ -26,6 +26,7 @@ from datajunction_server.api.helpers import (
 from datajunction_server.api.namespaces import create_node_namespace
 from datajunction_server.api.tags import get_tags_by_name
 from datajunction_server.constants import NODE_LIST_MAX
+from datajunction_server.database import DimensionLink
 from datajunction_server.database.attributetype import ColumnAttribute
 from datajunction_server.database.column import Column
 from datajunction_server.database.history import ActivityType, EntityType, History
@@ -103,7 +104,7 @@ from datajunction_server.sql.dag import (
     get_downstream_nodes,
     get_upstream_nodes,
 )
-from datajunction_server.sql.parsing.backends.antlr4 import parse
+from datajunction_server.sql.parsing.backends.antlr4 import parse, parse_rule
 from datajunction_server.utils import (
     Version,
     get_current_user,
@@ -967,11 +968,10 @@ async def refresh_source_node(
     if new_columns:
         # check if any of the columns have changed (only continue with update if they have)
         column_changes = {col.identifier() for col in current_revision.columns} != {
-            col.identifier() for col in new_columns
+            (col.name, str(parse_rule(str(col.type), "dataType")))
+            for col in new_columns
         }
 
-        # FIXME: there is a bug with type translation (bigint != long) - fix it. # pylint: disable=fixme
-
         # if the columns haven't changed and the node has a table, we can skip the update
         if not column_changes:
             if not source_node.missing_table:  # type: ignore
@@ -998,6 +998,16 @@ async def refresh_source_node(
         schema_=current_revision.schema_,
         table=current_revision.table,
         status=current_revision.status,
+        dimension_links=[
+            DimensionLink(
+                dimension_id=link.dimension_id,
+                join_sql=link.join_sql,
+                join_type=link.join_type,
+                join_cardinality=link.join_cardinality,
+                materialization_conf=link.materialization_conf,
+            )
+            for link in current_revision.dimension_links
+        ],
     )
     new_revision.version = str(old_version.next_major_version())
     new_revision.columns = [

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

@@ -5,7 +5,7 @@ SQL related APIs.
 import logging
 from typing import List, Optional, Tuple
 
-from fastapi import Depends, Query
+from fastapi import BackgroundTasks, Depends, Query
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from datajunction_server.api.helpers import (
@@ -15,12 +15,14 @@ from datajunction_server.api.helpers import (
     validate_orderby,
 )
 from datajunction_server.construction.build import get_measures_query
+from datajunction_server.database import Engine
 from datajunction_server.database.queryrequest import QueryBuildType, QueryRequest
 from datajunction_server.database.user import User
 from datajunction_server.internal.access.authentication.http import SecureAPIRouter
 from datajunction_server.internal.access.authorization import validate_access
 from datajunction_server.internal.engines import get_engine
 from datajunction_server.models import access
+from datajunction_server.models.access import AccessControlStore
 from datajunction_server.models.metric import TranslatedSQL
 from datajunction_server.models.user import UserOutput
 from datajunction_server.utils import get_current_user, get_session, get_settings
@@ -108,6 +110,51 @@ async def get_measures_sql_for_cube(
     return measures_query
 
 
+async def build_and_save_node_sql(  # pylint: disable=too-many-locals
+    node_name: str,
+    dimensions: List[str] = Query([]),
+    filters: List[str] = Query([]),
+    orderby: List[str] = Query([]),
+    limit: Optional[int] = None,
+    *,
+    session: AsyncSession = Depends(get_session),
+    engine: Engine,
+    access_control: AccessControlStore,
+) -> QueryRequest:
+    """
+    Build node SQL and save it to query requests
+    """
+    query_ast = await get_query(
+        session=session,
+        node_name=node_name,
+        dimensions=dimensions,
+        filters=filters,
+        orderby=orderby,
+        limit=limit,
+        engine=engine,
+        access_control=access_control,
+    )
+    columns = [
+        assemble_column_metadata(col)  # type: ignore
+        for col in query_ast.select.projection
+    ]
+    query = str(query_ast)
+    query_request = await QueryRequest.save_query_request(
+        session=session,
+        nodes=[node_name],
+        dimensions=dimensions,
+        filters=filters,
+        orderby=orderby,
+        limit=limit,
+        engine_name=engine.name if engine else None,
+        engine_version=engine.version if engine else None,
+        query_type=QueryBuildType.NODE,
+        query=query,
+        columns=[col.dict() for col in columns],
+    )
+    return query_request
+
+
 async def get_node_sql(  # pylint: disable=too-many-locals
     node_name: str,
     dimensions: List[str] = Query([]),
@@ -120,6 +167,7 @@ async def get_node_sql(  # pylint: disable=too-many-locals
     engine_version: Optional[str] = None,
     current_user: Optional[User],
     validate_access: access.ValidateAccessFn,  # pylint: disable=redefined-outer-name
+    background_tasks: BackgroundTasks,
 ) -> Tuple[TranslatedSQL, QueryRequest]:
     """
     Return SQL for a node.
@@ -149,6 +197,18 @@ async def get_node_sql(  # pylint: disable=too-many-locals
         engine_version=engine.version if engine else None,
         query_type=QueryBuildType.NODE,
     ):
+        # Update the node SQL in a background task to keep it up-to-date
+        background_tasks.add_task(
+            build_and_save_node_sql,
+            node_name=node_name,
+            dimensions=dimensions,
+            filters=filters,
+            orderby=orderby,
+            limit=limit,
+            session=session,
+            engine=engine,
+            access_control=access_control,
+        )
         return (
             TranslatedSQL(
                 sql=query_request.query,
@@ -158,38 +218,20 @@ async def get_node_sql(  # pylint: disable=too-many-locals
             query_request,
         )
 
-    query_ast = await get_query(
-        session=session,
+    query_request = await build_and_save_node_sql(
         node_name=node_name,
         dimensions=dimensions,
         filters=filters,
         orderby=orderby,
         limit=limit,
-        engine=engine,
-        access_control=access_control,
-    )
-    columns = [
-        assemble_column_metadata(col)  # type: ignore
-        for col in query_ast.select.projection
-    ]
-    query = str(query_ast)
-    query_request = await QueryRequest.save_query_request(
         session=session,
-        nodes=[node_name],
-        dimensions=dimensions,
-        filters=filters,
-        orderby=orderby,
-        limit=limit,
-        engine_name=engine.name if engine else None,
-        engine_version=engine.version if engine else None,
-        query_type=QueryBuildType.NODE,
-        query=query,
-        columns=[col.dict() for col in columns],
+        engine=engine,  # type: ignore
+        access_control=access_control,
     )
     return (
         TranslatedSQL(
-            sql=query,
-            columns=columns,
+            sql=query_request.query,
+            columns=query_request.columns,
             dialect=engine.dialect if engine else None,
         ),
         query_request,
@@ -215,6 +257,7 @@ async def get_sql(  # pylint: disable=too-many-locals
     validate_access: access.ValidateAccessFn = Depends(  # pylint: disable=W0621
         validate_access,
     ),
+    background_tasks: BackgroundTasks,
 ) -> TranslatedSQL:
     """
     Return SQL for a node.
@@ -230,6 +273,7 @@ async def get_sql(  # pylint: disable=too-many-locals
         engine_version=engine_version,
         current_user=current_user,
         validate_access=validate_access,
+        background_tasks=background_tasks,
     )
     return translated_sql
 

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

@@ -7,9 +7,9 @@ import time
 from typing import DefaultDict, Deque, Dict, List, Optional, Set, Tuple, Union, cast
 
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import joinedload
 
 from datajunction_server.construction.utils import to_namespaced_name
+from datajunction_server.database import Engine
 from datajunction_server.database.column import Column
 from datajunction_server.database.node import Node, NodeRevision
 from datajunction_server.database.user import User
@@ -382,6 +382,42 @@ async def join_tables_for_dimensions(
                     )
 
 
+def build_filters(
+    node: NodeRevision,
+    node_table: Optional[ast.Table],
+    filters: Optional[List[str]],
+) -> List[ast.Expression]:
+    """
+    Returns a list of built filter expressions based on the provided node
+    and its table expression.
+    """
+    filter_asts: List[ast.Expression] = []
+    if not filters:
+        return filter_asts
+    dimensions_to_columns_map = node.dimensions_to_columns_map()
+    for filter_ in filters:
+        temp_select = parse(f"select * where {filter_}").select
+        referenced_dimensions = list(temp_select.find_all(ast.Column))
+        # We can only push down the filter if all dimensions referenced by the filter
+        # are available as foreign key columns on the node
+        all_referenced_dimensions_available_on_node = all(
+            dim.identifier() in dimensions_to_columns_map
+            for dim in referenced_dimensions
+        )
+        if all_referenced_dimensions_available_on_node:
+            # Renames the columns from dimension attributes to columns that match those
+            # dimension attributes on the node
+            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:
+                    dim.add_table(node_table)
+            filter_asts.append(
+                temp_select.where,  # type: ignore
+            )
+    return filter_asts
+
+
 async def _build_tables_on_select(
     session: AsyncSession,
     select: ast.SelectExpression,
@@ -395,87 +431,25 @@ async def _build_tables_on_select(
     """
     Add all nodes not agg or filter dimensions to the select
     """
+    context = CompileContext(session=session, exception=DJException())
+
     for node, tbls in tables.items():
-        node_table = cast(
+        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(
             Optional[ast.Table],
             _get_node_table(node, build_criteria),
-        )  # got a materialization
-        fk_column_mapping = {}
-        for col in node.columns:
-            if col.dimension_id:
-                col_dimension = await Node.get_by_id(
-                    session,
-                    col.dimension_id,
-                    joinedload(Node.current).options(
-                        *NodeRevision.default_load_options()
-                    ),
-                )
-                fk_column_mapping[
-                    ",".join(
-                        sorted(
-                            [
-                                pk.name for pk in col_dimension.current.primary_key()  # type: ignore  # pylint: disable=line-too-long
-                            ],
-                        ),
-                    )
-                ] = col
+        )
 
-        if node_table is None:  # no materialization - recurse to node first
+        # If no attached physical table was found, recursively build the node
+        if physical_table is None:
             node_query = parse(cast(str, node.query))
             if hash(node_query) in memoized_queries:  # pragma: no cover
-                node_table = memoized_queries[hash(node_query)].select  # type: ignore
+                query_ast = memoized_queries[hash(node_query)]  # type: ignore
             else:
-                if filters:
-                    filter_asts = (  # pylint: disable=consider-using-ternary
-                        node_query.select.where and [node_query.select.where] or []
-                    )
-                    foreign_keys_map = {
-                        left.alias_or_name.name: right
-                        for link in node.dimension_links
-                        for left, right in link.foreign_key_mapping().items()
-                    }
-                    foreign_keys_alias_map = {
-                        col.alias_or_name.name: col  # type: ignore
-                        for col in node_query.select.projection
-                    }
-                    for filter_ in filters:
-                        temp_select = parse(f"select * where {filter_}").select
-                        referenced_cols = list(temp_select.find_all(ast.Column))
-
-                        # We can only push down the filter if all columns referenced by the filter
-                        # are available as foreign key columns on the node
-                        if all(
-                            col.alias_or_name.name in fk_column_mapping
-                            or col.alias_or_name.name in foreign_keys_map
-                            for col in referenced_cols
-                        ):
-                            # Renames the columns to the foreign key columns
-                            for col in referenced_cols:
-                                ref_col_name = (
-                                    fk_column_mapping[col.alias_or_name.name].name
-                                    if col.alias_or_name.name in fk_column_mapping
-                                    else foreign_keys_map[
-                                        col.alias_or_name.name
-                                    ].alias_or_name
-                                )
-                                col.name = ast.Name(name=ref_col_name)
-                                if (  # pragma: no cover
-                                    col.alias_or_name.name in foreign_keys_alias_map
-                                ):
-                                    key = foreign_keys_alias_map[  # type: ignore
-                                        col.alias_or_name.name
-                                    ]
-                                    col.name = (
-                                        key.name
-                                        if isinstance(key, ast.Named)
-                                        else key.alias_or_name  # type: ignore
-                                    )
-                            filter_asts.append(
-                                temp_select.where,  # type: ignore
-                            )
-                    if filter_asts:
-                        node_query.select.where = ast.BinaryOp.And(*filter_asts)
-
                 query_ast = await build_ast(  # type: ignore
                     session,
                     node_query,
@@ -485,16 +459,26 @@ async def _build_tables_on_select(
                     dimensions,
                     access_control,
                 )
-                node_table = query_ast.select  # type: ignore
-                node_table.parenthesized = True  # type: ignore
                 memoized_queries[hash(node_query)] = query_ast
 
-        alias = amenable_name(node.name)
-        context = CompileContext(session=session, exception=DJException())
+            alias = amenable_name(node.name)
+            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
+        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)
 
-        node_ast = ast.Alias(ast.Name(alias), child=node_table, as_=True)  # type: ignore
         for tbl in tbls:
-            if isinstance(node_ast.child, ast.Select) and isinstance(tbl, ast.Alias):
+            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
@@ -831,17 +815,24 @@ def _get_node_table(
 
 def get_default_criteria(
     node: NodeRevision,
+    engine: Optional[Engine] = None,
 ) -> BuildCriteria:
     """
     Get the default build criteria for a node.
     """
-    return BuildCriteria(
-        # set the dialect by finding available engines for this node, or default to Spark
-        dialect=(
+    # Set the dialect by using the provided engine, if any. If no engine is specified,
+    # set the dialect by finding available engines for this node, or default to Spark
+    dialect = (
+        engine.dialect
+        if engine
+        else (
             node.catalog.engines[0].dialect
             if node.catalog and node.catalog.engines and node.catalog.engines[0].dialect
             else Dialect.SPARK
-        ),
+        )
+    )
+    return BuildCriteria(
+        dialect=dialect,
         target_node_name=node.name,
     )
 

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

@@ -330,9 +330,11 @@ class Node(Base):  # pylint: disable=too-few-public-methods
         """
         Get a node by id
         """
-        statement = select(Node).where(Node.id == node_id).options(*options)
-        result = await session.execute(statement)
-        node = result.unique().scalar_one_or_none()
+        statement = (
+            select(Node).where(Node.id == node_id).options(*options)
+        )  # pragma: no cover
+        result = await session.execute(statement)  # pragma: no cover
+        node = result.unique().scalar_one_or_none()  # pragma: no cover
         return node
 
     @classmethod
@@ -741,6 +743,17 @@ class NodeRevision(
             if col.partition and col.partition.type_ == PartitionType.CATEGORICAL
         ]
 
+    def dimensions_to_columns_map(self):
+        """
+        A mapping between each of the dimension attributes linked to this node to the columns
+        that they're linked to.
+        """
+        return {
+            left.identifier(): right
+            for link in self.dimension_links
+            for left, right in link.foreign_key_mapping().items()
+        }
+
     def __deepcopy__(self, memo):
         """
         Note: We should not use copy or deepcopy to copy any SQLAlchemy objects.

{datajunction_server-0.0.1a49 → datajunction_server-0.0.1a49.dev0}/datajunction_server/materialization/jobs/cube_materialization.py

@@ -147,7 +147,6 @@ def build_materialization_query(
         )
 
         categorical_partitions = node_revision.categorical_partition_columns()
-        print("categorical_partitions", categorical_partitions)
         if categorical_partitions:
             categorical_partition_col = [
                 col
@@ -181,5 +180,4 @@ def build_materialization_query(
     final_query.select.from_ = ast.From(
         relations=[ast.Relation(primary=ast.Table(name=ast.Name("combiner_query")))],
     )
-    print("final_queryfinal_query", final_query)
     return final_query

{datajunction_server-0.0.1a49 → datajunction_server-0.0.1a49.dev0}/datajunction_server/sql/parsing/types.py

@@ -291,7 +291,7 @@ class NestedField(ColumnType):
             doc_string = "" if doc is None else f", doc={repr(doc)}"
             super().__init__(
                 (
-                    f"{name}: {field_type}"
+                    f"{name} {field_type}"
                     f"{' NOT NULL' if not is_optional else ''}"
                     + ("" if doc is None else f" {doc}")
                 ),
@@ -364,7 +364,7 @@ field_type=IntegerType(), is_optional=True, doc='an optional field'))
     def __init__(self, *fields: NestedField):
         if not self._initialized:
             super().__init__(
-                f"struct<{', '.join(map(str, fields))}>",
+                f"struct<{','.join(map(str, fields))}>",
                 f"StructType{repr(fields)}",
             )
             self._fields = fields

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

@@ -1639,7 +1639,12 @@ class TestNodeCRUD:  # pylint: disable=too-many-public-methods
         history = response.json()
         assert [
             (activity["activity_type"], activity["entity_type"]) for activity in history
-        ] == [("refresh", "node"), ("create", "link"), ("create", "node")]
+        ] == [
+            ("refresh", "node"),
+            ("create", "link"),
+            ("create", "link"),
+            ("create", "node"),
+        ]
 
         # Refresh it again, but this time no columns will have changed so
         # verify that the node revision stays the same
@@ -1651,6 +1656,33 @@ class TestNodeCRUD:  # pylint: disable=too-many-public-methods
         assert data_second["node_revision_id"] == data["node_revision_id"]
         assert data_second["columns"] == new_columns
 
+        # The refreshed source node should retain the existing dimension links
+        response = await custom_client.get("/nodes/default.repair_orders")
+        assert response.json()["dimension_links"] == [
+            {
+                "dimension": {"name": "default.repair_order"},
+                "foreign_keys": {
+                    "default.repair_orders.repair_order_id": "default.repair_order.repair_order_id",
+                },
+                "join_cardinality": "many_to_one",
+                "join_sql": "default.repair_orders.repair_order_id = "
+                "default.repair_order.repair_order_id",
+                "join_type": "left",
+                "role": None,
+            },
+            {
+                "dimension": {"name": "default.dispatcher"},
+                "foreign_keys": {
+                    "default.repair_orders.dispatcher_id": "default.dispatcher.dispatcher_id",
+                },
+                "join_cardinality": "many_to_one",
+                "join_sql": "default.repair_orders.dispatcher_id = "
+                "default.dispatcher.dispatcher_id",
+                "join_type": "left",
+                "role": None,
+            },
+        ]
+
     @pytest.mark.asyncio
     async def test_refresh_source_node_with_problems(
         self,
@@ -1684,7 +1716,12 @@ class TestNodeCRUD:  # pylint: disable=too-many-public-methods
         history = response.json()
         assert [
             (activity["activity_type"], activity["entity_type"]) for activity in history
-        ] == [("refresh", "node"), ("create", "link"), ("create", "node")]
+        ] == [
+            ("refresh", "node"),
+            ("create", "link"),
+            ("create", "link"),
+            ("create", "node"),
+        ]
 
         # Refresh it again, but this time no columns are found
         mocker.patch.object(
@@ -2692,11 +2729,11 @@ GROUP BY
             "attributes": [],
             "dimension": None,
             "name": "measures",
-            "type": "struct<completed_repairs: bigint, "
-            "total_repairs_dispatched: bigint, "
-            "total_amount_in_region: double, "
-            "avg_repair_amount_in_region: double, "
-            "avg_dispatch_delay: double, unique_contractors: "
+            "type": "struct<completed_repairs bigint,"
+            "total_repairs_dispatched bigint,"
+            "total_amount_in_region double,"
+            "avg_repair_amount_in_region double,"
+            "avg_dispatch_delay double,unique_contractors "
             "bigint>",
             "display_name": "Measures",
             "partition": None,