django-gisserver 1.4.1__py3-none-any.whl → 2.0__py3-none-any.whl

gisserver/output/gml32.py

@@ -11,6 +11,7 @@ much extra method calls per field. Some bits are non-DRY inlined for this reason
 from __future__ import annotations
 
 import itertools
+from collections import defaultdict
 from datetime import date, datetime, time, timezone
 from decimal import Decimal as D
 from io import StringIO
@@ -18,29 +19,33 @@ from operator import itemgetter
 from typing import cast
 
 from django.contrib.gis import geos
+from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.http import HttpResponse
 
 from gisserver.db import (
     AsGML,
-    build_db_annotations,
-    conditional_transform,
-    get_db_annotation,
-    get_db_geometry_selects,
     get_db_geometry_target,
+    get_db_rendered_geometry,
     get_geometries_union,
+    replace_queryset_geometries,
 )
-from gisserver.exceptions import NotFound
-from gisserver.features import FeatureRelation, FeatureType
-from gisserver.geometries import CRS
-from gisserver.parsers.fes20 import ValueReference
-from gisserver.types import XsdComplexType, XsdElement, XsdNode
+from gisserver.exceptions import NotFound, WFSException
+from gisserver.geometries import BoundingBox
+from gisserver.parsers.xml import xmlns
+from gisserver.projection import FeatureProjection, FeatureRelation
+from gisserver.types import GeometryXsdElement, GmlBoundedByElement, XsdElement, XsdNode, XsdTypes
 
-from .base import OutputRenderer
+from .base import CollectionOutputRenderer, XmlOutputRenderer
 from .results import SimpleFeatureCollection
+from .utils import (
+    attr_escape,
+    tag_escape,
+    value_to_text,
+    value_to_xml_string,
+)
 
 GML_RENDER_FUNCTIONS = {}
-AUTO_STR = (int, float, D, date, time)
 
 
 def register_geos_type(geos_type):
@@ -51,55 +56,62 @@ def register_geos_type(geos_type):
     return _inc
 
 
-def _tag_escape(s: str):
-    return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-
-def _attr_escape(s: str):
-    # Slightly faster then html.escape() as it doesn't replace single quotes.
-    # Having tried all possible variants, this code still outperforms other forms of escaping.
-    return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
-
-
-def _value_to_xml_string(value):
-    # Simple scalar value
-    if isinstance(value, str):  # most cases
-        return _tag_escape(value)
-    elif isinstance(value, datetime):
-        return value.astimezone(timezone.utc).isoformat()
-    elif isinstance(value, bool):
-        return "true" if value else "false"
-    elif isinstance(value, AUTO_STR):
-        return value  # no need for _tag_escape(), and f"{value}" works faster.
-    else:
-        return _tag_escape(str(value))
-
-
-def _value_to_text(value):
-    # Simple scalar value, no XML escapes
-    if isinstance(value, str):  # most cases
-        return value
-    elif isinstance(value, datetime):
-        return value.astimezone(timezone.utc).isoformat()
-    elif isinstance(value, bool):
-        return "true" if value else "false"
-    else:
-        return value  # f"{value} works faster and produces the right format.
-
-
-class GML32Renderer(OutputRenderer):
+class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
     """Render the GetFeature XML output in GML 3.2 format"""
 
     content_type = "text/xml; charset=utf-8"
+    content_disposition = 'inline; filename="{typenames} {page} {date}.xml"'
     xml_collection_tag = "FeatureCollection"
+    xml_sub_collection_tag = "FeatureCollection"  # Mapserver does not use SimpleFeatureCollection
     chunk_size = 40_000
     gml_seq = 0
 
+    # Aliases to use for XML namespaces
+    xml_namespaces = {
+        "http://www.opengis.net/wfs/2.0": "wfs",
+        "http://www.opengis.net/gml/3.2": "gml",
+        "http://www.w3.org/2001/XMLSchema-instance": "xsi",  # for xsi:nil="true" and xsi:schemaLocation.
+    }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.feature_types = [
+            feature_type
+            for sub_collection in self.collection.results
+            for feature_type in sub_collection.feature_types
+        ]
+
+        self.build_namespace_map()
+
+    def build_namespace_map(
+        self,
+    ):
+        """Collect all namespaces which namespaces are used by features."""
+        try:
+            # Make aliases for the feature type elements.
+            self.feature_qnames = {
+                feature_type: self.feature_to_qname(feature_type)
+                for feature_type in self.feature_types
+            }
+            self.xml_qnames = self._build_xml_qnames()
+        except KeyError as e:
+            raise ImproperlyConfigured(f"No XML namespace alias defined in WFSView for {e}") from e
+
+    def _build_xml_qnames(self) -> dict[XsdNode, str]:
+        """Collect aliases for all rendered elements.
+        This uses a defaultdict so optional attributes (e.g. by GetPropertyValue) can also be resolved.
+        The dict lookup also speeds up, no need to call ``node_to_qname()`` for each tag.
+        """
+        known_tags = {
+            xsd_element: self.to_qname(xsd_element)
+            for sub_collection in self.collection.results
+            for xsd_element in sub_collection.projection.all_elements
+        }
+        return defaultdict(self.to_qname, known_tags)
+
     def get_response(self):
         """Render the output as streaming response."""
-        from gisserver.queries import GetFeatureById
-
-        if isinstance(self.source_query, GetFeatureById):
+        if self.collection.results and self.collection.results[0].projection.output_standalone:
             # WFS spec requires that GetFeatureById output only returns the contents.
             # The streaming response is avoided here, to allow returning a 404.
             return self.get_by_id_response()
@@ -110,15 +122,18 @@ class GML32Renderer(OutputRenderer):
     def get_by_id_response(self):
         """Render a standalone item, for GetFeatureById"""
         sub_collection = self.collection.results[0]
+        sub_collection.source_query.finalize_results(sub_collection)  # Allow 404
         self.start_collection(sub_collection)
+
         instance = sub_collection.first()
         if instance is None:
             raise NotFound("Feature not found.")
 
+        self.app_namespaces.pop(xmlns.wfs20.value)  # not rendering wfs tags.
         self.output = StringIO()
         self._write = self.output.write
         self.write_by_id_response(
-            sub_collection, instance, extra_xmlns=self.render_xmlns_standalone()
+            sub_collection, instance, extra_xmlns=f" {self.render_xmlns_attributes()}"
         )
         content = self.output.getvalue()
         return HttpResponse(content, content_type=self.content_type)
@@ -127,40 +142,59 @@ class GML32Renderer(OutputRenderer):
         """Default behavior for standalone response is writing a feature (can be changed by GetPropertyValue)"""
         self._write('<?xml version="1.0" encoding="UTF-8"?>\n')
         self.write_feature(
-            feature_type=sub_collection.feature_type,
+            projection=sub_collection.projection,
             instance=instance,
             extra_xmlns=extra_xmlns,
         )
 
-    def render_xmlns(self):
-        """Generate the xmlns block that the document needs"""
-        xsd_typenames = ",".join(
-            sub_collection.feature_type.name for sub_collection in self.collection.results
-        )
-        schema_location = [
-            f"{self.app_xml_namespace} {self.server_url}?SERVICE=WFS&VERSION=2.0.0&REQUEST=DescribeFeatureType&TYPENAMES={xsd_typenames}",  # noqa: E501
+    def render_xsi_schema_location(self):
+        """Render the value for the xsi:schemaLocation="..." block."""
+        # Find which namespaces are exposed
+        types_by_namespace = defaultdict(list)
+        for feature_type in self.feature_types:
+            types_by_namespace[feature_type.xml_namespace].append(feature_type)
+
+        # Schema location are pairs of "{namespace-uri} {schema-url} {namespace-uri2} {schema-url2}"
+        # WFS server types refer to the endpoint that generates the XML Schema for the given feature.
+        schema_locations = []
+        for xml_namespace, feature_types in types_by_namespace.items():
+            schema_locations.append(xml_namespace)
+            schema_locations.append(self.operation.view.get_xml_schema_url(feature_types))
+
+        schema_locations += [
             "http://www.opengis.net/wfs/2.0 http://schemas.opengis.net/wfs/2.0/wfs.xsd",
             "http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd",
         ]
+        return " ".join(schema_locations)
 
-        return (
-            'xmlns:wfs="http://www.opengis.net/wfs/2.0" '
-            'xmlns:gml="http://www.opengis.net/gml/3.2" '
-            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
-            'xmlns:app="{app_xml_namespace}" '
-            'xsi:schemaLocation="{schema_location}"'
-        ).format(
-            app_xml_namespace=_attr_escape(self.app_xml_namespace),
-            schema_location=_attr_escape(" ".join(schema_location)),
-        )
+    def render_exception(self, exception: Exception):
+        """Render the exception in a format that fits with the output.
 
-    def render_xmlns_standalone(self):
-        """Generate the xmlns block that the document needs"""
-        # xsi is needed for "xsi:nil="true"' attributes.
+        The WSF XSD spec has a hidden gem: an <wfs:truncatedResponse> element
+        can be rendered at the end of a feature collection
+        to inform the client an error happened during rendering.
+        """
+        message = super().render_exception(exception)
+        buffer = self.output.getvalue()
+
+        # Wrap into <ows:ExceptionReport> tag.
+        if not isinstance(exception, WFSException):
+            exception = WFSException(message, code=exception.__class__.__name__, status_code=500)
+        exception.debug_hint = False
+
+        # Only at the top-level, an exception report can be rendered
+        closing_child = (
+            f"</wfs:{self.xml_sub_collection_tag}></wfs:member>\n"
+            if len(self.collection.results) > 1
+            else ""
+        )
         return (
-            f' xmlns:app="{_attr_escape(self.app_xml_namespace)}"'
-            ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'
-            ' xmlns:gml="http://www.opengis.net/gml/3.2"'
+            f"{buffer}"
+            f"{closing_child}"
+            "  <wfs:truncatedResponse>"
+            f"{exception.as_xml()}"
+            "  </wfs:truncatedResponse>\n"
+            f"</wfs:{self.xml_collection_tag}>\n"
         )
 
     def render_stream(self):
@@ -170,19 +204,19 @@ class GML32Renderer(OutputRenderer):
         collection = self.collection
         self.output = output = StringIO()
         self._write = self.output.write
-        xmlns = self.render_xmlns().strip()
         number_matched = collection.number_matched
         number_matched = int(number_matched) if number_matched is not None else "unknown"
         number_returned = collection.number_returned
         next = previous = ""
         if collection.next:
-            next = f' next="{_attr_escape(collection.next)}"'
+            next = f' next="{attr_escape(collection.next)}"'
         if collection.previous:
-            previous = f' previous="{_attr_escape(collection.previous)}"'
+            previous = f' previous="{attr_escape(collection.previous)}"'
 
         self._write(
             f"""<?xml version='1.0' encoding="UTF-8" ?>\n"""
-            f"<wfs:{self.xml_collection_tag} {xmlns}"
+            f"<wfs:{self.xml_collection_tag} {self.render_xmlns_attributes()}"
+            f' xsi:schemaLocation="{attr_escape(self.render_xsi_schema_location())}"'
             f' timeStamp="{collection.timestamp}"'
             f' numberMatched="{number_matched}"'
             f' numberReturned="{int(number_returned)}"'
@@ -193,11 +227,12 @@ class GML32Renderer(OutputRenderer):
             has_multiple_collections = len(collection.results) > 1
 
             for sub_collection in collection.results:
+                projection = sub_collection.projection
                 self.start_collection(sub_collection)
                 if has_multiple_collections:
                     self._write(
                         f"<wfs:member>\n"
-                        f"<wfs:{self.xml_collection_tag}"
+                        f"<wfs:{self.xml_sub_collection_tag}"
                         f' timeStamp="{collection.timestamp}"'
                         f' numberMatched="{int(sub_collection.number_matched)}"'
                         f' numberReturned="{int(sub_collection.number_returned)}">\n'
@@ -206,7 +241,7 @@ class GML32Renderer(OutputRenderer):
                 for instance in sub_collection:
                     self.gml_seq = 0  # need to increment this between write_xml_field calls
                     self._write("<wfs:member>\n")
-                    self.write_feature(sub_collection.feature_type, instance)
+                    self.write_feature(projection, instance)
                     self._write("</wfs:member>\n")
 
                     # Only perform a 'yield' every once in a while,
@@ -218,7 +253,7 @@ class GML32Renderer(OutputRenderer):
                         yield xml_chunk
 
                 if has_multiple_collections:
-                    self._write(f"</wfs:{self.xml_collection_tag}>\n</wfs:member>\n")
+                    self._write(f"</wfs:{self.xml_sub_collection_tag}>\n</wfs:member>\n")
 
         self._write(f"</wfs:{self.xml_collection_tag}>\n")
         yield output.getvalue()
@@ -227,86 +262,66 @@ class GML32Renderer(OutputRenderer):
         """Hook to allow initialization per feature type"""
 
     def write_feature(
-        self, feature_type: FeatureType, instance: models.Model, extra_xmlns=""
+        self, projection: FeatureProjection, instance: models.Model, extra_xmlns=""
     ) -> None:
         """Write the contents of the object value.
 
         This output is typically wrapped in <wfs:member> tags
         unless it's used for a GetPropertyById response.
         """
-        # Write <app:FeatureTypeName> start node
-        pk = _tag_escape(str(instance.pk))
-        self._write(f'<{feature_type.xml_name} gml:id="{feature_type.name}.{pk}"{extra_xmlns}>\n')
+        feature_type = projection.feature_type
+        feature_xml_qname = self.feature_qnames[feature_type]
 
+        # Write <app:FeatureTypeName> start node
+        pk = tag_escape(str(instance.pk))
+        self._write(f'<{feature_xml_qname} gml:id="{feature_type.name}.{pk}"{extra_xmlns}>\n')
         # Write all fields, both base class and local elements.
-        for xsd_element in feature_type.xsd_type.all_elements:
+        for xsd_element in projection.xsd_root_elements:
             # Note that writing 5000 features with 30 tags means this code make 150.000 method calls.
             # Hence, branching to different rendering styles is branched here instead of making such
             # call into a generic "write_field()" function and stepping out from there.
-            if xsd_element.is_geometry:
-                if xsd_element.xml_name == "gml:boundedBy":
-                    # Special case for <gml:boundedBy>, so it will render with
-                    # the output CRS and can be overwritten with DB-rendered GML.
-                    self.write_bounds(feature_type, instance)
-                else:
-                    # Separate call which can be optimized (no need to overload write_xml_field() for all calls).
-                    self.write_gml_field(feature_type, xsd_element, instance)
+
+            if xsd_element.type.is_geometry:
+                # Separate call which can be optimized (no need to overload write_xml_field() for all calls).
+                self.write_gml_field(projection, xsd_element, instance)
             else:
                 value = xsd_element.get_value(instance)
                 if xsd_element.is_many:
-                    self.write_many(feature_type, xsd_element, value)
+                    self.write_many(projection, xsd_element, value)
                 else:
                     # e.g. <gml:name>, or all other <app:...> nodes.
-                    self.write_xml_field(feature_type, xsd_element, value)
-
-        self._write(f"</{feature_type.xml_name}>\n")
-
-    def write_bounds(self, feature_type, instance) -> None:
-        """Render the GML bounds for the complete instance"""
-        envelope = feature_type.get_envelope(instance, self.output_crs)
-        if envelope is not None:
-            lower = " ".join(map(str, envelope.lower_corner))
-            upper = " ".join(map(str, envelope.upper_corner))
-            self._write(
-                f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{self.xml_srs_name}">
-                <gml:lowerCorner>{lower}</gml:lowerCorner>
-                <gml:upperCorner>{upper}</gml:upperCorner>
-              </gml:Envelope></gml:boundedBy>\n"""
-            )
+                    self.write_xml_field(projection, xsd_element, value)
+
+        self._write(f"</{feature_xml_qname}>\n")
 
-    def write_many(self, feature_type: FeatureType, xsd_element: XsdElement, value) -> None:
+    def write_many(self, projection: FeatureProjection, xsd_element: XsdElement, value) -> None:
         """Write a node that has multiple values (e.g. array or queryset)."""
         # some <app:...> node that has multiple values
         if value is None:
             # No tag for optional element (see PropertyIsNull), otherwise xsi:nil node.
             if xsd_element.min_occurs:
-                self._write(f'<{xsd_element.xml_name} xsi:nil="true"/>\n')
+                xml_qname = self.xml_qnames[xsd_element]
+                self._write(f'<{xml_qname} xsi:nil="true"/>\n')
         else:
-            # Render the tag multiple times
-            if xsd_element.type.is_complex_type:
-                # If the retrieved QuerySet was not filtered yet, do so now. This can't
-                # be done in get_value() because the FeatureType is not known there.
-                value = feature_type.filter_related_queryset(value)
-
             for item in value:
-                self.write_xml_field(feature_type, xsd_element, value=item)
+                self.write_xml_field(projection, xsd_element, value=item)
 
     def write_xml_field(
-        self, feature_type: FeatureType, xsd_element: XsdElement, value, extra_xmlns=""
+        self, projection: FeatureProjection, xsd_element: XsdElement, value, extra_xmlns=""
     ):
         """Write the value of a single field."""
-        xml_name = xsd_element.xml_name
+        xml_qname = self.xml_qnames[xsd_element]
         if value is None:
-            self._write(f'<{xml_name} xsi:nil="true"{extra_xmlns}/>\n')
+            self._write(f'<{xml_qname} xsi:nil="true"{extra_xmlns}/>\n')
         elif xsd_element.type.is_complex_type:
             # Expanded foreign relation / dictionary
-            self.write_xml_complex_type(feature_type, xsd_element, value, extra_xmlns=extra_xmlns)
+            self.write_xml_complex_type(projection, xsd_element, value, extra_xmlns=extra_xmlns)
         else:
             # As this is likely called 150.000 times during a request, this is optimized.
-            # Avoided a separate call to _value_to_xml_string() and avoided isinstance() here.
+            # Avoided a separate call to value_to_xml_string() and avoided isinstance() here.
             value_cls = value.__class__
             if value_cls is str:  # most cases
-                value = _tag_escape(value)
+                value = tag_escape(value)
             elif value_cls is datetime:
                 value = value.astimezone(timezone.utc).isoformat()
             elif value_cls is bool:
@@ -320,49 +335,88 @@ class GML32Renderer(OutputRenderer):
             ):
                 # Non-string or custom field that extended a scalar.
                 # Any of the other types have a faster f"{value}" translation that produces the correct text.
-                value = _value_to_xml_string(value)
+                value = value_to_xml_string(value)
 
-            self._write(f"<{xml_name}{extra_xmlns}>{value}</{xml_name}>\n")
+            self._write(f"<{xml_qname}{extra_xmlns}>{value}</{xml_qname}>\n")
 
-    def write_xml_complex_type(self, feature_type, xsd_element, value, extra_xmlns="") -> None:
+    def write_xml_complex_type(
+        self, projection: FeatureProjection, xsd_element: XsdElement, value, extra_xmlns=""
+    ) -> None:
         """Write a single field, that consists of sub elements"""
-        xsd_type = cast(XsdComplexType, xsd_element.type)
-        self._write(f"<{xsd_element.xml_name}{extra_xmlns}>\n")
-        for sub_element in xsd_type.elements:
-            sub_value = sub_element.get_value(value)
-            if sub_element.is_many:
-                self.write_many(feature_type, sub_element, sub_value)
+        xml_qname = self.xml_qnames[xsd_element]
+        self._write(f"<{xml_qname}{extra_xmlns}>\n")
+        for sub_element in projection.xsd_child_nodes[xsd_element]:
+            if sub_element.type.is_geometry:
+                # Separate call which can be optimized (no need to overload write_xml_field() for all calls).
+                self.write_gml_field(projection, sub_element, value)
             else:
-                self.write_xml_field(feature_type, sub_element, sub_value)
-        self._write(f"</{xsd_element.xml_name}>\n")
+                sub_value = sub_element.get_value(value)
+                if sub_element.is_many:
+                    self.write_many(projection, sub_element, sub_value)
+                else:
+                    self.write_xml_field(projection, sub_element, sub_value)
+        self._write(f"</{xml_qname}>\n")
 
     def write_gml_field(
-        self, feature_type, xsd_element: XsdElement, instance: models.Model, extra_xmlns=""
+        self,
+        projection: FeatureProjection,
+        geo_element: GeometryXsdElement,
+        instance: models.Model,
+        extra_xmlns="",
     ) -> None:
         """Separate method to allow overriding this for db-performance optimizations."""
-        # Need to have instance.pk data here (and instance['pk'] for value rendering)
-        value = xsd_element.get_value(instance)
-        xml_name = xsd_element.xml_name
-        if value is None:
-            # Avoid incrementing gml_seq
-            self._write(f'<{xml_name} xsi:nil="true"{extra_xmlns}/>\n')
-            return
+        if geo_element.type is XsdTypes.gmlBoundingShapeType:
+            # Special case for <gml:boundedBy>, which doesn't need xsd:nil values, nor a gml:id.
+            # The value is not a GEOSGeometry either, as that is not exposed by django.contrib.gis.
+            value = cast(GmlBoundedByElement, geo_element).get_value(
+                instance, crs=projection.output_crs
+            )
+            if value is not None:
+                self._write(self.render_gml_bounds(value))
+        else:
+            # Regular geometry elements.
+            xml_qname = self.xml_qnames[geo_element]
+            value = geo_element.get_value(instance)
+            if value is None:
+                # Avoid incrementing gml_seq
+                self._write(f'<{xml_qname} xsi:nil="true"{extra_xmlns}/>\n')
+            else:
+                gml_id = self.get_gml_id(instance._meta.object_name, instance.pk)
 
-        gml_id = self.get_gml_id(feature_type, instance.pk)
+                # the following is somewhat faster, but will render GML 2, not GML 3.2:
+                # gml = value.ogr.gml
+                # pos = gml.find(">")  # Will inject the gml:id="..." tag.
+                # gml = f"{gml[:pos]} gml:id="{attr_escape(gml_id)}"{gml[pos:]}"
 
-        # the following is somewhat faster, but will render GML 2, not GML 3.2:
-        # gml = value.ogr.gml
-        # pos = gml.find(">")  # Will inject the gml:id="..." tag.
-        # gml = f"{gml[:pos]} gml:id="{_attr_escape(gml_id)}"{gml[pos:]}"
+                gml = self.render_gml_value(projection, gml_id, value)
+                self._write(f"<{xml_qname}{extra_xmlns}>{gml}</{xml_qname}>\n")
 
-        gml = self.render_gml_value(gml_id, value)
-        self._write(f"<{xml_name}{extra_xmlns}>{gml}</{xml_name}>\n")
+    def get_gml_id(self, prefix: str, object_id) -> str:
+        """Generate the gml:id value, which is required for GML 3.2 objects."""
+        self.gml_seq += 1
+        return f"{prefix}.{object_id}.{self.gml_seq}"
 
-    def render_gml_value(self, gml_id, value: geos.GEOSGeometry | None, extra_xmlns="") -> str:
+    def render_gml_bounds(self, envelope: BoundingBox) -> str:
+        """Render the gml:boundedBy element that contains an Envelope.
+        Note this uses an internal object type,
+        as :mod:`django.contrib.gis.geos` only provides a Point/Polygon or 4-tuple envelope.
+        """
+        return f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{attr_escape(envelope.crs.urn)}">
+            <gml:lowerCorner>{envelope.south} {envelope.west}</gml:lowerCorner>
+            <gml:upperCorner>{envelope.north} {envelope.east}</gml:upperCorner>
+          </gml:Envelope></gml:boundedBy>\n"""
+
+    def render_gml_value(
+        self,
+        projection: FeatureProjection,
+        gml_id,
+        value: geos.GEOSGeometry | None,
+        extra_xmlns="",
+    ) -> str:
         """Normal case: 'value' is raw geometry data.."""
         # In case this is a standalone response, this will be the top-level element, hence includes the xmlns.
-        base_attrs = f' gml:id="{_attr_escape(gml_id)}" srsName="{self.xml_srs_name}"{extra_xmlns}'
-        self.output_crs.apply_to(value)
+        base_attrs = f' gml:id="{attr_escape(gml_id)}" srsName="{attr_escape(projection.output_crs.urn)}"{extra_xmlns}'
+        projection.output_crs.apply_to(value)
         return self._render_gml_type(value, base_attrs=base_attrs)
 
     def _render_gml_type(self, value: geos.GEOSGeometry, base_attrs=""):
@@ -397,11 +451,16 @@ class GML32Renderer(OutputRenderer):
         buf.write("</gml:Polygon>")
         return buf.getvalue()
 
-    @register_geos_type(geos.MultiPolygon)
+    @register_geos_type(geos.GeometryCollection)
     def render_gml_multi_geometry(self, value: geos.GeometryCollection, base_attrs):
         children = "".join(self._render_gml_type(child) for child in value)
         return f"<gml:MultiGeometry{base_attrs}>{children}</gml:MultiGeometry>"
 
+    @register_geos_type(geos.MultiPolygon)
+    def render_gml_multi_polygon(self, value: geos.GeometryCollection, base_attrs):
+        children = "".join(self._render_gml_type(child) for child in value)
+        return f"<gml:MultiPolygon{base_attrs}>{children}</gml:MultiPolygon>"
+
     @register_geos_type(geos.MultiLineString)
     def render_gml_multi_line_string(self, value: geos.MultiPoint, base_attrs):
         children = "</gml:lineStringMember><gml:lineStringMember>".join(
@@ -447,15 +506,10 @@ class GML32Renderer(OutputRenderer):
             "</gml:LineString>"
         )
 
-    def get_gml_id(self, feature_type: FeatureType, object_id) -> str:
-        """Generate the gml:id value, which is required for GML 3.2 objects."""
-        self.gml_seq += 1
-        return f"{feature_type.name}.{object_id}.{self.gml_seq}"
-
 
 class DBGMLRenderingMixin:
 
-    def render_gml_value(self, gml_id, value: str, extra_xmlns=""):
+    def render_gml_value(self, projection, gml_id, value: str, extra_xmlns=""):
         """DB optimized: 'value' is pre-rendered GML XML string."""
         # Write the gml:id inside the first tag
         end_pos = value.find(">")
@@ -463,13 +517,13 @@ class DBGMLRenderingMixin:
         id_pos = gml_tag.find("gml:id=")
         if id_pos == -1:
             # Inject
-            return f'{gml_tag} gml:id="{_attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
+            return f'{gml_tag} gml:id="{attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
         else:
             # Replace
             end_pos1 = gml_tag.find('"', id_pos + 8)
             return (
                 f"{gml_tag[:id_pos]}"
-                f'gml:id="{_attr_escape(gml_id)}'
+                f'gml:id="{attr_escape(gml_id)}'
                 f"{value[end_pos1:end_pos]}"  # from " right until >
                 f"{extra_xmlns}"  # extra namespaces?
                 f"{value[end_pos:]}"  # from > and beyond
@@ -479,111 +533,89 @@ class DBGMLRenderingMixin:
 class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
     """Faster GetFeature renderer that uses the database to render GML 3.2"""
 
-    @classmethod
-    def decorate_queryset(
-        cls,
-        feature_type: FeatureType,
-        queryset: models.QuerySet,
-        output_crs: CRS,
-        **params,
-    ):
+    def decorate_queryset(self, projection: FeatureProjection, queryset: models.QuerySet):
         """Update the queryset to let the database render the GML output.
-        This is far more efficient then GeoDjango's logic, which performs a
+        This is far more efficient than GeoDjango's logic, which performs a
         C-API call for every single coordinate of a geometry.
         """
-        queryset = super().decorate_queryset(feature_type, queryset, output_crs, **params)
+        queryset = super().decorate_queryset(projection, queryset)
 
-        # Retrieve geometries as pre-rendered instead.
-        gml_elements = feature_type.xsd_type.geometry_elements
-        geo_selects = get_db_geometry_selects(gml_elements, output_crs)
-        if geo_selects:
-            queryset = queryset.defer(*geo_selects.keys()).annotate(
-                _as_envelope_gml=cls.get_db_envelope_as_gml(feature_type, queryset, output_crs),
-                **build_db_annotations(geo_selects, "_as_gml_{name}", AsGML),
+        # Retrieve gml:boundedBy in pre-rendered format.
+        if projection.has_bounded_by:
+            queryset = queryset.annotate(
+                _as_envelope_gml=self.get_db_envelope_as_gml(projection, queryset),
             )
 
-        return queryset
+        # Retrieve geometries as pre-rendered instead.
+        # Only take the geometries of the current level.
+        # The annotations for relations will be handled by prefetches and get_prefetch_queryset()
+        return replace_queryset_geometries(
+            queryset, projection.geometry_elements, projection.output_crs, AsGML
+        )
 
-    @classmethod
     def get_prefetch_queryset(
-        cls,
-        feature_type: FeatureType,
+        self,
+        projection: FeatureProjection,
         feature_relation: FeatureRelation,
-        output_crs: CRS,
     ) -> models.QuerySet | None:
         """Perform DB annotations for prefetched relations too."""
-        base = super().get_prefetch_queryset(feature_type, feature_relation, output_crs)
-        if base is None:
+        queryset = super().get_prefetch_queryset(projection, feature_relation)
+        if queryset is None:
             return None
 
         # Find which fields are GML elements
-        gml_elements = []
-        for e in feature_relation.xsd_elements:
-            if e.is_geometry:
-                # Prefetching a flattened relation
-                gml_elements.append(e)
-            elif e.type.is_complex_type:
-                # Prefetching a complex type
-                xsd_type: XsdComplexType = cast(XsdComplexType, e.type)
-                gml_elements.extend(xsd_type.geometry_elements)
-
-        geometries = get_db_geometry_selects(gml_elements, output_crs)
-        if geometries:
-            # Exclude geometries from the fields, fetch them as pre-rendered annotations instead.
-            return base.defer(geometries.keys()).annotate(
-                **build_db_annotations(geometries, "_as_gml_{name}", AsGML),
-            )
-        else:
-            return base
+        return replace_queryset_geometries(
+            queryset, feature_relation.geometry_elements, projection.output_crs, AsGML
+        )
 
-    @classmethod
-    def get_db_envelope_as_gml(cls, feature_type, queryset, output_crs) -> AsGML:
+    def get_db_envelope_as_gml(self, projection: FeatureProjection, queryset) -> AsGML:
         """Offload the GML rendering of the envelope to the database.
 
         This also avoids offloads the geometry union calculation to the DB.
         """
-        geo_fields_union = cls._get_geometries_union(feature_type, queryset, output_crs)
+        geo_fields_union = self._get_geometries_union(projection, queryset)
         return AsGML(geo_fields_union, envelope=True)
 
-    @classmethod
-    def _get_geometries_union(cls, feature_type: FeatureType, queryset, output_crs):
+    def _get_geometries_union(self, projection: FeatureProjection, queryset):
         """Combine all geometries of the model in a single SQL function."""
         # Apply transforms where needed, in case some geometries use a different SRID.
         return get_geometries_union(
             [
-                conditional_transform(
-                    model_field.name,
-                    model_field.srid,
-                    output_srid=output_crs.srid,
-                )
-                for model_field in feature_type.geometry_fields
+                get_db_geometry_target(geo_element, output_crs=projection.output_crs)
+                for geo_element in projection.all_geometry_elements
+                if geo_element.source is not None  # excludes GmlBoundedByElement
             ],
             using=queryset.db,
         )
 
     def write_gml_field(
-        self, feature_type, xsd_element: XsdElement, instance: models.Model, extra_xmlns=""
+        self,
+        projection: FeatureProjection,
+        geo_element: GeometryXsdElement,
+        instance: models.Model,
+        extra_xmlns="",
     ) -> None:
         """Write the value of an GML tag.
 
         This optimized version takes a pre-rendered XML from the database query.
         """
-        value = get_db_annotation(instance, xsd_element.name, "_as_gml_{name}")
-        xml_name = xsd_element.xml_name
-        if value is None:
-            # Avoid incrementing gml_seq
-            self._write(f'<{xml_name} xsi:nil="true"{extra_xmlns}/>\n')
-            return
+        xml_qname = self.xml_qnames[geo_element]
+        if geo_element.type is XsdTypes.gmlBoundingShapeType:
+            gml = instance._as_envelope_gml
+            if gml is None:
+                return
+        else:
+            value = get_db_rendered_geometry(instance, geo_element, AsGML)
+            if value is None:
+                # Avoid incrementing gml_seq, make nil tag.
+                self._write(f'<{xml_qname} xsi:nil="true"{extra_xmlns}/>\n')
+                return
 
-        gml_id = self.get_gml_id(feature_type, instance.pk)
-        gml = self.render_gml_value(gml_id, value, extra_xmlns=extra_xmlns)
-        self._write(f"<{xml_name}{extra_xmlns}>{gml}</{xml_name}>\n")
+            # Get gml tag to write as value.
+            gml_id = self.get_gml_id(instance._meta.object_name, instance.pk)
+            gml = self.render_gml_value(projection, gml_id, value, extra_xmlns=extra_xmlns)
 
-    def write_bounds(self, feature_type, instance) -> None:
-        """Generate the <gml:boundedBy> from DB prerendering."""
-        gml = instance._as_envelope_gml
-        if gml is not None:
-            self._write(f"<gml:boundedBy>{gml}</gml:boundedBy>\n")
+        self._write(f"<{xml_qname}{extra_xmlns}>{gml}</{xml_qname}>\n")
 
 
 class GML32ValueRenderer(GML32Renderer):
@@ -596,67 +628,55 @@ class GML32ValueRenderer(GML32Renderer):
 
     content_type = "text/xml; charset=utf-8"
     content_type_plain = "text/plain; charset=utf-8"
+    content_disposition = 'inline; filename="{typenames} {page} {date}-value.xml"'
+    content_disposition_plain = 'inline; filename="{typenames} {page} {date}-value.txt"'
     xml_collection_tag = "ValueCollection"
-    _escape_value = staticmethod(_value_to_xml_string)
+    xml_sub_collection_tag = "ValueCollection"
+    _escape_value = staticmethod(value_to_xml_string)
     gml_value_getter = itemgetter("member")
 
-    def __init__(self, *args, value_reference: ValueReference, **kwargs):
-        self.value_reference = value_reference
-        super().__init__(*args, **kwargs)
-        self.xsd_node: XsdNode | None = None
-
-    @classmethod
-    def decorate_queryset(
-        cls,
-        feature_type: FeatureType,
-        queryset: models.QuerySet,
-        output_crs: CRS,
-        **params,
-    ):
+    def decorate_queryset(self, projection: FeatureProjection, queryset: models.QuerySet):
         # Don't optimize queryset, it only retrieves one value
         # The data is already limited to a ``queryset.values()`` in ``QueryExpression.get_queryset()``.
         return queryset
 
-    def start_collection(self, sub_collection: SimpleFeatureCollection):
-        # Resolve which XsdNode is being rendered
-        match = sub_collection.feature_type.resolve_element(self.value_reference.xpath)
-        self.xsd_node = match.child
-
     def write_by_id_response(
         self, sub_collection: SimpleFeatureCollection, instance: dict, extra_xmlns
     ):
         """The value rendering only renders the value. not a complete feature"""
-        if self.xsd_node.is_attribute:
+        if sub_collection.projection.property_value_node.is_attribute:
             # Output as plain text
             self.content_type = self.content_type_plain  # change for this instance!
-            self._escape_value = _value_to_text  # avoid XML escaping
+            self.content_disposition = self.content_disposition_plain
+            self._escape_value = value_to_text  # avoid XML escaping
         else:
             self._write('<?xml version="1.0" encoding="UTF-8"?>\n')
 
         # Write the single tag, no <wfs:member> around it.
-        self.write_feature(sub_collection.feature_type, instance, extra_xmlns=extra_xmlns)
+        self.write_feature(sub_collection.projection, instance, extra_xmlns=extra_xmlns)
 
-    def write_feature(self, feature_type: FeatureType, instance: dict, extra_xmlns="") -> None:
+    def write_feature(self, projection: FeatureProjection, instance: dict, extra_xmlns="") -> None:
         """Write the XML for a single object.
         In this case, it's only a single XML tag.
         """
-        if self.xsd_node.is_geometry:
+        xsd_node = projection.property_value_node
+        if xsd_node.type.is_geometry:
             self.write_gml_field(
-                feature_type,
-                cast(XsdElement, self.xsd_node),
+                projection,
+                cast(GeometryXsdElement, xsd_node),
                 instance,
                 extra_xmlns=extra_xmlns,
             )
-        elif self.xsd_node.is_attribute:
+        elif xsd_node.is_attribute:
             value = instance["member"]
             if value is not None:
-                value = self.xsd_node.format_raw_value(instance["member"])  # for gml:id
+                value = xsd_node.format_raw_value(instance["member"])  # for gml:id
                 value = self._escape_value(value)
                 self._write(value)
-        elif self.xsd_node.is_array:
+        elif xsd_node.is_array:
             if (value := instance["member"]) is not None:
                 # <wfs:member> doesn't allow multiple items as children, for new render as separate members.
-                xml_name = self.xsd_node.xml_name
+                xml_qname = self.xml_qnames[xsd_node]
                 first = True
                 for item in value:
                     if item is not None:
@@ -664,33 +684,42 @@ class GML32ValueRenderer(GML32Renderer):
                             self._write("</wfs:member>\n<wfs:member>")
 
                         item = self._escape_value(item)
-                        self._write(f"<{xml_name}>{item}</{xml_name}>\n")
+                        self._write(f"<{xml_qname}>{item}</{xml_qname}>\n")
                         first = False
-        elif self.xsd_node.type.is_complex_type:
+        elif xsd_node.type.is_complex_type:
             raise NotImplementedError("GetPropertyValue with complex types is not implemented")
-            # self.write_xml_complex_type(feature_type, self.xsd_node, instance['member'])
+            # self.write_xml_complex_type(projection, self.xsd_node, instance['member'])
         else:
             self.write_xml_field(
-                feature_type,
-                cast(XsdElement, self.xsd_node),
+                projection,
+                cast(XsdElement, xsd_node),
                 value=instance["member"],
                 extra_xmlns=extra_xmlns,
             )
 
     def write_gml_field(
-        self, feature_type, xsd_element: XsdElement, instance: dict, extra_xmlns=""
+        self,
+        projection: FeatureProjection,
+        geo_element: GeometryXsdElement,
+        instance: dict,
+        extra_xmlns="",
     ) -> None:
         """Overwritten to allow dict access instead of model access."""
+        if geo_element.type is XsdTypes.gmlBoundingShapeType:
+            raise NotImplementedError(
+                "rendering <gml:boundedBy> in GetPropertyValue is not implemented."
+            )
+
         value = self.gml_value_getter(instance)  # "member" or "gml_member"
-        xml_name = xsd_element.xml_name
+        xml_qname = self.xml_qnames[geo_element]
         if value is None:
             # Avoid incrementing gml_seq
-            self._write(f'<{xml_name} xsi:nil="true"{extra_xmlns}/>\n')
+            self._write(f'<{xml_qname} xsi:nil="true"{extra_xmlns}/>\n')
             return
 
-        gml_id = self.get_gml_id(feature_type, instance["pk"])
-        gml = self.render_gml_value(gml_id, value, extra_xmlns=extra_xmlns)
-        self._write(f"<{xml_name}{extra_xmlns}>{gml}</{xml_name}>\n")
+        gml_id = self.get_gml_id(geo_element.source.model._meta.object_name, instance["pk"])
+        gml = self.render_gml_value(projection, gml_id, value, extra_xmlns=extra_xmlns)
+        self._write(f"<{xml_qname}{extra_xmlns}>{gml}</{xml_qname}>\n")
 
 
 class DBGML32ValueRenderer(DBGMLRenderingMixin, GML32ValueRenderer):
@@ -698,15 +727,15 @@ class DBGML32ValueRenderer(DBGMLRenderingMixin, GML32ValueRenderer):
 
     gml_value_getter = itemgetter("gml_member")
 
-    @classmethod
-    def decorate_queryset(cls, feature_type: FeatureType, queryset, output_crs, **params):
+    def decorate_queryset(self, projection: FeatureProjection, queryset):
         """Update the queryset to let the database render the GML output."""
-        value_reference = params["valueReference"]
-        match = feature_type.resolve_element(value_reference.xpath)
-        if match.child.is_geometry:
+        # As this is a classmethod, self.value_reference is not available yet.
+        element = projection.property_value_node
+        if element.type.is_geometry:
             # Add 'gml_member' to point to the pre-rendered GML version.
+            geo_element = cast(GeometryXsdElement, element)
             return queryset.values(
-                "pk", gml_member=AsGML(get_db_geometry_target(match, output_crs))
+                "pk", gml_member=AsGML(get_db_geometry_target(geo_element, projection.output_crs))
             )
         else:
             return queryset