infrahub-server 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

infrahub/core/diff/repository/repository.py

@@ -3,17 +3,22 @@ from typing import Generator
 from infrahub import config
 from infrahub.core import registry
 from infrahub.core.diff.query.field_summary import EnrichedDiffNodeFieldSummaryQuery
+from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import ResourceNotFoundError
+from infrahub.log import get_logger
 
 from ..model.path import (
     ConflictSelection,
     EnrichedDiffConflict,
     EnrichedDiffRoot,
+    EnrichedDiffRootMetadata,
     EnrichedDiffs,
+    EnrichedDiffsMetadata,
     EnrichedNodeCreateRequest,
     NodeDiffFieldSummary,
+    NodeFieldSpecifier,
     TimeRange,
     TrackingId,
 )
@@ -21,15 +26,18 @@ from ..query.delete_query import EnrichedDiffDeleteQuery
 from ..query.diff_get import EnrichedDiffGetQuery
 from ..query.diff_summary import DiffSummaryCounters, DiffSummaryQuery
 from ..query.drop_tracking_id import EnrichedDiffDropTrackingIdQuery
-from ..query.empty_roots import EnrichedDiffEmptyRootsQuery
+from ..query.field_specifiers import EnrichedDiffFieldSpecifiersQuery
 from ..query.filters import EnrichedDiffQueryFilters
 from ..query.get_conflict_query import EnrichedDiffConflictQuery
 from ..query.has_conflicts_query import EnrichedDiffHasConflictQuery
+from ..query.roots_metadata import EnrichedDiffRootsMetadataQuery
 from ..query.save import EnrichedDiffRootsCreateQuery, EnrichedNodeBatchCreateQuery, EnrichedNodesLinkQuery
 from ..query.time_range_query import EnrichedDiffTimeRangeQuery
 from ..query.update_conflict_query import EnrichedDiffConflictUpdateQuery
 from .deserializer import EnrichedDiffDeserializer
 
+log = get_logger()
+
 
 class DiffRepository:
     MAX_SAVE_BATCH_SIZE: int = 100
@@ -53,7 +61,6 @@ class DiffRepository:
         include_empty: bool = False,
     ) -> list[EnrichedDiffRoot]:
         final_max_depth = config.SETTINGS.database.max_depth_search_hierarchy
-        final_limit = limit or config.SETTINGS.database.query_size_limit
         query = await EnrichedDiffGetQuery.init(
             db=self.db,
             base_branch_name=base_branch_name,
@@ -62,7 +69,7 @@ class DiffRepository:
             to_time=to_time,
             filters=EnrichedDiffQueryFilters(**dict(filters or {})),
             max_depth=final_max_depth,
-            limit=final_limit,
+            limit=limit,
             offset=offset,
             tracking_id=tracking_id,
             diff_ids=diff_ids,
@@ -118,6 +125,22 @@ class DiffRepository:
             for dbr in diff_branch_roots
         ]
 
+    async def hydrate_diff_pair(self, enriched_diffs_metadata: EnrichedDiffsMetadata) -> EnrichedDiffs:
+        hydrated_base_diff = await self.get_one(
+            diff_branch_name=enriched_diffs_metadata.base_branch_name,
+            diff_id=enriched_diffs_metadata.base_branch_diff.uuid,
+        )
+        hydrated_branch_diff = await self.get_one(
+            diff_branch_name=enriched_diffs_metadata.diff_branch_name,
+            diff_id=enriched_diffs_metadata.diff_branch_diff.uuid,
+        )
+        return EnrichedDiffs(
+            base_branch_name=enriched_diffs_metadata.base_branch_name,
+            diff_branch_name=enriched_diffs_metadata.diff_branch_name,
+            base_branch_diff=hydrated_base_diff,
+            diff_branch_diff=hydrated_branch_diff,
+        )
+
     async def get_one(
         self,
         diff_branch_name: str,
@@ -161,6 +184,8 @@ class DiffRepository:
 
     @retry_db_transaction(name="enriched_diff_save")
     async def save(self, enriched_diffs: EnrichedDiffs) -> None:
+        num_nodes = len(enriched_diffs.base_branch_diff.nodes) + len(enriched_diffs.diff_branch_diff.nodes)
+        log.info(f"Saving diff (num_nodes={num_nodes})...")
         root_query = await EnrichedDiffRootsCreateQuery.init(db=self.db, enriched_diffs=enriched_diffs)
         await root_query.execute(db=self.db)
         for node_create_batch in self._get_node_create_request_batch(enriched_diffs=enriched_diffs):
@@ -168,6 +193,7 @@ class DiffRepository:
             await node_query.execute(db=self.db)
         link_query = await EnrichedNodesLinkQuery.init(db=self.db, enriched_diffs=enriched_diffs)
         await link_query.execute(db=self.db)
+        log.info("Diff saved.")
 
     async def summary(
         self,
@@ -211,18 +237,55 @@ class DiffRepository:
         await query.execute(db=self.db)
         return await query.get_time_ranges()
 
-    async def get_empty_roots(
+    async def get_diff_pairs_metadata(
         self,
         diff_branch_names: list[str] | None = None,
         base_branch_names: list[str] | None = None,
-    ) -> list[EnrichedDiffRoot]:
-        query = await EnrichedDiffEmptyRootsQuery.init(
-            db=self.db, diff_branch_names=diff_branch_names, base_branch_names=base_branch_names
+        from_time: Timestamp | None = None,
+        to_time: Timestamp | None = None,
+    ) -> list[EnrichedDiffsMetadata]:
+        if diff_branch_names and base_branch_names:
+            diff_branch_names += base_branch_names
+        empty_roots = await self.get_roots_metadata(
+            diff_branch_names=diff_branch_names,
+            base_branch_names=base_branch_names,
+            from_time=from_time,
+            to_time=to_time,
+        )
+        roots_by_id = {root.uuid: root for root in empty_roots}
+        pairs: list[EnrichedDiffsMetadata] = []
+        for branch_root in empty_roots:
+            if branch_root.base_branch_name == branch_root.diff_branch_name:
+                continue
+            base_root = roots_by_id[branch_root.partner_uuid]
+            pairs.append(
+                EnrichedDiffsMetadata(
+                    base_branch_name=branch_root.base_branch_name,
+                    diff_branch_name=branch_root.diff_branch_name,
+                    base_branch_diff=base_root,
+                    diff_branch_diff=branch_root,
+                )
+            )
+        return pairs
+
+    async def get_roots_metadata(
+        self,
+        diff_branch_names: list[str] | None = None,
+        base_branch_names: list[str] | None = None,
+        from_time: Timestamp | None = None,
+        to_time: Timestamp | None = None,
+    ) -> list[EnrichedDiffRootMetadata]:
+        query = await EnrichedDiffRootsMetadataQuery.init(
+            db=self.db,
+            diff_branch_names=diff_branch_names,
+            base_branch_names=base_branch_names,
+            from_time=from_time,
+            to_time=to_time,
         )
         await query.execute(db=self.db)
         diff_roots = []
-        for neo4j_node in query.get_empty_root_nodes():
-            diff_roots.append(self.deserializer.build_diff_root(root_node=neo4j_node))
+        for neo4j_node in query.get_root_nodes_metadata():
+            diff_roots.append(self.deserializer.build_diff_root_metadata(root_node=neo4j_node))
         return diff_roots
 
     async def diff_has_conflicts(
@@ -267,3 +330,31 @@ class DiffRepository:
     async def drop_tracking_ids(self, tracking_ids: list[TrackingId]) -> None:
         query = await EnrichedDiffDropTrackingIdQuery.init(db=self.db, tracking_ids=tracking_ids)
         await query.execute(db=self.db)
+
+    async def get_num_changes_in_time_range_by_branch(
+        self, branch_names: list[str], from_time: Timestamp, to_time: Timestamp
+    ) -> dict[str, int]:
+        query = await DiffCountChanges.init(db=self.db, branch_names=branch_names, diff_from=from_time, diff_to=to_time)
+        await query.execute(db=self.db)
+        return query.get_num_changes_by_branch()
+
+    async def get_node_field_specifiers(self, diff_id: str) -> set[NodeFieldSpecifier]:
+        limit = config.SETTINGS.database.query_size_limit
+        offset = 0
+        specifiers: set[NodeFieldSpecifier] = set()
+        while True:
+            query = await EnrichedDiffFieldSpecifiersQuery.init(db=self.db, diff_id=diff_id, offset=offset, limit=limit)
+            await query.execute(db=self.db)
+
+            new_specifiers = {
+                NodeFieldSpecifier(
+                    node_uuid=field_specifier_tuple[0],
+                    field_name=field_specifier_tuple[1],
+                )
+                for field_specifier_tuple in query.get_node_field_specifier_tuples()
+            }
+            if not new_specifiers:
+                break
+            specifiers |= new_specifiers
+            offset += limit
+        return specifiers

infrahub/core/diff/tasks.py

@@ -57,7 +57,7 @@ async def refresh_diff_all(branch_name: str) -> None:
         component_registry = get_component_registry()
         default_branch = registry.get_branch_from_registry()
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
-        diff_roots_to_refresh = await diff_repository.get_empty_roots(diff_branch_names=[branch_name])
+        diff_roots_to_refresh = await diff_repository.get_roots_metadata(diff_branch_names=[branch_name])
 
         for diff_root in diff_roots_to_refresh:
             if diff_root.base_branch_name != diff_root.diff_branch_name:

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 17
+GRAPH_VERSION = 18

infrahub/core/integrity/object_conflict/conflict_recorder.py

@@ -94,13 +94,18 @@ class ObjectConflictValidatorRecorder:
         await self.finalize_validator(validator, is_success)
         return current_checks
 
-    async def get_or_create_validator(self, proposed_change: CoreProposedChange) -> Node:
+    async def get_validator(self, proposed_change: CoreProposedChange) -> Node | None:
         validations = await proposed_change.validations.get_peers(db=self.db, branch_agnostic=True)
 
         for validation in validations.values():
             if validation.get_kind() == self.validator_kind:
                 return validation
+        return None
 
+    async def get_or_create_validator(self, proposed_change: CoreProposedChange) -> Node:
+        validator_obj = await self.get_validator(proposed_change=proposed_change)
+        if validator_obj:
+            return validator_obj
         validator_obj = await Node.init(db=self.db, schema=self.validator_kind)
         await validator_obj.new(
             db=self.db,

infrahub/core/ipam/utilization.py

@@ -35,7 +35,12 @@ class PrefixUtilizationGetter:
 
     async def _run_and_parse_query(self) -> None:
         self._results_by_prefix_id = {}
-        query = await IPPrefixUtilization.init(db=self.db, at=self.at, ip_prefixes=self.ip_prefixes)
+        query = await IPPrefixUtilization.init(
+            db=self.db,
+            at=self.at,
+            ip_prefixes=self.ip_prefixes,
+            allocated_kinds=[InfrahubKind.IPPREFIX, InfrahubKind.IPADDRESS],
+        )
         await query.execute(db=self.db)
 
         for result in query.get_results():

infrahub/core/manager.py

@@ -26,6 +26,7 @@ from infrahub.core.relationship import Relationship, RelationshipManager
 from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema, ProfileSchema, RelationshipSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import NodeNotFoundError, ProcessingError, SchemaNotFoundError
+from infrahub.graphql.models import OrderModel
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -141,6 +142,7 @@ class NodeManager:
         account=...,
         partial_match: bool = ...,
         branch_agnostic: bool = ...,
+        order: OrderModel | None = ...,
     ) -> list[Any]: ...
 
     @overload
@@ -161,6 +163,7 @@ class NodeManager:
         account=...,
         partial_match: bool = ...,
         branch_agnostic: bool = ...,
+        order: OrderModel | None = ...,
     ) -> list[SchemaProtocol]: ...
 
     @classmethod
@@ -180,6 +183,7 @@ class NodeManager:
         account=None,
         partial_match: bool = False,
         branch_agnostic: bool = False,
+        order: OrderModel | None = None,
     ) -> list[Any]:
         """Query one or multiple nodes of a given type based on filter arguments.
 
@@ -227,6 +231,7 @@ class NodeManager:
             at=at,
             partial_match=partial_match,
             branch_agnostic=branch_agnostic,
+            order=order,
         )
         await query.execute(db=db)
         node_ids = query.get_node_ids()
@@ -295,6 +300,7 @@ class NodeManager:
             at=at,
             partial_match=partial_match,
             branch_agnostic=branch_agnostic,
+            order=OrderModel(disable=True),
         )
         return await query.count(db=db)
 
@@ -657,6 +663,7 @@ class NodeManager:
             prefetch_relationships=prefetch_relationships,
             account=account,
             branch_agnostic=branch_agnostic,
+            order=OrderModel(disable=True),
         )
 
         if len(items) > 1:
@@ -820,6 +827,7 @@ class NodeManager:
             prefetch_relationships=prefetch_relationships,
             account=account,
             branch_agnostic=branch_agnostic,
+            order=OrderModel(disable=True),
         )
 
         if len(items) < 1:

infrahub/core/merge.py

@@ -10,6 +10,7 @@ from infrahub.core.protocols import CoreRepository
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import ValidationError
+from infrahub.log import get_logger
 
 from ..git.models import GitRepositoryMerge
 from ..workflows.catalogue import GIT_REPOSITORIES_MERGE
@@ -25,6 +26,8 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
     from infrahub.services import InfrahubServices
 
+log = get_logger()
+
 
 class BranchMerger:
     def __init__(
@@ -174,9 +177,11 @@ class BranchMerger:
         if self.source_branch.name == registry.default_branch:
             raise ValidationError(f"Unable to merge the branch '{self.source_branch.name}' into itself")
 
-        enriched_diff = await self.diff_coordinator.update_branch_diff(
+        log.debug("Updating diff for merge")
+        enriched_diff = await self.diff_coordinator.update_branch_diff_and_return(
             base_branch=self.destination_branch, diff_branch=self.source_branch
         )
+        log.debug("Diff updated for merge")
         conflict_map = enriched_diff.get_all_conflicts()
         errors: list[str] = []
         for conflict_path, conflict in conflict_map.items():

infrahub/core/migrations/graph/__init__.py

@@ -19,6 +19,7 @@ from .m014_remove_index_attr_value import Migration014
 from .m015_diff_format_update import Migration015
 from .m016_diff_delete_bug_fix import Migration016
 from .m017_add_core_profile import Migration017
+from .m018_uniqueness_nulls import Migration018
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -43,6 +44,7 @@ MIGRATIONS: list[type[Union[GraphMigration, InternalSchemaMigration, ArbitraryMi
     Migration015,
     Migration016,
     Migration017,
+    Migration018,
 ]
 
 

infrahub/core/migrations/graph/m014_remove_index_attr_value.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core.migrations.shared import MigrationResult
-from infrahub.core.query import Query  # noqa: TCH001
+from infrahub.core.query import Query  # noqa: TC001
 from infrahub.database import DatabaseType
 from infrahub.database.constants import IndexType
 from infrahub.database.index import IndexItem

infrahub/core/migrations/graph/m015_diff_format_update.py

@@ -31,6 +31,6 @@ class Migration015(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_empty_roots()
+        diff_roots = await diff_repo.get_roots_metadata()
         await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
         return MigrationResult()

infrahub/core/migrations/graph/m016_diff_delete_bug_fix.py

@@ -31,6 +31,6 @@ class Migration016(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_empty_roots()
+        diff_roots = await diff_repo.get_roots_metadata()
         await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
         return MigrationResult()

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Sequence
+
+from infrahub.core import registry
+from infrahub.core.diff.payload_builder import get_display_labels_per_kind
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.schema import GenericSchema, NodeSchema, SchemaRoot, internal_schema
+from infrahub.core.schema.manager import SchemaManager
+from infrahub.core.validators.uniqueness.checker import UniquenessChecker
+from infrahub.dependencies.registry import build_component_registry, get_component_registry
+from infrahub.log import get_logger
+
+from ..shared import InternalSchemaMigration, SchemaMigration
+
+if TYPE_CHECKING:
+    from infrahub.core.validators.uniqueness.model import NonUniqueNode
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration018(InternalSchemaMigration):
+    name: str = "018_validate_nulls_in_uniqueness_constraints"
+    minimum_version: int = 17
+    migrations: Sequence[SchemaMigration] = []
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+
+        return result
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        """
+        Validate any schema that include optional attributes in the uniqueness constraints
+
+        An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
+        """
+        default_branch = registry.get_branch_from_registry()
+        build_component_registry()
+        component_registry = get_component_registry()
+        uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
+        non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
+
+        manager = SchemaManager()
+        registry.schema = manager
+        internal_schema_root = SchemaRoot(**internal_schema)
+        manager.register_schema(schema=internal_schema_root)
+        schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
+        manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
+
+        for schema_kind in schema_branch.node_names + schema_branch.generic_names:
+            schema = schema_branch.get(name=schema_kind, duplicate=False)
+            if not isinstance(schema, (NodeSchema, GenericSchema)):
+                continue
+
+            schema_constraint_path_groups = schema.get_unique_constraint_schema_attribute_paths(
+                schema_branch=schema_branch
+            )
+            includes_optional_attr: bool = False
+
+            for constraint_group in schema_constraint_path_groups:
+                for schema_attribute_path in constraint_group:
+                    if (
+                        schema_attribute_path.attribute_schema
+                        and schema_attribute_path.attribute_schema.optional is True
+                    ):
+                        includes_optional_attr = True
+                        break
+
+            if not includes_optional_attr:
+                continue
+
+            non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
+            if non_unique_nodes:
+                non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
+
+        if not non_unique_nodes_by_kind:
+            return MigrationResult()
+
+        error_strings = []
+        for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
+            display_label_map = await get_display_labels_per_kind(
+                db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
+            )
+            for non_unique_node in non_unique_nodes:
+                display_label = display_label_map.get(non_unique_node.node_id)
+                error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
+                error_str += " violates uniqueness constraints for the following attributes: "
+                attr_values = [
+                    f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
+                ]
+                error_str += ", ".join(attr_values)
+                error_strings.append(error_str)
+        if error_strings:
+            error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
+            error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
+            error_str += " now that NULL values are considered during uniqueness validation"
+            return MigrationResult(errors=[error_str] + error_strings)
+        return MigrationResult()

infrahub/core/migrations/query/attribute_add.py

@@ -56,6 +56,10 @@ class AttributeAddQuery(Query):
         self.params["is_visible_default"] = True
 
         query = """
+        MERGE (av:AttributeValue { value: $attr_value, is_default: true })
+        MERGE (is_protected_value:Boolean { value: $is_protected_default })
+        MERGE (is_visible_value:Boolean { value: $is_visible_default })
+        WITH av, is_protected_value, is_visible_value
         MATCH p = (n:%(node_kind)s)
         CALL {
             WITH n
@@ -66,12 +70,8 @@ class AttributeAddQuery(Query):
             ORDER BY r2.branch_level DESC, r2.from ASC, r1.branch_level DESC, r1.from ASC
             LIMIT 1
         }
-        WITH n1 as n, r11 as r1, r12 as r2
+        WITH n1 as n, r11 as r1, r12 as r2, av, is_protected_value, is_visible_value
         WHERE r1.status = "active" AND (r2 IS NULL OR r2.status = "deleted")
-        MERGE (av:AttributeValue { value: $attr_value, is_default: true })
-        MERGE (is_protected_value:Boolean { value: $is_protected_default })
-        MERGE (is_visible_value:Boolean { value: $is_visible_default })
-        WITH n, av, is_protected_value, is_visible_value, r2
         CREATE (a:Attribute { name: $attr_name, branch_support: $branch_support })
         CREATE (n)-[:HAS_ATTRIBUTE $rel_props ]->(a)
         CREATE (a)-[:HAS_VALUE $rel_props ]->(av)

infrahub/core/migrations/schema/tasks.py

@@ -7,9 +7,9 @@ from prefect import flow, task
 from prefect.cache_policies import NONE
 from prefect.logging import get_run_logger
 
-from infrahub.core.branch import Branch  # noqa: TCH001
+from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.migrations import MIGRATION_MAP
-from infrahub.core.path import SchemaPath  # noqa: TCH001
+from infrahub.core.path import SchemaPath  # noqa: TC001
 from infrahub.services import services
 from infrahub.workflows.utils import add_branch_tag
 

infrahub/core/migrations/shared.py

@@ -6,8 +6,8 @@ from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Self
 
 from infrahub.core import registry
-from infrahub.core.path import SchemaPath  # noqa: TCH001
-from infrahub.core.query import Query  # noqa: TCH001
+from infrahub.core.path import SchemaPath  # noqa: TC001
+from infrahub.core.query import Query  # noqa: TC001
 from infrahub.core.schema import (
     AttributeSchema,
     GenericSchema,
@@ -17,7 +17,7 @@ from infrahub.core.schema import (
     internal_schema,
 )
 
-from .query import MigrationQuery  # noqa: TCH001
+from .query import MigrationQuery  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch

infrahub/core/node/__init__.py

@@ -18,6 +18,7 @@ from infrahub.support.macro import MacroDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
+from ...graphql.models import OrderModel
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
 from .base import BaseNode, BaseNodeMeta, BaseNodeOptions
@@ -399,7 +400,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     peer = await relationship_attribute.get_peer(db=db, raise_on_error=True)
 
                     related_node = await registry.manager.get_one_by_id_or_default_filter(
-                        db=db, id=peer.id, kind=attribute_path.active_relationship_schema.peer
+                        db=db, id=peer.id, kind=attribute_path.active_relationship_schema.peer, branch=self._branch.name
                     )
 
                     attribute: BaseAttribute = getattr(
@@ -609,7 +610,12 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         # Update the relationship to the branch itself
         query = await NodeGetListQuery.init(
-            db=db, schema=self._schema, filters={"id": self.id}, branch=self._branch, at=delete_at
+            db=db,
+            schema=self._schema,
+            filters={"id": self.id},
+            branch=self._branch,
+            at=delete_at,
+            order=OrderModel(disable=True),
         )
         await query.execute(db=db)
         result = query.get_result()

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Iterable, Optional
 
 from infrahub.core import registry
+from infrahub.core.constants import NULL_VALUE
 from infrahub.core.schema import (
     MainSchemaTypes,
     SchemaAttributePath,
@@ -61,10 +62,12 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                         include_in_query = True
                     attribute_name = attribute_path.attribute_schema.name
                     attribute = getattr(updated_node, attribute_name)
-                    if attribute.is_enum:
+                    if attribute.is_enum and attribute.value:
                         attribute_value = attribute.value.value
                     else:
                         attribute_value = attribute.value
+                    if attribute_value is None:
+                        attribute_value = NULL_VALUE
                     query_attribute_paths.add(
                         QueryAttributePath(
                             attribute_name=attribute_name,
@@ -96,10 +99,14 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                 attribute_name = schema_attribute_path.attribute_schema.name
                 attribute_field = getattr(updated_node, attribute_name)
                 attribute_value = getattr(attribute_field, schema_attribute_path.attribute_property_name or "value")
+                if attribute_field.is_enum and attribute_value:
+                    attribute_value = attribute_value.value
+                elif attribute_value is None:
+                    attribute_value = NULL_VALUE
                 node_value_combination.append(
                     SchemaAttributePathValue.from_schema_attribute_path(
                         schema_attribute_path,
-                        value=attribute_value.value if attribute_field.is_enum else attribute_value,
+                        value=attribute_value,
                     )
                 )
         return node_value_combination

infrahub/core/query/__init__.py

@@ -10,6 +10,7 @@ import ujson
 from neo4j.graph import Node as Neo4jNode
 from neo4j.graph import Path as Neo4jPath
 from neo4j.graph import Relationship as Neo4jRelationship
+from opentelemetry import trace
 
 from infrahub import config
 from infrahub.core.constants import PermissionLevel
@@ -161,7 +162,7 @@ def cleanup_return_labels(labels: list[str]) -> list[str]:
 class QueryResult:
     def __init__(self, data: list[Union[Neo4jNode, Neo4jRelationship, list[Neo4jNode]]], labels: list[str]):
         self.data = data
-        self.labels = cleanup_return_labels(labels)
+        self.labels = labels
         self.branch_score: int = 0
         self.time_score: int = 0
         self.permission_score = PermissionLevel.DEFAULT
@@ -523,6 +524,7 @@ class Query(ABC):
 
         return ":params { " + ", ".join(params) + " }"
 
+    @trace.get_tracer(__name__).start_as_current_span("Query.execute")
     async def execute(self, db: InfrahubDatabase) -> Self:
         # Ensure all mandatory params have been provided
         # Ensure at least 1 return obj has been defined
@@ -552,7 +554,8 @@ class Query(ABC):
         if not results and self.raise_error_if_empty:
             raise QueryError(query=query_str, params=self.params)
 
-        self.results = [QueryResult(data=result, labels=self.return_labels) for result in results]
+        clean_labels = cleanup_return_labels(self.return_labels)
+        self.results = [QueryResult(data=result, labels=clean_labels) for result in results]
         self.has_been_executed = True
 
         return self