arango-query-core 0.2.4__tar.gz → 0.2.6__tar.gz

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/CHANGELOG.md

@@ -6,6 +6,45 @@ exact versions (contextual-data-fabric CC-9) and re-run their golden /
 eval suites on every bump — pre-1.0, **minor** bumps may break the API
 and this file must say so explicitly.
 
+## [0.2.6] - 2026-10-29
+
+### Added
+
+- **Temporal property encodings.** A property may declare how its temporal
+  values are stored, `"encoding": "epoch_ms"` (integer milliseconds since the
+  epoch) or `"iso8601"` (an ISO-8601 string), read into
+  `PropertyInfo.encoding` (empty when not declared) and carried by
+  `schema_summary()`. Any other value is refused with `INVALID_MAPPING`.
+  The vocabulary is `TEMPORAL_ENCODINGS`. It is a physical detail, like
+  `field`, so OWL/Turtle does not carry it. arango-cypher-py lowers temporal
+  accessors, functions and arithmetic from it (LDBC WP-41).
+
+## [0.2.5] - 2026-10-26
+
+### Added
+
+- **Supertypes (label hierarchies).** A supertype is a label that stands for
+  other labels, such as LDBC's `Message`, which is every `Post` and every
+  `Comment`. It is mapped with one of two new entity styles,
+  `SUPERTYPE_STYLES`:
+  - `MULTI_LABEL`: the members share a collection and list their labels in
+    an array field (`labelsField`, `labelValue`);
+  - `UNION`: the members have their own collections (`members`).
+- **New resolver methods.** `MappingResolver.is_supertype()` and
+  `supertype_members()`. The latter flattens nested supertypes and refuses
+  unknown members and cycles with `INVALID_MAPPING`. A supertype without
+  properties of its own has its members' properties.
+- **`edge_constrains_target`** treats a supertype target as guaranteed when
+  every class an edge endpoint can be is a member: `HAS_CREATOR`'s domain
+  `[Post, Comment]` guarantees `Message`.
+- **OWL/Turtle** writes and reads the hierarchy as `rdfs:subClassOf`.
+  `turtle_to_mapping` no longer invents a `collectionName` for a `UNION`
+  supertype. The rdflib parser does not read `rdfs:subClassOf` yet.
+
+The change is additive: mappings without the new styles resolve exactly as
+before. A consumer that switches on `style` and does not handle the new
+values rejects them rather than misreading them.
+
 ## [0.2.4] - 2026-10-21
 
 ### Added

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arango-query-core
-Version: 0.2.4
+Version: 0.2.6
 Summary: Shared conceptual-model and NL substrate for ArangoDB query transpilers (arango-cypher-py, arango-sparql-py)
 Project-URL: Repository, https://github.com/ArthurKeen/arango-query-core
 Project-URL: Changelog, https://github.com/ArthurKeen/arango-query-core/blob/main/CHANGELOG.md

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/arango_query_core/__init__.py

@@ -4,6 +4,8 @@ from .exec import AqlExecutor, explain_aql, safe_execute
 from .extensions import ExtensionPolicy, ExtensionRegistry
 from .mapping import (
     COLLECTION_NAME_RE,
+    SUPERTYPE_STYLES,
+    TEMPORAL_ENCODINGS,
     IndexInfo,
     MappingBundle,
     MappingResolver,
@@ -23,6 +25,8 @@ except ImportError:
 
 __all__ = [
     "COLLECTION_NAME_RE",
+    "SUPERTYPE_STYLES",
+    "TEMPORAL_ENCODINGS",
     "AqlExecutor",
     "AqlFragment",
     "AqlQuery",

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/arango_query_core/mapping.py

@@ -10,6 +10,28 @@ from .errors import CoreError
 
 JsonObj = dict[str, Any]
 
+#: Entity mapping styles for a *supertype*: a label whose instances are the
+#: instances of other labels (LDBC's ``Message`` is every ``Post`` and every
+#: ``Comment``).
+#:
+#: * ``MULTI_LABEL`` — the members share one collection and every document
+#:   lists all its labels in an array field::
+#:
+#:       {"style": "MULTI_LABEL", "collectionName": "nodes",
+#:        "labelsField": "labels", "labelValue": "Message"}
+#:
+#:   matches documents of ``nodes`` whose ``labels`` contain ``"Message"``.
+#: * ``UNION`` — the members live in their own collections::
+#:
+#:       {"style": "UNION", "members": ["Post", "Comment"]}
+#:
+#: Members come from the physical ``members`` list or, failing that, the
+#: conceptual entity's ``subtypes``. They must be mapped labels; a member may
+#: itself be a supertype (members are flattened). Consumers that switch on
+#: ``style`` and do not know these values fail closed, which is why supertypes
+#: get styles of their own rather than extra fields on ``LABEL``/``COLLECTION``.
+SUPERTYPE_STYLES = frozenset({"MULTI_LABEL", "UNION"})
+
 
 # ArangoDB collection-name grammar (per the official docs):
 #   * starts with a letter or underscore
@@ -141,6 +163,14 @@ class IndexInfo:
     traversal_safe: bool = True
 
 
+#: Storage encodings of temporal property values.
+#:
+#: * ``epoch_ms`` — an integer, milliseconds since 1970-01-01T00:00:00Z.
+#: * ``iso8601`` — an ISO-8601 string (``2010-01-03T15:10:31.499+00:00``,
+#:   or ``2010-01-03`` for a date).
+TEMPORAL_ENCODINGS = frozenset({"epoch_ms", "iso8601"})
+
+
 @dataclass(frozen=True)
 class PropertyInfo:
     """Metadata for a single property/attribute on an entity or relationship.
@@ -165,6 +195,25 @@ class PropertyInfo:
     # / numeric / free_text / boolean / other), inferred by the schema analyzer.
     # Consumers choose a matching strategy from this rather than field names.
     role: str = ""
+    # How a temporal value (``type`` date / datetime / …) is stored: one of
+    # ``TEMPORAL_ENCODINGS``, or empty when the mapping does not say.
+    # Consumers must not guess an encoding: comparisons, components
+    # (``.year``) and arithmetic differ between the two.
+    encoding: str = ""
+
+
+def _property_encoding(owner: str, name: str, raw: Any) -> str:
+    """A property's declared ``encoding``, checked against ``TEMPORAL_ENCODINGS``."""
+    if raw in (None, ""):
+        return ""
+    encoding = str(raw)
+    if encoding not in TEMPORAL_ENCODINGS:
+        raise CoreError(
+            f"Property {owner}.{name} declares encoding {encoding!r}; expected one of "
+            f"{', '.join(sorted(TEMPORAL_ENCODINGS))}",
+            code="INVALID_MAPPING",
+        )
+    return encoding
 
 
 @dataclass(frozen=True)
@@ -391,6 +440,13 @@ class MappingResolver:
             return {}
 
         props_raw = mapping.get("properties", {})
+        if not props_raw and mapping.get("style") in SUPERTYPE_STYLES:
+            # A supertype without its own property list has its members' properties.
+            merged: dict[str, PropertyInfo] = {}
+            for member in self.supertype_members(label_or_type):
+                for name, info in self.resolve_properties(member).items():
+                    merged.setdefault(name, info)
+            return merged
         if not isinstance(props_raw, dict):
             return {}
 
@@ -409,6 +465,7 @@ class MappingResolver:
                     numeric_like=bool(meta.get("numericLike") or meta.get("numeric_like")),
                     sample_values=tuple(str(s) for s in samples) if samples else (),
                     role=str(meta.get("role") or ""),
+                    encoding=_property_encoding(label_or_type, name, meta.get("encoding")),
                 )
             elif isinstance(meta, str):
                 result[name] = PropertyInfo(field=name, type=meta)
@@ -518,7 +575,16 @@ class MappingResolver:
         be in the set **and** every class in the union must map to the same
         physical collection (otherwise multiple collections are reachable and
         IS_SAME_COLLECTION is still needed).
+
+        A supertype target is guaranteed when every class the endpoint can be
+        is one of its members: ``HAS_CREATOR``'s domain ``[Post, Comment]``
+        guarantees ``Message``.
         """
+        if self.is_supertype(target_label):
+            classes = [endpoint] if isinstance(endpoint, str) else list(endpoint or [])
+            members = set(self.supertype_members(target_label))
+            return bool(classes) and all(c in members for c in classes)
+
         if isinstance(endpoint, str):
             return endpoint == target_label
 
@@ -645,6 +711,68 @@ class MappingResolver:
         """Check if any index on the relationship's edge collection has VCI enabled."""
         return any(idx.vci for idx in self.resolve_indexes(rel_type))
 
+    # ------------------------------------------------------------------
+    # Supertypes (label hierarchies)
+    # ------------------------------------------------------------------
+
+    def is_supertype(self, label: str) -> bool:
+        """True when *label* is mapped with a supertype style (see :data:`SUPERTYPE_STYLES`)."""
+        try:
+            return self.resolve_entity(label).get("style") in SUPERTYPE_STYLES
+        except CoreError:
+            return False
+
+    def _declared_members(self, label: str, emap: JsonObj) -> list[str]:
+        members = emap.get("members")
+        if members is None:
+            for ent in self.bundle.conceptual_schema.get("entities", []) or []:
+                if isinstance(ent, dict) and ent.get("name") == label:
+                    members = ent.get("subtypes")
+                    break
+        if not isinstance(members, list) or not members or not all(isinstance(m, str) and m for m in members):
+            raise CoreError(
+                f"Supertype {label!r} declares no members: give the physical mapping a 'members' list "
+                f"or the conceptual entity a 'subtypes' list",
+                code="INVALID_MAPPING",
+            )
+        return members
+
+    def supertype_members(self, label: str) -> list[str]:
+        """The concrete (non-supertype) labels a supertype stands for, in declaration order.
+
+        Nested supertypes are flattened. Raises ``INVALID_MAPPING`` for a
+        member that is not mapped or a cycle; raises ``MAPPING_NOT_FOUND`` if
+        *label* is not mapped, and ``INVALID_MAPPING`` if it is not a supertype.
+        """
+        out: list[str] = []
+
+        def visit(name: str, path: tuple[str, ...]) -> None:
+            if name in path:
+                raise CoreError(
+                    f"Supertype cycle: {' -> '.join((*path, name))}",
+                    code="INVALID_MAPPING",
+                )
+            try:
+                emap = self.resolve_entity(name)
+            except CoreError as e:
+                if path:
+                    raise CoreError(
+                        f"Supertype {path[-1]!r} lists member {name!r}, which is not mapped",
+                        code="INVALID_MAPPING",
+                    ) from e
+                raise
+            if emap.get("style") not in SUPERTYPE_STYLES:
+                if not path:
+                    raise CoreError(f"{name!r} is not a supertype", code="INVALID_MAPPING")
+                if name not in out:
+                    out.append(name)
+                return
+            for member in self._declared_members(name, emap):
+                visit(member, (*path, name))
+
+        visit(label, ())
+        return out
+
     def all_entity_labels(self) -> list[str]:
         """Return all entity type labels defined in the mapping."""
         entities = self.bundle.physical_mapping.get("entities", {})
@@ -697,6 +825,7 @@ class MappingResolver:
                         **({"numericLike": True} if p.numeric_like else {}),
                         **({"sampleValues": list(p.sample_values)} if p.sample_values else {}),
                         **({"role": p.role} if p.role else {}),
+                        **({"encoding": p.encoding} if p.encoding else {}),
                     }
                     for name, p in props.items()
                 },
@@ -731,6 +860,7 @@ class MappingResolver:
                         **({"numericLike": True} if p.numeric_like else {}),
                         **({"sampleValues": list(p.sample_values)} if p.sample_values else {}),
                         **({"role": p.role} if p.role else {}),
+                        **({"encoding": p.encoding} if p.encoding else {}),
                     }
                     for name, p in props.items()
                 },

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/arango_query_core/owl_turtle.py

@@ -62,6 +62,13 @@ def mapping_to_turtle(bundle: MappingBundle) -> str:
                 lines.append(f':{name} phys:typeField "{tf}" .')
             if tv:
                 lines.append(f':{name} phys:typeValue "{tv}" .')
+        if style == "MULTI_LABEL":
+            for annot in ("labelsField", "labelValue"):
+                if emap.get(annot):
+                    lines.append(f':{name} phys:{annot} "{emap[annot]}" .')
+        # A supertype's members are its OWL subclasses.
+        for member in emap.get("members") or entity_def.get("subtypes") or []:
+            lines.append(f":{member} rdfs:subClassOf :{name} .")
 
         for prop in entity_def.get("properties", []):
             pname = prop.get("name", "")
@@ -127,6 +134,7 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
     obj_props: dict[str, dict[str, str]] = {}
     data_props: list[dict[str, Any]] = []
     annotations: dict[str, dict[str, str]] = {}
+    subclasses: dict[str, list[str]] = {}  # supertype -> member classes (rdfs:subClassOf)
 
     current_subject: str | None = None
     current_kind: str | None = None  # "class", "objprop", "dataprop"
@@ -150,6 +158,11 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
             obj_props.setdefault(current_subject, {})
             continue
 
+        m_sub = re.match(r":(\w+)\s+rdfs:subClassOf\s+:(\w+)\s*\.", stripped)
+        if m_sub:
+            subclasses.setdefault(m_sub.group(2), []).append(m_sub.group(1))
+            continue
+
         m_dataprop = re.match(r":(\w+)\s+a\s+owl:DatatypeProperty", stripped)
         if m_dataprop:
             current_subject = m_dataprop.group(1)
@@ -188,6 +201,8 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
             "typeValue",
             "edgeCollectionName",
             "attributeName",
+            "labelsField",
+            "labelValue",
         ):
             m_a = re.match(rf':(\w+)\s+phys:{annot}\s+"([^"]+)"', stripped)
             if m_a:
@@ -200,15 +215,24 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
     for name in classes:
         own = [dp for dp in data_props if name in dp["domains"]]
         props = [{"name": dp["name"], "type": _from_xsd_type(dp.get("range", "xsd:string"))} for dp in own]
-        entities_cs.append({"name": name, "labels": [name], "properties": props})
+        cs_entry: dict[str, Any] = {"name": name, "labels": [name], "properties": props}
+        if subclasses.get(name):
+            cs_entry["subtypes"] = list(subclasses[name])
+        entities_cs.append(cs_entry)
         ann = annotations.get(name, {})
-        pm_entry: dict[str, Any] = {
-            "style": ann.get("mappingStyle", "COLLECTION"),
-            "collectionName": ann.get("collectionName", name.lower() + "s"),
-        }
-        if pm_entry["style"] == "LABEL":
+        style = ann.get("mappingStyle", "COLLECTION")
+        pm_entry: dict[str, Any] = {"style": style}
+        if style == "UNION":
+            # A UNION supertype has no collection of its own; its members are its subclasses.
+            pm_entry["members"] = list(subclasses.get(name, []))
+        else:
+            pm_entry["collectionName"] = ann.get("collectionName", name.lower() + "s")
+        if style == "LABEL":
             pm_entry["typeField"] = ann.get("typeField", "type")
             pm_entry["typeValue"] = ann.get("typeValue", name)
+        if style == "MULTI_LABEL":
+            pm_entry["labelsField"] = ann.get("labelsField", "labels")
+            pm_entry["labelValue"] = ann.get("labelValue", name)
         fields = {
             dp["name"]: {"field": annotations[dp["name"]]["attributeName"]}
             for dp in own

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/docs/PRD.md

@@ -116,7 +116,7 @@ to prevent a three-way fork.
 
 | Module / subpackage | Purpose |
 | --- | --- |
-| `mapping` | `MappingBundle`, `MappingResolver`, `MappingSource`, `PropertyInfo`, `IndexInfo`, `RelationshipStats`; `mapping_from_wire_dict`, `mapping_hash`; collection-name grammar guard (`COLLECTION_NAME_RE`, `is_valid_collection_name`) |
+| `mapping` | `MappingBundle`, `MappingResolver` (incl. supertypes: `SUPERTYPE_STYLES`, `is_supertype`, `supertype_members`), `MappingSource`, `PropertyInfo`, `IndexInfo`, `RelationshipStats`; `mapping_from_wire_dict`, `mapping_hash`; collection-name grammar guard (`COLLECTION_NAME_RE`, `is_valid_collection_name`) |
 | `owl_turtle` / `owl_rdflib` | OWL/Turtle ⇄ MappingBundle round-trip; rdflib parser behind the `owl` extra (import degrades to `None` without it) |
 | `aql` | `AqlFragment`, `AqlQuery` value types |
 | `exec` | `AqlExecutor` protocol, `safe_execute` (bind-var reference checking), `explain_aql` |
@@ -149,6 +149,24 @@ to prevent a three-way fork.
 - **R5 — Deterministic contract types.** `mapping_hash` over a bundle
   is stable across processes (canonical JSON) so consumers can use it
   for cache keys and change detection.
+- **R7 — Label hierarchies (supertypes).** A supertype is a label whose
+  instances are the instances of other labels (LDBC's `Message` is every
+  `Post` and every `Comment`).
+  - **Styles.** It is mapped with one of two entity styles (`SUPERTYPE_STYLES`):
+    - `MULTI_LABEL`: the members share one collection, and documents list
+      their labels in an array field (`labelsField`, `labelValue`).
+    - `UNION`: the members have collections of their own (`members`).
+  - **Members** come from the physical `members` list or the conceptual
+    entity's `subtypes`.
+  - **Resolver.** `MappingResolver.supertype_members()` flattens nested
+    supertypes, and refuses unknown members and cycles (`INVALID_MAPPING`).
+    A supertype without properties of its own has its members' properties.
+    `edge_constrains_target` treats a supertype target as guaranteed when
+    every class an edge endpoint can be is a member.
+  - **New styles fail closed.** Supertypes get styles of their own, so a
+    consumer that does not handle them rejects the mapping instead of
+    misreading it.
+  - **OWL.** OWL/Turtle round-trips the hierarchy as `rdfs:subClassOf`.
 - **R6 — Quality gates.** ruff (lint + format), mypy, and pytest run in
   CI on every push/PR; all three must pass before a release is tagged.
 

{arango_query_core-0.2.4 → arango_query_core-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arango-query-core"
-version = "0.2.4"
+version = "0.2.6"
 description = "Shared conceptual-model and NL substrate for ArangoDB query transpilers (arango-cypher-py, arango-sparql-py)"
 readme = "README.md"
 license = { file = "LICENSE" }

arango_query_core-0.2.6/tests/test_mapping_property_encoding.py

@@ -0,0 +1,74 @@
+"""Temporal property encodings: ``PropertyInfo.encoding``."""
+
+from __future__ import annotations
+
+import pytest
+
+from arango_query_core import TEMPORAL_ENCODINGS, CoreError, MappingBundle, MappingResolver
+
+
+def _resolver(properties: dict, rel_properties: dict | None = None) -> MappingResolver:
+    return MappingResolver(
+        MappingBundle(
+            conceptual_schema={"entities": [], "relationships": []},
+            physical_mapping={
+                "entities": {
+                    "Post": {"collectionName": "post", "style": "COLLECTION", "properties": properties},
+                    "Person": {"collectionName": "person", "style": "COLLECTION", "properties": {}},
+                },
+                "relationships": {
+                    "KNOWS": {
+                        "edgeCollectionName": "knows",
+                        "style": "DEDICATED_COLLECTION",
+                        "domain": "Person",
+                        "range": "Person",
+                        "properties": rel_properties or {},
+                    }
+                },
+            },
+            metadata={},
+        )
+    )
+
+
+def test_the_vocabulary() -> None:
+    assert frozenset({"epoch_ms", "iso8601"}) == TEMPORAL_ENCODINGS
+
+
+def test_a_declared_encoding_is_read_for_entities_and_relationships() -> None:
+    resolver = _resolver(
+        {"creationDate": {"type": "datetime", "encoding": "epoch_ms"}},
+        {"creationDate": {"type": "datetime", "encoding": "iso8601"}},
+    )
+    assert resolver.resolve_properties("Post")["creationDate"].encoding == "epoch_ms"
+    assert resolver.resolve_properties("KNOWS")["creationDate"].encoding == "iso8601"
+
+
+def test_no_declaration_means_unknown() -> None:
+    props = _resolver({"creationDate": {"type": "datetime"}, "title": "string", "id": None})
+    infos = props.resolve_properties("Post")
+    assert {name: info.encoding for name, info in infos.items()} == {
+        "creationDate": "",
+        "title": "",
+        "id": "",
+    }
+
+
+@pytest.mark.parametrize("bad", ["epochMillis", "ISO8601", "seconds", 13])
+def test_an_unknown_encoding_is_an_invalid_mapping(bad: object) -> None:
+    resolver = _resolver({"creationDate": {"type": "datetime", "encoding": bad}})
+    with pytest.raises(CoreError, match="Post.creationDate declares encoding") as err:
+        resolver.resolve_properties("Post")
+    assert err.value.code == "INVALID_MAPPING"
+
+
+def test_the_schema_summary_carries_the_encoding_when_declared() -> None:
+    summary = _resolver(
+        {"creationDate": {"type": "datetime", "encoding": "iso8601"}, "title": {"type": "string"}},
+        {"creationDate": {"type": "datetime", "encoding": "epoch_ms"}},
+    ).schema_summary()
+    post = next(e for e in summary["entities"] if e["label"] == "Post")
+    assert post["properties"]["creationDate"]["encoding"] == "iso8601"
+    assert "encoding" not in post["properties"]["title"]
+    knows = next(r for r in summary["relationships"] if r["type"] == "KNOWS")
+    assert knows["properties"]["creationDate"]["encoding"] == "epoch_ms"

arango_query_core-0.2.6/tests/test_mapping_supertypes.py

@@ -0,0 +1,190 @@
+"""Supertypes (label hierarchies): the MULTI_LABEL and UNION entity styles."""
+
+from __future__ import annotations
+
+import pytest
+
+from arango_query_core import SUPERTYPE_STYLES, CoreError, MappingBundle, MappingResolver
+
+
+def _bundle(
+    entities: dict, relationships: dict | None = None, conceptual: dict | None = None
+) -> MappingBundle:
+    return MappingBundle(
+        conceptual_schema=conceptual or {"entities": [], "relationships": []},
+        physical_mapping={"entities": entities, "relationships": relationships or {}},
+        metadata={},
+    )
+
+
+_POST = {
+    "collectionName": "post",
+    "style": "COLLECTION",
+    "properties": {"id": {"field": "id"}, "imageFile": {}},
+}
+_COMMENT = {
+    "collectionName": "comment",
+    "style": "COLLECTION",
+    "properties": {"id": {"field": "id"}, "length": {}},
+}
+_HAS_CREATOR = {
+    "edgeCollectionName": "has_creator",
+    "style": "DEDICATED_COLLECTION",
+    "domain": ["Post", "Comment"],
+    "range": "Person",
+}
+
+
+def _pg(**extra) -> MappingResolver:
+    return MappingResolver(
+        _bundle(
+            {
+                "Post": _POST,
+                "Comment": _COMMENT,
+                "Person": {"collectionName": "person", "style": "COLLECTION"},
+                "Message": {"style": "UNION", "members": ["Post", "Comment"]},
+                **extra,
+            },
+            {"HAS_CREATOR": _HAS_CREATOR},
+        )
+    )
+
+
+def test_both_styles_are_supertype_styles():
+    assert {"MULTI_LABEL", "UNION"} == SUPERTYPE_STYLES
+
+
+def test_union_members_and_is_supertype():
+    r = _pg()
+    assert r.is_supertype("Message")
+    assert not r.is_supertype("Post")
+    assert not r.is_supertype("Nowhere")
+    assert r.supertype_members("Message") == ["Post", "Comment"]
+
+
+def test_members_may_come_from_the_conceptual_subtypes():
+    r = MappingResolver(
+        _bundle(
+            {
+                "Post": {
+                    "collectionName": "nodes",
+                    "style": "LABEL",
+                    "typeField": "type",
+                    "typeValue": "Post",
+                },
+                "Comment": {
+                    "collectionName": "nodes",
+                    "style": "LABEL",
+                    "typeField": "type",
+                    "typeValue": "Comment",
+                },
+                "Message": {
+                    "style": "MULTI_LABEL",
+                    "collectionName": "nodes",
+                    "labelsField": "labels",
+                    "labelValue": "Message",
+                },
+            },
+            conceptual={"entities": [{"name": "Message", "subtypes": ["Post", "Comment"]}]},
+        )
+    )
+    assert r.supertype_members("Message") == ["Post", "Comment"]
+
+
+def test_nested_supertypes_are_flattened_without_duplicates():
+    r = _pg(
+        Reply={"style": "UNION", "members": ["Comment"]},
+        Content={"style": "UNION", "members": ["Message", "Reply", "Post"]},
+    )
+    assert r.supertype_members("Content") == ["Post", "Comment"]
+
+
+@pytest.mark.parametrize(
+    "extra,needle",
+    [
+        ({"Message": {"style": "UNION", "members": ["Post", "Ghost"]}}, "'Ghost', which is not mapped"),
+        ({"Message": {"style": "UNION"}}, "declares no members"),
+        (
+            {
+                "Message": {"style": "UNION", "members": ["Thread"]},
+                "Thread": {"style": "UNION", "members": ["Message"]},
+            },
+            "cycle",
+        ),
+    ],
+)
+def test_invalid_hierarchies_are_refused(extra, needle):
+    r = _pg(**extra)
+    with pytest.raises(CoreError) as exc:
+        r.supertype_members("Message")
+    assert exc.value.code == "INVALID_MAPPING"
+    assert needle in str(exc.value)
+
+
+def test_a_concrete_label_is_not_a_supertype():
+    with pytest.raises(CoreError, match="is not a supertype"):
+        _pg().supertype_members("Post")
+
+
+def test_supertype_without_properties_has_its_members_properties():
+    props = _pg().resolve_properties("Message")
+    assert set(props) == {"id", "imageFile", "length"}
+
+
+def test_an_edge_whose_endpoints_are_all_members_guarantees_the_supertype():
+    r = _pg()
+    assert r.edge_constrains_target("HAS_CREATOR", "Message", "INBOUND")
+    assert r.edge_constrains_target("HAS_CREATOR", "Person", "OUTBOUND")
+
+
+def test_an_edge_that_can_reach_a_non_member_does_not():
+    r = _pg(Forum={"collectionName": "forum", "style": "COLLECTION"})
+    r.bundle.physical_mapping["relationships"]["HAS_TAG"] = {
+        "edgeCollectionName": "has_tag",
+        "style": "DEDICATED_COLLECTION",
+        "domain": ["Forum", "Post", "Comment"],
+        "range": "Tag",
+    }
+    assert not r.edge_constrains_target("HAS_TAG", "Message", "INBOUND")
+
+
+def test_existing_mappings_are_unaffected():
+    r = MappingResolver(_bundle({"Post": _POST}))
+    assert not r.is_supertype("Post")
+    assert set(r.resolve_properties("Post")) == {"id", "imageFile"}
+
+
+def test_union_and_multi_label_round_trip_through_owl_as_subclasses():
+    from arango_query_core import mapping_to_turtle, turtle_to_mapping
+
+    bundle = _bundle(
+        {
+            "Post": {"collectionName": "post", "style": "COLLECTION"},
+            "Comment": {"collectionName": "comment", "style": "COLLECTION"},
+            "Message": {"style": "UNION", "members": ["Post", "Comment"]},
+            "Thing": {
+                "style": "MULTI_LABEL",
+                "collectionName": "nodes",
+                "labelsField": "labels",
+                "labelValue": "Thing",
+            },
+        },
+        conceptual={
+            "entities": [
+                {"name": "Post"},
+                {"name": "Comment"},
+                {"name": "Message"},
+                {"name": "Thing", "subtypes": ["Post"]},
+            ],
+            "relationships": [],
+        },
+    )
+    turtle = mapping_to_turtle(bundle)
+    assert ":Post rdfs:subClassOf :Message ." in turtle
+    back = turtle_to_mapping(turtle)
+    pm = back.physical_mapping["entities"]
+    assert pm["Message"] == {"style": "UNION", "members": ["Post", "Comment"]}
+    assert pm["Thing"]["labelsField"] == "labels" and pm["Thing"]["labelValue"] == "Thing"
+    r = MappingResolver(back)
+    assert r.supertype_members("Message") == ["Post", "Comment"]
+    assert r.supertype_members("Thing") == ["Post"]