infrahub-server 1.3.8__py3-none-any.whl → 1.4.0__py3-none-any.whl

infrahub/core/migrations/schema/attribute_kind_update.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.types import is_large_attribute_type
+
+from ..query import AttributeMigrationQuery
+from ..shared import AttributeSchemaMigration, MigrationResult
+
+if TYPE_CHECKING:
+    from infrahub.core.branch.models import Branch
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+
+class AttributeKindUpdateMigrationQuery(AttributeMigrationQuery):
+    name = "migration_attribute_kind"
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
+        self.params.update(branch_params)
+        needs_index = not is_large_attribute_type(self.migration.new_attribute_schema.kind)
+        self.params["needs_index"] = needs_index
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["at"] = self.at.to_string()
+        self.params["attr_name"] = self.migration.previous_attribute_schema.name
+        new_attr_value_labels = "AttributeValue"
+        if needs_index:
+            new_attr_value_labels += ":AttributeValueIndexed"
+        # ruff: noqa: S608
+        query = """
+// ------------
+// start with all the Attribute vertices we might care about
+// ------------
+MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+WHERE attr.name = $attr_name
+WITH DISTINCT n, attr
+
+// ------------
+// for each Attribute, find the most recent active edge and AttributeValue vertex that needs to be [un]indexed
+// ------------
+CALL (n, attr) {
+    MATCH (n)-[r1:HAS_ATTRIBUTE]->(attr:Attribute)-[r2:HAS_VALUE]->(av)
+    WHERE all(r IN [r1, r2] WHERE %(branch_filter)s)
+    WITH r2, av, r1.status = "active" AND r2.status = "active" AS is_active
+    ORDER BY r2.branch_level DESC, r2.from DESC, r2.status = "active" DESC, r1.branch_level DESC, r1.from DESC, r1.status = "active" DESC
+    LIMIT 1
+    WITH r2 AS has_value_e, av, "AttributeValueIndexed" IN labels(av) AS is_indexed
+    WHERE is_active AND is_indexed <> $needs_index
+    RETURN has_value_e, av
+}
+
+// ------------
+// check if the correct AttributeValue vertex to use exists
+// create it if not
+// ------------
+WITH DISTINCT av.is_default AS av_is_default, av.value AS av_value
+CALL (av_is_default, av_value) {
+    OPTIONAL MATCH (existing_av:AttributeValue {is_default: av_is_default, value: av_value})
+    WHERE "AttributeValueIndexed" IN labels(existing_av) = $needs_index
+    WITH existing_av WHERE existing_av IS NULL
+    LIMIT 1
+    CREATE (:%(new_attr_value_labels)s {is_default: av_is_default, value: av_value})
+}
+
+// ------------
+// get all the AttributeValue vertices that need to be updated again and run the updates
+// ------------
+WITH 1 AS one
+LIMIT 1
+MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+WHERE attr.name = $attr_name
+WITH DISTINCT n, attr
+
+// ------------
+// for each Attribute, find the most recent active edge and AttributeValue vertex that needs to be [un]indexed
+// ------------
+CALL (n, attr) {
+    MATCH (n)-[r1:HAS_ATTRIBUTE]->(attr:Attribute)-[r2:HAS_VALUE]->(av)
+    WHERE all(r IN [r1, r2] WHERE %(branch_filter)s)
+    WITH r2, av, r1.status = "active" AND r2.status = "active" AS is_active
+    ORDER BY r2.branch_level DESC, r2.from DESC, r2.status = "active" DESC, r1.branch_level DESC, r1.from DESC, r1.status = "active" DESC
+    LIMIT 1
+    WITH r2 AS has_value_e, av, "AttributeValueIndexed" IN labels(av) AS is_indexed
+    WHERE is_active AND is_indexed <> $needs_index
+    RETURN has_value_e, av
+}
+
+
+// ------------
+// create and update the HAS_VALUE edges
+// ------------
+CALL (attr, has_value_e, av) {
+    // ------------
+    // get the correct AttributeValue vertex b/c it definitely exists now
+    // ------------
+    MATCH (new_av:%(new_attr_value_labels)s {is_default: av.is_default, value: av.value})
+    WHERE "AttributeValueIndexed" IN labels(new_av) = $needs_index
+    LIMIT 1
+
+    // ------------
+    // create the new HAS_VALUE edge
+    // ------------
+    CREATE (attr)-[new_has_value_e:HAS_VALUE]->(new_av)
+    SET new_has_value_e = properties(has_value_e)
+    SET new_has_value_e.status = "active"
+    SET new_has_value_e.branch = $branch
+    SET new_has_value_e.branch_level = $branch_level
+    SET new_has_value_e.from = $at
+    SET new_has_value_e.to = NULL
+
+    // ------------
+    // if we are updating on a branch and the existing edge is on the default branch,
+    // then create a new deleted edge on this branch
+    // ------------
+    WITH attr, has_value_e, av
+    WHERE has_value_e.branch <> $branch
+    CREATE (attr)-[deleted_has_value_e:HAS_VALUE]->(av)
+    SET deleted_has_value_e = properties(has_value_e)
+    SET deleted_has_value_e.status = "deleted"
+    SET deleted_has_value_e.branch = $branch
+    SET deleted_has_value_e.branch_level = $branch_level
+    SET deleted_has_value_e.from = $at
+    SET deleted_has_value_e.to = NULL
+}
+
+// ------------
+// if the existing edge is on the same branch as the update,
+// then set its "to" time
+// ------------
+CALL (has_value_e) {
+    WITH has_value_e
+    WHERE has_value_e.branch = $branch
+    SET has_value_e.to = $at
+}
+        """ % {
+            "schema_kind": self.migration.previous_schema.kind,
+            "branch_filter": branch_filter,
+            "new_attr_value_labels": new_attr_value_labels,
+        }
+        self.add_to_query(query)
+
+
+class AttributeKindUpdateMigration(AttributeSchemaMigration):
+    name: str = "attribute.kind.update"
+    queries: Sequence[type[AttributeMigrationQuery]] = [AttributeKindUpdateMigrationQuery]  # type: ignore[assignment]
+
+    async def execute(self, db: InfrahubDatabase, branch: Branch, at: Timestamp | str | None = None) -> MigrationResult:
+        is_indexed_previous = is_large_attribute_type(self.previous_attribute_schema.kind)
+        is_indexed_new = is_large_attribute_type(self.new_attribute_schema.kind)
+        if is_indexed_previous is is_indexed_new:
+            return MigrationResult()
+
+        return await super().execute(db=db, branch=branch, at=at)

infrahub/core/migrations/schema/tasks.py

@@ -10,17 +10,18 @@ from prefect.logging import get_run_logger
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.migrations import MIGRATION_MAP
 from infrahub.core.path import SchemaPath  # noqa: TC001
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workers.dependencies import get_database
 from infrahub.workflows.utils import add_branch_tag
 
 from .models import SchemaApplyMigrationData, SchemaMigrationPathResponseData
 
 if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
+    from infrahub.database import InfrahubDatabase
 
 
 @flow(name="schema_apply_migrations", flow_run_name="Apply schema migrations", persist_result=True)
-async def schema_apply_migrations(message: SchemaApplyMigrationData, service: InfrahubServices) -> list[str]:
+async def schema_apply_migrations(message: SchemaApplyMigrationData) -> list[str]:
     await add_branch_tag(branch_name=message.branch.name)
     log = get_run_logger()
 
@@ -55,7 +56,7 @@ async def schema_apply_migrations(message: SchemaApplyMigrationData, service: In
             new_node_schema=new_node_schema,
             previous_node_schema=previous_node_schema,
             schema_path=migration.path,
-            service=service,
+            database=await get_database(),
         )
 
     async for _, result in batch.execute():
@@ -75,13 +76,13 @@ async def schema_path_migrate(
     branch: Branch,
     migration_name: str,
     schema_path: SchemaPath,
-    service: InfrahubServices,
+    database: InfrahubDatabase,
     new_node_schema: MainSchemaTypes | None = None,
     previous_node_schema: MainSchemaTypes | None = None,
 ) -> SchemaMigrationPathResponseData:
     log = get_run_logger()
 
-    async with service.database.start_session() as db:
+    async with database.start_session() as db:
         node_kind = None
         if new_node_schema:
             node_kind = new_node_schema.kind

infrahub/core/models.py

@@ -569,7 +569,11 @@ class HashableModel(BaseModel):
 
         for field_name in other.model_fields.keys():
             if not hasattr(self, field_name):
-                setattr(self, field_name, getattr(other, field_name))
+                try:
+                    setattr(self, field_name, getattr(other, field_name))
+                except ValueError:
+                    # handles the case where self and other are different types and other has fields that self does not
+                    pass
                 continue
 
             attr_other = getattr(other, field_name)

infrahub/core/node/proposed_change.py

@@ -0,0 +1,43 @@
+from typing import cast
+
+from infrahub.core.constants.infrahubkind import THREADCOMMENT
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange as CoreProposedChangeProtocol
+from infrahub.database import InfrahubDatabase
+
+
+class CoreProposedChange(Node):
+    async def to_graphql(
+        self,
+        db: InfrahubDatabase,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
+        filter_sensitive: bool = False,
+        permissions: dict | None = None,
+        include_properties: bool = True,
+    ) -> dict:
+        response = await super().to_graphql(
+            db,
+            fields=fields,
+            related_node_ids=related_node_ids,
+            filter_sensitive=filter_sensitive,
+            permissions=permissions,
+            include_properties=include_properties,
+        )
+
+        if fields:
+            if "total_comments" in fields:
+                total_comments = 0
+                proposed_change = cast(CoreProposedChangeProtocol, self)
+                change_comments = await proposed_change.comments.get_relationships(db=db)
+                total_comments += len(change_comments)
+
+                threads = await proposed_change.threads.get_peers(db=db)
+                thread_comments = await NodeManager.query(
+                    db=db, schema=THREADCOMMENT, filters={"thread__ids": list(threads.keys())}
+                )
+                total_comments += len(thread_comments)
+                response["total_comments"] = {"value": total_comments}
+
+        return response

infrahub/core/protocols.py

@@ -319,6 +319,7 @@ class CoreCheckDefinition(CoreTaskTarget):
 
 
 class CoreCustomWebhook(CoreWebhook, CoreTaskTarget):
+    shared_key: StringOptional
     transformation: RelationshipManager
 
 
@@ -480,7 +481,10 @@ class CoreProposedChange(CoreTaskTarget):
     source_branch: String
     destination_branch: String
     state: Enum
+    is_draft: Boolean
+    total_comments: IntegerOptional
     approved_by: RelationshipManager
+    rejected_by: RelationshipManager
     reviewers: RelationshipManager
     created_by: RelationshipManager
     comments: RelationshipManager
@@ -554,6 +558,14 @@ class InternalAccountToken(CoreNode):
     account: RelationshipManager
 
 
+class InternalIPPrefixAvailable(BuiltinIPPrefix):
+    pass
+
+
+class InternalIPRangeAvailable(BuiltinIPAddress):
+    last_address: IPHost
+
+
 class InternalRefreshToken(CoreNode):
     expiration: DateTime
     account: RelationshipManager

infrahub/core/query/attribute.py

@@ -5,9 +5,16 @@ from typing import TYPE_CHECKING, Any
 from infrahub.core.constants import AttributeDBNodeType
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_NODE_LABEL, RELATIONSHIP_TO_VALUE_LABEL
 from infrahub.core.constants.schema import FlagProperty, NodeProperty
+from infrahub.core.graph.schema import (
+    GraphAttributeIPHostNode,
+    GraphAttributeIPNetworkNode,
+    GraphAttributeValueIndexedNode,
+    GraphAttributeValueNode,
+)
 from infrahub.core.query import Query, QueryNode, QueryRel, QueryType
 from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import build_regex_attrs
+from infrahub.types import is_large_attribute_type
 
 if TYPE_CHECKING:
     from infrahub.core.attribute import BaseAttribute
@@ -56,12 +63,14 @@ class AttributeUpdateValueQuery(AttributeQuery):
 
         prop_list = [f"{key}: ${key}" for key in content.keys()]
 
-        labels = ["AttributeValue"]
+        labels = [GraphAttributeValueNode.get_default_label()]
         node_type = self.attr.get_db_node_type()
-        if node_type == AttributeDBNodeType.IPHOST:
-            labels.append("AttributeIPHost")
-        elif node_type == AttributeDBNodeType.IPNETWORK:
-            labels.append("AttributeIPNetwork")
+        if AttributeDBNodeType.INDEXED in node_type:
+            labels.append(GraphAttributeValueIndexedNode.get_default_label())
+        if AttributeDBNodeType.IPHOST in node_type:
+            labels.append(GraphAttributeIPHostNode.get_default_label())
+        if AttributeDBNodeType.IPNETWORK in node_type:
+            labels.append(GraphAttributeIPNetworkNode.get_default_label())
 
         query = """
         MATCH (a:Attribute { uuid: $attr_uuid })
@@ -198,6 +207,9 @@ async def default_attribute_query_filter(
     support_profiles: bool = False,
 ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
     """Generate Query String Snippet to filter the right node."""
+    attribute_value_label = GraphAttributeValueNode.get_default_label()
+    if attribute_kind and not is_large_attribute_type(attribute_kind):
+        attribute_value_label = GraphAttributeValueIndexedNode.get_default_label()
 
     query_filter: list[QueryElement] = []
     query_params: dict[str, Any] = {}
@@ -226,33 +238,35 @@ async def default_attribute_query_filter(
         query_filter.append(QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]))
 
         if filter_value is None:
-            query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+            query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
         else:
             if partial_match:
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 query_where.append(
                     f"toLower(toString(av.{filter_name})) CONTAINS toLower(toString(${param_prefix}_{filter_name}))"
                 )
             elif attribute_kind and attribute_kind == "List" and not isinstance(filter_value, list):
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 filter_value = build_regex_attrs(values=[filter_value])
                 query_where.append(f"toString(av.{filter_name}) =~ ${param_prefix}_{filter_name}")
             elif filter_name == "isnull":
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
             elif support_profiles:
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 query_where.append(f"(av.{filter_name} = ${param_prefix}_{filter_name} OR av.is_default)")
             else:
                 query_filter.append(
                     QueryNode(
-                        name="av", labels=["AttributeValue"], params={filter_name: f"${param_prefix}_{filter_name}"}
+                        name="av",
+                        labels=[attribute_value_label],
+                        params={filter_name: f"${param_prefix}_{filter_name}"},
                     )
                 )
             query_params[f"{param_prefix}_{filter_name}"] = filter_value
 
     elif filter_name == "values" and isinstance(filter_value, list):
         query_filter.extend(
-            (QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]), QueryNode(name="av", labels=["AttributeValue"]))
+            (QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]), QueryNode(name="av", labels=[attribute_value_label]))
         )
         if attribute_kind and attribute_kind == "List":
             query_params[f"{param_prefix}_{filter_name}"] = build_regex_attrs(values=filter_value)
@@ -267,10 +281,14 @@ async def default_attribute_query_filter(
         query_filter.append(QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]))
 
         if filter_value is None:
-            query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+            query_filter.append(QueryNode(name="av", labels=[GraphAttributeValueNode.get_default_label()]))
         else:
             query_filter.append(
-                QueryNode(name="av", labels=["AttributeValue"], params={filter_name: f"${param_prefix}_{filter_name}"})
+                QueryNode(
+                    name="av",
+                    labels=[GraphAttributeValueNode.get_default_label()],
+                    params={filter_name: f"${param_prefix}_{filter_name}"},
+                )
             )
             query_params[f"{param_prefix}_{filter_name}"] = filter_value
 

infrahub/core/query/diff.py

@@ -100,6 +100,17 @@ class DiffCountChanges(Query):
         return branch_count_map
 
 
+async def get_num_changes_in_time_range_by_branch(
+    branch_names: list[str],
+    from_time: Timestamp,
+    to_time: Timestamp,
+    db: InfrahubDatabase,
+) -> dict[str, int]:
+    query = await DiffCountChanges.init(db=db, branch_names=branch_names, diff_from=from_time, diff_to=to_time)
+    await query.execute(db=db)
+    return query.get_num_changes_by_branch()
+
+
 class DiffCalculationQuery(DiffQuery):
     type = QueryType.READ
     insert_limit = False

infrahub/core/query/ipam.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterable
 
 from infrahub.core.constants import InfrahubKind
+from infrahub.core.graph.schema import GraphAttributeIPHostNode, GraphAttributeIPNetworkNode
 from infrahub.core.ipam.constants import AllIPTypes, IPAddressType, IPNetworkType
 from infrahub.core.query import QueryType
 from infrahub.core.registry import registry
@@ -21,8 +22,8 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-PREFIX_ATTRIBUTE_LABEL = "AttributeIPNetwork"
-ADDRESS_ATTRIBUTE_LABEL = "AttributeIPHost"
+PREFIX_ATTRIBUTE_LABEL = GraphAttributeIPNetworkNode.get_default_label()
+ADDRESS_ATTRIBUTE_LABEL = GraphAttributeIPHostNode.get_default_label()
 
 
 @dataclass
@@ -280,14 +281,13 @@ class IPPrefixUtilization(Query):
         MATCH path = (
             (pfx)-[r_1:IS_RELATED]-(rl:Relationship)-[r_2:IS_RELATED]-(child:Node)
             -[r_attr:HAS_ATTRIBUTE]->(attr:Attribute)
-            -[r_attr_val:HAS_VALUE]->(av:AttributeValue)
+            -[r_attr_val:HAS_VALUE]->(av:{PREFIX_ATTRIBUTE_LABEL}|{ADDRESS_ATTRIBUTE_LABEL})
         )
         WHERE %(id_func)s(r_1) = %(id_func)s(r_rel1)
         AND %(id_func)s(r_2) = %(id_func)s(r_rel2)
         AND ({rel_filter("r_attr")})
         AND ({rel_filter("r_attr_val")})
         AND attr.name IN ["prefix", "address"]
-        AND any(l in labels(av) WHERE l in ["{PREFIX_ATTRIBUTE_LABEL}", "{ADDRESS_ATTRIBUTE_LABEL}"])
         WITH
             path,
             pfx,
@@ -478,6 +478,7 @@ class IPPrefixReconcileQuery(Query):
             -[pr2:IS_RELATED {status: "active"}]-(maybe_new_parent:%(ip_prefix_kind)s)
             -[har:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})
             -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
+            USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
             WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
             AND av.version = $ip_version
             AND av.binary_address IN $possible_prefix_list
@@ -514,15 +515,16 @@ class IPPrefixReconcileQuery(Query):
             OPTIONAL MATCH child_path = (
                  (ip_namespace)-[r1:IS_RELATED]
                  -(ns_rel:Relationship)-[r2:IS_RELATED]
-                 -(maybe_new_child:Node)-[har:HAS_ATTRIBUTE]
+                 -(maybe_new_child:%(ip_prefix_kind)s|%(ip_address_kind)s)-[har:HAS_ATTRIBUTE]
                  ->(a:Attribute)-[hvr:HAS_VALUE]
-                 ->(av:AttributeValue)
+                 ->(av:%(ip_prefix_attribute_kind)s|%(ip_address_attribute_kind)s)
             )
+            USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
+            USING INDEX av:%(ip_address_attribute_kind)s(binary_address)
             WHERE $is_prefix  // only prefix nodes can have children
             AND ns_rel.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
             AND any(child_kind IN [$ip_prefix_kind, $ip_address_kind] WHERE child_kind IN labels(maybe_new_child))
             AND a.name in ["prefix", "address"]
-            AND any(attr_kind IN [$ip_prefix_attribute_kind, $ip_address_attribute_kind] WHERE attr_kind IN labels(av))
             AND (ip_node IS NULL OR maybe_new_child.uuid <> ip_node.uuid)
             AND (
                 ($ip_prefix_kind IN labels(maybe_new_child) AND av.prefixlen > $prefixlen)
@@ -580,6 +582,10 @@ class IPPrefixReconcileQuery(Query):
             collect(new_child) as new_children
         """ % {
             "branch_filter": branch_filter,
+            "ip_prefix_kind": InfrahubKind.IPPREFIX,
+            "ip_address_kind": InfrahubKind.IPADDRESS,
+            "ip_prefix_attribute_kind": PREFIX_ATTRIBUTE_LABEL,
+            "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }
         self.add_to_query(get_new_children_query)
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]

infrahub/core/query/node.py

@@ -140,15 +140,19 @@ class NodeCreateAllQuery(NodeQuery):
         attributes: list[AttributeCreateData] = []
         attributes_iphost: list[AttributeCreateData] = []
         attributes_ipnetwork: list[AttributeCreateData] = []
+        attributes_indexed: list[AttributeCreateData] = []
 
         for attr_name in self.node._attributes:
             attr: BaseAttribute = getattr(self.node, attr_name)
             attr_data = attr.get_create_data()
+            node_type = attr.get_db_node_type()
 
-            if attr_data.node_type == AttributeDBNodeType.IPHOST:
+            if AttributeDBNodeType.IPHOST in node_type:
                 attributes_iphost.append(attr_data)
-            elif attr_data.node_type == AttributeDBNodeType.IPNETWORK:
+            elif AttributeDBNodeType.IPNETWORK in node_type:
                 attributes_ipnetwork.append(attr_data)
+            elif AttributeDBNodeType.INDEXED in node_type:
+                attributes_indexed.append(attr_data)
             else:
                 attributes.append(attr_data)
 
@@ -182,6 +186,7 @@ class NodeCreateAllQuery(NodeQuery):
                 relationships.append(rel_create_data)
 
         self.params["attrs"] = [attr.model_dump() for attr in attributes]
+        self.params["attrs_indexed"] = [attr.model_dump() for attr in attributes_indexed]
         self.params["attrs_iphost"] = [attr.model_dump() for attr in attributes_iphost]
         self.params["attrs_ipnetwork"] = [attr.model_dump() for attr in attributes_ipnetwork]
         self.params["rels_bidir"] = [
@@ -224,24 +229,59 @@ class NodeCreateAllQuery(NodeQuery):
             "binary_address": "attr.content.binary_address",
             "version": "attr.content.version",
             "prefixlen": "attr.content.prefixlen",
-            # "num_addresses": "attr.content.num_addresses",
         }
         ipnetwork_prop_list = [f"{key}: {value}" for key, value in ipnetwork_prop.items()]
 
-        attrs_query = """
+        attrs_nonindexed_query = """
         WITH distinct n
         UNWIND $attrs AS attr
+        // Try to find a matching vertex
+        OPTIONAL MATCH (existing_av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+        WHERE NOT existing_av:AttributeValueIndexed
+        CALL (attr, existing_av) {
+            // If none found, create a new one
+            WITH existing_av
+            WHERE existing_av IS NULL
+            CREATE (:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+        }
+        CALL (attr) {
+            MATCH (av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+            WHERE NOT av:AttributeValueIndexed
+            RETURN av
+            LIMIT 1
+        }
+        CALL (n, attr, av) {
+            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
+            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
+            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            MERGE (ip:Boolean { value: attr.is_protected })
+            MERGE (iv:Boolean { value: attr.is_visible })
+            WITH a, ip, iv
+            LIMIT 1
+            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
+            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            FOREACH ( prop IN attr.source_prop |
+                MERGE (peer:Node { uuid: prop.peer_id })
+                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+            )
+            FOREACH ( prop IN attr.owner_prop |
+                MERGE (peer:Node { uuid: prop.peer_id })
+                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+            )
+        }"""
+
+        attrs_indexed_query = """
+        WITH distinct n
+        UNWIND $attrs_indexed AS attr
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue { value: attr.content.value, is_default: attr.content.is_default })
+            MERGE (av:AttributeValue:AttributeValueIndexed { value: attr.content.value, is_default: attr.content.is_default })
             WITH av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
             MERGE (iv:Boolean { value: attr.is_visible })
-            WITH a, ip, iv
-            LIMIT 1
             CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
             CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
             FOREACH ( prop IN attr.source_prop |
@@ -260,7 +300,7 @@ class NodeCreateAllQuery(NodeQuery):
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue:AttributeIPHost { %(iphost_prop)s })
+            MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPHost { %(iphost_prop)s })
             WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
@@ -287,7 +327,7 @@ class NodeCreateAllQuery(NodeQuery):
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue:AttributeIPNetwork { %(ipnetwork_prop)s })
+            MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPNetwork { %(ipnetwork_prop)s })
             WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
@@ -424,7 +464,8 @@ class NodeCreateAllQuery(NodeQuery):
         MATCH (root:Root)
         CREATE (n:Node:%(labels)s $node_prop )
         CREATE (n)-[r:IS_PART_OF $node_branch_prop ]->(root)
-        {attrs_query if self.params["attrs"] else ""}
+        {attrs_nonindexed_query if self.params["attrs"] else ""}
+        {attrs_indexed_query if self.params["attrs_indexed"] else ""}
         {attrs_iphost_query if self.params["attrs_iphost"] else ""}
         {attrs_ipnetwork_query if self.params["attrs_ipnetwork"] else ""}
         {rels_bidir_query if self.params["rels_bidir"] else ""}

infrahub/core/query/resource_manager.py

@@ -140,7 +140,7 @@ class NumberPoolGetAllocated(Query):
         self.params.update(branch_params)
 
         query = """
-        MATCH (n:%(node)s)-[ha:HAS_ATTRIBUTE]-(a:Attribute {name: $node_attribute})-[hv:HAS_VALUE]-(av:AttributeValue)
+        MATCH (n:%(node)s)-[ha:HAS_ATTRIBUTE]-(a:Attribute {name: $node_attribute})-[hv:HAS_VALUE]-(av:AttributeValueIndexed)
         MATCH (a)-[hs:HAS_SOURCE]-(pool:%(number_pool_kind)s)
         WHERE
             pool.uuid = $pool_id
@@ -306,7 +306,7 @@ class NumberPoolGetUsed(Query):
         self.params["attribute_name"] = self.pool.node_attribute.value
 
         query = """
-        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValue)
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValueIndexed)
         WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
         CALL (pool, res, av) {
             MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
@@ -371,7 +371,7 @@ class NumberPoolSetReserved(Query):
 
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        MERGE (value:AttributeValue { value: $reserved, is_default: false })
+        MERGE (value:AttributeValue:AttributeValueIndexed { value: $reserved, is_default: false })
         WITH value, pool
         LIMIT 1
         CREATE (pool)-[rel:IS_RESERVED $rel_prop]->(value)

infrahub/core/schema/basenode_schema.py

@@ -55,6 +55,14 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def is_profile_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return False
+
+    @property
+    def is_ip_address(self) -> bool:
+        return False
+
     @property
     def kind(self) -> str:
         if self.namespace == "Attribute":