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

gisserver/features.py

@@ -17,23 +17,26 @@ For example, model relationships can be modelled to a different XML layout.
 from __future__ import annotations
 
 import html
-import operator
-from collections import defaultdict
+import itertools
+import logging
 from dataclasses import dataclass
-from functools import cached_property, lru_cache, reduce
-from typing import Union
+from functools import cached_property, lru_cache
+from typing import TYPE_CHECKING, Literal, Union
 
-from django.conf import settings
 from django.contrib.gis.db import models as gis_models
 from django.contrib.gis.db.models import Extent, GeometryField
 from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured
 from django.db import models
-from django.db.models.fields.related import ForeignObjectRel  # Django 2.2 import
+from django.http import HttpRequest
 
-from gisserver.db import conditional_transform
-from gisserver.exceptions import ExternalValueError
+from gisserver import conf
+from gisserver.compat import ArrayField, GeneratedField
+from gisserver.db import get_db_geometry_target
+from gisserver.exceptions import ExternalValueError, InvalidParameterValue
 from gisserver.geometries import CRS, WGS84, BoundingBox
+from gisserver.parsers.xml import parse_qname, xmlns
 from gisserver.types import (
+    GeometryXsdElement,
     GmlBoundedByElement,
     GmlIdAttribute,
     GmlNameElement,
@@ -44,18 +47,10 @@ from gisserver.types import (
     XsdTypes,
 )
 
-if "django.contrib.postgres" in settings.INSTALLED_APPS:
-    from django.contrib.postgres.fields import ArrayField
-else:
-    ArrayField = None
-
-try:
-    from typing import Literal  # Python 3.8
-
-    _all_ = Literal["__all__"]
-except ImportError:
-    _all_ = str
+if TYPE_CHECKING:
+    from gisserver.projection import FeatureRelation
 
+_all_ = Literal["__all__"]
 
 __all__ = [
     "FeatureType",
@@ -65,6 +60,8 @@ __all__ = [
     "get_basic_field_type",
 ]
 
+logger = logging.getLogger(__name__)
+
 XSD_TYPES = {
     models.CharField: XsdTypes.string,
     models.TextField: XsdTypes.string,
@@ -91,7 +88,7 @@ DEFAULT_XSD_TYPE = XsdTypes.anyType
 
 
 def get_basic_field_type(
-    field_name: str, model_field: models.Field | ForeignObjectRel
+    field_name: str, model_field: models.Field | models.ForeignObjectRel
 ) -> XsdAnyType:
     """Determine the XSD field type for a Django field."""
     if ArrayField is not None and isinstance(model_field, ArrayField):
@@ -99,6 +96,10 @@ def get_basic_field_type(
         # The array notation is written as "is_many"
         model_field = model_field.base_field
 
+    if GeneratedField is not None and isinstance(model_field, GeneratedField):
+        # Allow things like: models.GeneratedField(SomeFunction("geofield"), output_field=models.GeometryField())
+        model_field = model_field.output_field
+
     try:
         # Direct instance, quickly resolved!
         return XSD_TYPES[model_field.__class__]
@@ -108,7 +109,7 @@ def get_basic_field_type(
     if isinstance(model_field, models.ForeignKey):
         # Don't let it query on the relation value yet
         return get_basic_field_type(field_name, model_field.target_field)
-    elif isinstance(model_field, ForeignObjectRel):
+    elif isinstance(model_field, models.ForeignObjectRel):
         # e.g. ManyToOneRel descriptor of a foreignkey_id field.
         return get_basic_field_type(field_name, model_field.remote_field.target_field)
     else:
@@ -125,7 +126,12 @@ def get_basic_field_type(
         return DEFAULT_XSD_TYPE
 
 
-def _get_model_fields(model, fields, parent=None):
+def _get_model_fields(
+    model: type[models.Model],
+    fields: _all_ | list[str],
+    parent: ComplexFeatureField | None = None,
+    feature_type: FeatureType | None = None,
+):
     if fields == "__all__":
         # All regular fields
         # Relationships will not be expanded since it can expose so many other fields.
@@ -136,15 +142,16 @@ def _get_model_fields(model, fields, parent=None):
                 # .bind() is called directly by providing these arguments via init:
                 model=model,
                 parent=parent,
+                feature_type=feature_type,
             )
             for f in model._meta.get_fields()
-            if not f.is_relation or f.many_to_one or f.one_to_one  # ForeignKey  # OneToOneField
+            if not f.is_relation or f.many_to_one or f.one_to_one  # ForeignKey, OneToOneField
         ]
     else:
         # Only defined fields
         fields = [f if isinstance(f, FeatureField) else FeatureField(f) for f in fields]
-        for field in fields:
-            field.bind(model, parent=parent)
+        for field in fields:  # type: FeatureField
+            field.bind(model, parent=parent, feature_type=feature_type)
         return fields
 
 
@@ -169,10 +176,10 @@ class FeatureField:
     """
 
     #: Allow to override the XSD element type that this field will generate.
-    xsd_element_class: type[XsdElement] = XsdElement
+    xsd_element_class: type[XsdElement] = None
 
     model: type[models.Model] | None
-    model_field: models.Field | ForeignObjectRel | None
+    model_field: models.Field | models.ForeignObjectRel | None
 
     def __init__(
         self,
@@ -180,26 +187,47 @@ class FeatureField:
         model_attribute=None,
         model=None,
         parent: ComplexFeatureField | None = None,
+        feature_type: FeatureType | None = None,
         abstract=None,
         xsd_class: type[XsdElement] | None = None,
     ):
+        """
+        Initialize a single field of the feature.
+
+        :param name: Name of the model field.
+        :param model_attribute: Which model attribute to access. This can be a dotted field path.
+        :param model: Which model is accessed. Usually this is passed via :meth:`bind`.
+        :param parent: The parent field of this element. Usually this is passed via :meth:`bind`.
+        :param feature_type: The feature this field is a part of. Usually this is passed via :meth:`bind`.
+        :param abstract: The "help text" or short abstract/description for this field.
+        :param xsd_class: Override which class is used to construct the internal XsdElement.
+                          This controls the schema rendering, value retrieval and rendering of the element.
+        """
         self.name = name
         self.model_attribute = model_attribute
         self.model = None
         self.model_field = None
         self.parent = parent
+        self.feature_type = feature_type
         self.abstract = abstract
+
         # Allow to override the class attribute on 'self',
         # which avoids having to subclass this field class as well.
         if xsd_class is not None:
             self.xsd_element_class = xsd_class
 
         self._nillable_relation = False
+        self._nillable_output_field = False
         if model is not None:
-            self.bind(model)
+            self.bind(model, parent=parent, feature_type=feature_type)
 
     def __repr__(self):
-        return f"<{self.__class__.__name__}: {self.name}>"
+        if self.model_field is None:
+            return f"<{self.__class__.__name__}: {self.name} (unbound)>"
+        else:
+            return (
+                f"<{self.__class__.__name__}: {self.name}, source={self.absolute_model_attribute}>"
+            )
 
     def _get_xsd_type(self):
         return get_basic_field_type(self.name, self.model_field)
@@ -208,6 +236,7 @@ class FeatureField:
         self,
         model: type[models.Model],
         parent: ComplexFeatureField | None = None,
+        feature_type: FeatureType | None = None,
     ):
         """Late-binding for the model.
 
@@ -220,40 +249,61 @@ class FeatureField:
         :param model: The model is field is linked to.
         :param parent: When this element is part of a complex feature,
                        this links to the parent field.
+        :param feature_type: The original feature type that his element was mentioned in.
         """
         if self.model is not None:
             raise RuntimeError(f"Feature field '{self.name}' cannot be reused")
         self.model = model
         self.parent = parent
+        self.feature_type = feature_type
 
         if self.model_attribute:
             # Support dot based field traversal.
             field_path = self.model_attribute.split(".")
             try:
                 field: models.Field = self.model._meta.get_field(field_path[0])
+
+                for name in field_path[1:]:
+                    if field.null:
+                        self._nillable_relation = True
+
+                    if not field.is_relation:
+                        # Note this tests the previous loop variable, so it checks whether the
+                        # field can be walked into in order to resolve the next dotted name below.
+                        raise ImproperlyConfigured(
+                            f"FeatureField '{self.name}' has an invalid model_attribute: "
+                            f"field '{name}' is a '{field.__class__.__name__}', not a relation."
+                        )
+
+                    field = field.related_model._meta.get_field(name)
+                self.model_field = field
             except FieldDoesNotExist as e:
                 raise ImproperlyConfigured(
                     f"FeatureField '{self.name}' has an invalid"
                     f" model_attribute: '{self.model_attribute}' can't be"
                     f" resolved for model '{self.model.__name__}'."
                 ) from e
+        else:
+            try:
+                self.model_field = self.model._meta.get_field(self.name)
+                if GeneratedField is not None and isinstance(self.model_field, GeneratedField):
+                    self._nillable_output_field = self.model_field.output_field.null
+            except FieldDoesNotExist as e:
+                raise ImproperlyConfigured(
+                    f"FeatureField '{self.name}' can't be resolved for model '{self.model.__name__}'."
+                    " Either set 'model_attribute' or change the name."
+                ) from e
 
-            for name in field_path[1:]:
-                if field.null:
-                    self._nillable_relation = True
-
-                if not field.is_relation:
-                    # Note this tests the previous loop variable, so it checks whether the
-                    # field can be walked into in order to resolve the next dotted name below.
-                    raise ImproperlyConfigured(
-                        f"FeatureField '{field.name}' has an invalid model_attribute: "
-                        f"field '{name}' is a '{field.__class__.__name__}', not a relation."
-                    )
+    @cached_property
+    def absolute_model_attribute(self) -> str:
+        """Determine the full attribute of the field."""
+        if self.model_field is None:
+            raise RuntimeError(f"bind() was not called for {self!r}")
 
-                field = field.related_model._meta.get_field(name)
-            self.model_field = field
+        if self.parent is not None:
+            return f"{self.parent.absolute_model_attribute}.{self.model_attribute or self.name}"
         else:
-            self.model_field = self.model._meta.get_field(self.name)
+            return self.model_attribute or self.name
 
     @cached_property
     def xsd_element(self) -> XsdElement:
@@ -266,8 +316,10 @@ class FeatureField:
         if self.model_field is None:
             raise RuntimeError(f"bind() was not called for {self!r}")
 
+        xsd_type = self._get_xsd_type()
+
         # Determine max number of occurrences.
-        if isinstance(self.model_field, GeometryField):
+        if xsd_type.is_geometry:
             max_occurs = 1  # be explicit here, like mapserver does.
         elif self.model_field.many_to_many or self.model_field.one_to_many:
             max_occurs = "unbounded"  # M2M or reverse FK field
@@ -276,14 +328,24 @@ class FeatureField:
         else:
             max_occurs = None  # default is 1, but attribute can be left out.
 
-        return self.xsd_element_class(
+        # Determine which subclass to use for the element.
+        xsd_element_class = self.xsd_element_class or (
+            GeometryXsdElement if xsd_type.is_geometry else XsdElement
+        )
+
+        return xsd_element_class(
             name=self.name,
-            type=self._get_xsd_type(),
-            nillable=self.model_field.null or self._nillable_relation,
+            type=xsd_type,
+            namespace=self.feature_type.xml_namespace,  # keep all types in the same namespace for now.
+            nillable=(
+                self.model_field.null or self._nillable_relation or self._nillable_output_field
+            ),
             min_occurs=0,
             max_occurs=max_occurs,
             model_attribute=self.model_attribute,
+            absolute_model_attribute=self.absolute_model_attribute,
             source=self.model_field,
+            feature_type=self.feature_type,
         )
 
 
@@ -307,13 +369,18 @@ class ComplexFeatureField(FeatureField):
         model=None,
         abstract=None,
         xsd_class=None,
-        xsd_base_type=XsdTypes.gmlAbstractFeatureType,
+        xsd_base_type=None,
     ):
         """
         :param name: Name of the model field.
-        :param fields: List of fields to expose for the target model. This can
-            be a list of :class:`FeatureField` objects, or plain field names.
+        :param fields: If the field exposes a foreign key, provide its child element names.
+            This can be a list of :func:`field` elements, or plain field names.
             Using ``__all__`` also works but is not recommended outside testing.
+        :param model_attribute: Which model attribute to access. This can be a dotted field path.
+        :param abstract: The "help text" or short abstract/description for this field.
+        :param xsd_class: Override which class is used to construct the internal XsdElement.
+                          This controls the schema rendering, value retrieval and rendering of the element.
+        :param xsd_base_type: Override which class is the base class for the element.
         """
         super().__init__(
             name,
@@ -328,7 +395,9 @@ class ComplexFeatureField(FeatureField):
     @cached_property
     def fields(self) -> list[FeatureField]:
         """Provide all fields that will be rendered as part of this complex field."""
-        return _get_model_fields(self.target_model, self._fields, parent=self)
+        return _get_model_fields(
+            self.target_model, self._fields, parent=self, feature_type=self.feature_type
+        )
 
     def _get_xsd_type(self) -> XsdComplexType:
         """Generate the XSD description for the field with an object relation."""
@@ -336,6 +405,7 @@ class ComplexFeatureField(FeatureField):
 
         return XsdComplexType(
             name=f"{self.target_model._meta.object_name}Type",
+            namespace=self.feature_type.xml_namespace,  # keep all types in the same namespace for now.
             elements=[field.xsd_element for field in self.fields],
             attributes=[
                 # Add gml:id attribute definition, so it can be resolved in xpath
@@ -343,6 +413,7 @@ class ComplexFeatureField(FeatureField):
                     type_name=self.name,
                     source=pk_field,
                     model_attribute=pk_field.name,
+                    feature_type=self.feature_type,
                 )
             ],
             base=self.xsd_base_type,
@@ -377,9 +448,13 @@ def field(
     so little knowledge is needed about the internal working.
 
     :param name: Name of the model field.
-    :param fields: If the field exposes a foreign key, provide it's child element names.
+    :param model_attribute: Which model attribute to access. This can be a dotted field path.
+    :param abstract: The "help text" or short abstract/description for this field.
+    :param fields: If the field exposes a foreign key, provide its child element names.
         This can be a list of :func:`field` elements, or plain field names.
         Using ``__all__`` also works but is not recommended outside testing.
+    :param xsd_class: Override which class is used to construct the internal XsdElement.
+                      This controls the schema rendering, value retrieval and rendering of the element.
     """
     if fields is not None:
         return ComplexFeatureField(
@@ -398,46 +473,10 @@ def field(
         )
 
 
-@dataclass
-class FeatureRelation:
-    """Tell which related fields are queried by the feature.
-    Each dict holds an ORM-path, with the relevant sub-elements.
-    """
-
-    #: The ORM path that is queried for this particular relation
-    orm_path: str
-    #: The fields that will be retrieved for that path
-    orm_fields: set[str]
-    #: The model that is accessed for this relation (if set)
-    related_model: type[models.Model] | None
-    #: The source elements that access this relation.
-    xsd_elements: list[XsdElement]
-
-    @cached_property
-    def _local_model_field_names(self) -> list[str]:
-        """Tell which local fields of the model will be accessed by this feature."""
-
-        meta = self.related_model._meta
-        result = []
-        for name in self.orm_fields:
-            model_field = meta.get_field(name)
-            if not model_field.many_to_many and not model_field.one_to_many:
-                result.append(name)
-
-        # When this relation is retrieved through a ManyToOneRel (reverse FK),
-        # the prefetch_related() also needs to have the original foreign key
-        # in order to link all prefetches to the proper parent instance.
-        for xsd_element in self.xsd_elements:
-            if xsd_element.source is not None and xsd_element.source.one_to_many:
-                result.append(xsd_element.source.field.name)
-
-        return result
-
-
 class FeatureType:
     """Declare a feature that is exposed on the map.
 
-    All WFS operations use this class to read the feature ype.
+    All WFS operations use this class to read the feature type.
     You may subclass this class to provide extensions,
     such as redefining :meth:`get_queryset`.
 
@@ -464,14 +503,14 @@ class FeatureType:
         metadata_url: str | None = None,
         # Settings
         show_name_field: bool = True,
-        xml_prefix: str = "app",
+        xml_namespace: str | None = None,
     ):
         """
         :param queryset: The queryset to retrieve the data.
         :param fields: Define which fields to show in the WFS data.
             This can be a list of field names, or :class:`FeatureField` objects.
         :param display_field_name: Name of the field that's used as general string representation.
-        :param geometry_field: Name of the geometry field to expose (default = auto detect).
+        :param geometry_field_name: Name of the geometry field to expose (default = auto-detect).
         :param name: Name, also used as XML tag name.
         :param title: Used in WFS metadata.
         :param abstract: Used in WFS metadata.
@@ -481,7 +520,7 @@ class FeatureType:
         :param metadata_url: Used in WFS metadata.
         :param show_name_field: Whether to show the ``gml:name`` or the GeoJSON ``geometry_name``
             field. Default is to show a field when ``name_field`` is given.
-        :param xml_prefix: The XML namespace prefix to use.
+        :param xml_namespace: The XML namespace to use, will be set by :meth:`bind_namespace` otherwise.
         """
         if isinstance(queryset, models.QuerySet):
             self.queryset = queryset
@@ -506,23 +545,34 @@ class FeatureType:
 
         # Settings
         self.show_name_field = show_name_field
-        self.xml_prefix = xml_prefix
+        self.xml_namespace = xml_namespace
 
         # Validate that the name doesn't require XML escaping.
         if html.escape(self.name) != self.name or " " in self.name or ":" in self.name:
             raise ValueError(f"Invalid feature name for XML: <{self.xml_name}>")
 
-        self._cached_resolver = lru_cache(100)(self._inner_resolve_element)
+        self._cached_resolver = lru_cache(200)(self._inner_resolve_element)
 
-    def check_permissions(self, request):
+    def bind_namespace(self, default_xml_namespace: str):
+        """Make sure the feature type receives the settings from the parent view."""
+        if not self.xml_namespace:
+            self.xml_namespace = default_xml_namespace
+
+    def check_permissions(self, request: HttpRequest):
         """Hook that allows subclasses to reject access for datasets.
         It may raise a Django PermissionDenied error.
+
+        This can check for example whether ``request.user`` may access this feature.
+
+        The parsed WFS request is available as ``request.ows_request``.
+        Currently, this can be a :class:`~gisserver.parsers.wfs20.GetFeature`
+        or :class:`~gisserver.parsers.wfs20.GetPropertyValue` instance.
         """
 
     @cached_property
-    def xml_name(self):
-        """Return the feature name with xml namespace prefix."""
-        return f"{self.xml_prefix}:{self.name}"
+    def xml_name(self) -> str:
+        """Return the feature tag as XML Full Qualified name"""
+        return f"{{{self.xml_namespace}}}{self.name}" if self.xml_namespace else self.name
 
     @cached_property
     def supported_crs(self) -> list[CRS]:
@@ -530,61 +580,19 @@ class FeatureType:
         return [self.crs] + self.other_crs
 
     @cached_property
-    def geometry_fields(self) -> list[GeometryField]:
-        """Tell which fields of the model have a geometry field.
-        This only compares against fields that are mentioned in this feature type.
-        """
-        return [
-            ff.model_field or getattr(self.model, ff.model_attribute)
-            for ff in self.fields
-            if ff.xsd_element.is_geometry
-        ]
-
-    @cached_property
-    def orm_relations(self) -> list[FeatureRelation]:
-        """Tell which fields will be retrieved from related fields.
-
-        This gives an object layout based on the XSD elements,
-        that can be used for prefetching data.
-        """
-        models = {}
-        fields = defaultdict(set)
-        elements = defaultdict(list)
-
-        # Check all elements that render as "dotted" flattened relation
-        for xsd_element in self.xsd_type.flattened_elements:
-            if xsd_element.source is not None:
-                # Split "relation.field" notation into path, and take the field as child attribute.
-                obj_path, field = xsd_element.orm_relation
-                elements[obj_path].append(xsd_element)
-                fields[obj_path].add(field)
-                # field is already on relation:
-                models[obj_path] = xsd_element.source.model
-
-        # Check all elements that render as "nested" complex type:
-        for xsd_element in self.xsd_type.complex_elements:
-            # The complex element itself points to the root of the path,
-            # all sub elements become the child attributes.
-            obj_path = xsd_element.orm_path
-            elements[obj_path].append(xsd_element)
-            fields[obj_path] = {
-                f.orm_path
-                for f in xsd_element.type.elements
-                if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
-            }
-            if xsd_element.source:
-                # field references a related object:
-                models[obj_path] = xsd_element.source.related_model
-
-        return [
-            FeatureRelation(
-                orm_path=obj_path,
-                orm_fields=sub_fields,
-                related_model=models.get(obj_path),
-                xsd_elements=elements[obj_path],
+    def all_geometry_elements(self) -> list[GeometryXsdElement]:
+        """Provide access to all geometry elements from *all* nested levels."""
+        return self.xsd_type.geometry_elements + list(
+            itertools.chain.from_iterable(
+                # Take the geometry elements at each object level.
+                xsd_element.type.geometry_elements
+                for xsd_element in self.xsd_type.all_complex_elements
+                # The 'None' level is the root node, which is already added before.
+                # For now, don't support geometry fields on an M2M relation.
+                # If that use-case is needed, it would require additional work to implement.
+                if xsd_element is not None and not xsd_element.is_many
             )
-            for obj_path, sub_fields in fields.items()
-        ]
+        )
 
     @cached_property
     def _local_model_field_names(self) -> list[str]:
@@ -600,6 +608,17 @@ class FeatureType:
     @cached_property
     def fields(self) -> list[FeatureField]:
         """Define which fields to render."""
+        if (
+            self._geometry_field_name
+            and "." in self._geometry_field_name
+            and (self._fields is None or self._fields == "__all__")
+        ):
+            # If you want to define more complex relationships, please be explicit in which fields you want.
+            # Allowing autoconfiguration of this is complex and likely not what you're looking for either.
+            raise ImproperlyConfigured(
+                "Using a geometry_field_name path requires defining 'fields' explicitly."
+            )
+
         # This lazy reading allows providing 'fields' as lazy value.
         if self._fields is None:
             # Autoconfig, no fields defined.
@@ -610,9 +629,10 @@ class FeatureType:
                     if isinstance(f, gis_models.GeometryField)
                 )
 
-            return [FeatureField(self._geometry_field_name, model=self.model)]
+            return [FeatureField(self._geometry_field_name, model=self.model, feature_type=self)]
         else:
-            return _get_model_fields(self.model, self._fields)
+            # Either __all__ or an explicit list.
+            return _get_model_fields(self.model, self._fields, feature_type=self)
 
     @cached_property
     def display_field(self) -> models.Field | None:
@@ -623,49 +643,36 @@ class FeatureType:
             return self.model._meta.get_field(self.display_field_name)
 
     @cached_property
-    def geometry_field(self) -> gis_models.GeometryField:
-        """Give access to the Django field that holds the geometry."""
-        if not self.geometry_fields:
-            raise ImproperlyConfigured(
-                f"FeatureType '{self.name}' does not expose a geometry field."
-            ) from None
-
-        if self._geometry_field_name:
-            # Explicitly mentioned, use that field.
-            # Check whether the server is not accidentally exposing another field
-            # that is not part of the type definition.
-            field = next(
-                (
-                    field
-                    for field in self.geometry_fields
-                    if field.name == self._geometry_field_name
-                ),
-                None,
-            )
-            if field is None:
+    def main_geometry_element(self) -> GeometryXsdElement:
+        """Give access to the main geometry element."""
+        if not self._geometry_field_name:
+            try:
+                # Take the first element that has a geometry.
+                return self.all_geometry_elements[0]
+            except IndexError:
+                raise ImproperlyConfigured(
+                    f"FeatureType '{self.name}' does not expose any geometry field "
+                    f"as part of its definition."
+                ) from None
+        else:
+            try:
+                return next(
+                    e
+                    for e in self.all_geometry_elements
+                    if e.absolute_model_attribute == self._geometry_field_name
+                )
+            except StopIteration:
                 raise ImproperlyConfigured(
                     f"FeatureType '{self.name}' does not expose the geometry field "
                     f"'{self._geometry_field_name}' as part of its definition."
-                )
-
-            return field
-        else:
-            # Default: take the first geometry
-            return self.geometry_fields[0]
-
-    @cached_property
-    def geometry_field_name(self) -> str:
-        """Tell which field is the geometry field."""
-        # Due to internal reorganization this property is no longer needed,
-        # retained for backward compatibility and to reflect any used input parameters.
-        return self.geometry_field.name
+                ) from None
 
     @cached_property
     def crs(self) -> CRS:
         """Tell which projection the data should be presented at."""
         if self._crs is None:
             # Default CRS
-            return CRS.from_srid(self.geometry_field.srid)  # checks lookup too
+            return CRS.from_srid(self.main_geometry_element.source_srid)  # checks lookup too
         else:
             return self._crs
 
@@ -673,6 +680,11 @@ class FeatureType:
         """Return the queryset that is used as basis for this feature."""
         # Return a queryset that only retrieves the fields that are actually displayed.
         # That that without .only(), use at least `self.queryset.all()` so a clone is returned.
+        logger.debug(
+            "QuerySet for %s default only retrieves: %r",
+            self.queryset.model._meta.label,
+            self._local_model_field_names,
+        )
         return self.queryset.only(*self._local_model_field_names)
 
     def get_related_queryset(self, feature_relation: FeatureRelation) -> models.QuerySet:
@@ -683,9 +695,15 @@ class FeatureType:
                 f"source model is not defined for: {feature_relation.xsd_elements!r}"
             )
         # Return a queryset that only retrieves the fields that are displayed.
-        return self.filter_related_queryset(
-            feature_relation.related_model.objects.only(*feature_relation._local_model_field_names)
+        logger.debug(
+            "QuerySet for %s by default only retrieves: %r",
+            feature_relation.related_model._meta.label,
+            feature_relation._local_model_field_names,
+        )
+        queryset = feature_relation.related_model.objects.only(
+            *feature_relation._local_model_field_names
         )
+        return self.filter_related_queryset(queryset)  # Allow overriding by FeatureType subclasses
 
     def filter_related_queryset(self, queryset: models.QuerySet) -> models.QuerySet:
         """When a related object returns a queryset, this hook allows extra filtering."""
@@ -698,37 +716,13 @@ class FeatureType:
         when the database table is empty, or the custom queryset doesn't
         return any results.
         """
-        if not self.geometry_fields:
+        if not self.main_geometry_element:
             return None
 
-        geo_expression = conditional_transform(
-            self.geometry_field.name, self.geometry_field.srid, WGS84.srid
-        )
-
+        geo_expression = get_db_geometry_target(self.main_geometry_element, WGS84)
         bbox = self.get_queryset().aggregate(a=Extent(geo_expression))["a"]
         return BoundingBox(*bbox, crs=WGS84) if bbox else None
 
-    def get_envelope(self, instance, crs: CRS | None = None) -> BoundingBox | None:
-        """Get the bounding box for a single instance.
-
-        This is only used for native Python rendering. When the database
-        rendering is enabled (GISSERVER_USE_DB_RENDERING=True), the calculation
-        is entirely performed within the query.
-        """
-        geometries = [
-            geom
-            for geom in (getattr(instance, f.name) for f in self.geometry_fields)
-            if geom is not None
-        ]
-        if not geometries:
-            return None
-
-        # Perform the combining of geometries inside libgeos
-        geometry = geometries[0] if len(geometries) == 1 else reduce(operator.or_, geometries)
-        if crs is not None and geometry.srid != crs.srid:
-            crs.apply_to(geometry)  # avoid clone
-        return BoundingBox.from_geometry(geometry, crs=crs)
-
     def get_display_value(self, instance: models.Model) -> str:
         """Generate the display name value"""
         if self.display_field_name:
@@ -747,12 +741,8 @@ class FeatureType:
         """
         pk_field = self.model._meta.pk
 
-        # Define <gml:boundedBy>, if the feature has a geometry
-        base_elements = []
-        if self.geometry_fields:
-            # Without a geometry, boundaries are not possible.
-            base_elements.append(GmlBoundedByElement(feature_type=self))
-
+        # Define <gml:boundedBy>
+        base_elements = [GmlBoundedByElement(feature_type=self)]
         if self.show_name_field:
             # Add <gml:name>
             gml_name = GmlNameElement(
@@ -762,16 +752,19 @@ class FeatureType:
             )
             base_elements.insert(0, gml_name)
 
+        # Write out the definition of XsdTypes.gmlAbstractFeatureType as actual class definition.
+        # By having these base elements, the XPath queries can also resolve these like any other feature field elements.
         return XsdComplexType(
-            prefix="gml",
             name="AbstractFeatureType",
+            namespace=xmlns.gml.value,
             elements=base_elements,
             attributes=[
-                # Add gml:id attribute definition so it can be resolved in xpath
+                # Add gml:id="..." attribute definition so it can be resolved in xpath
                 GmlIdAttribute(
                     type_name=self.name,
                     source=pk_field,
                     model_attribute=pk_field.name,
+                    feature_type=self,
                 )
             ],
             base=XsdTypes.gmlAbstractGMLType,
@@ -781,13 +774,14 @@ class FeatureType:
     def xsd_type(self) -> XsdComplexType:
         """Return the definition of this feature as an XSD Complex Type."""
         return self.xsd_type_class(
-            name=f"{self.name.title()}Type",
+            name=f"{self.name[0].upper()}{self.name[1:]}Type",
             elements=[field.xsd_element for field in self.fields],
+            namespace=self.xml_namespace,
             base=self.xsd_base_type,
             source=self.model,
         )
 
-    def resolve_element(self, xpath: str) -> XPathMatch:
+    def resolve_element(self, xpath: str, ns_aliases: dict[str, str]) -> XPathMatch:
         """Resolve the element, and the matching object.
 
         This is used to convert XPath references in requests
@@ -795,13 +789,28 @@ class FeatureType:
 
         Internally, this method caches results.
         """
-        nodes = self._cached_resolver(xpath)  # calls _inner_resolve_element
+        # When the XML POST request used xmlns="http://www.opengis.net/wfs/2.0",
+        # this will become the default namespace elements are translated into.
+        # However, the XPath elements should be interpreted within our application namespace instead.
+        # When the default namespace is missing, it should also resolve to our feature.
+        ns_aliases = ns_aliases.copy()
+        ns_aliases[""] = self.xml_namespace
+
+        if len(ns_aliases) > 10:
+            # Avoid filling memory by caching large namespace blobs.
+            nodes = self._inner_resolve_element(xpath, ns_aliases)
+        else:
+            # Go through lru_cache() for faster lookup of the same elements.
+            # Note 1: the cache will be less effective when clients use different namespace aliases.
+            # Note 2: when WFSView overrides get_feature_types() the cache may only exist per request.
+            nodes = self._cached_resolver(xpath, HDict(ns_aliases))
+
         if nodes is None:
             raise ExternalValueError(f"Field '{xpath}' does not exist.")
 
         return XPathMatch(self, nodes, query=xpath)
 
-    def _inner_resolve_element(self, xpath: str):
+    def _inner_resolve_element(self, xpath: str, ns_aliases: dict[str, str]):
         """Inner part of resolve_element() that is cached.
         This performs any additional checks that happen at the root-level only.
         """
@@ -818,16 +827,34 @@ class FeatureType:
         elif "(" in xpath:
             raise NotImplementedError(f"XPath selectors with functions are not supported: {xpath}")
 
-        # Allow /app:ElementName/.. as "absolute" path.
-        # Given our internal resolver logic, simple solution is to strip it.
-        for root_prefix in (
-            f"{self.name}/",
-            f"/{self.name}/",
-            f"{self.xml_name}/",
-            f"/{self.xml_name}/",
-        ):
-            if xpath.startswith(root_prefix):
-                xpath = xpath[len(root_prefix) :]
-                break
+        # Allow /app:ElementName/.. as "absolute" path, simply strip it for now.
+        # This is only actually needed to support join queries, which we don't.
+        xpath = xpath.lstrip("/")
+        root_name, _, _ = xpath.partition("/")
+        root_xml_name = parse_qname(root_name, ns_aliases)
+        if root_xml_name == self.xml_name:
+            xpath = xpath[len(root_name) + 1 :]
+
+        return self.xsd_type.resolve_element_path(xpath, ns_aliases)
+
+    def resolve_crs(self, crs: CRS, locator="") -> CRS:
+        """Check a parsed CRS against the list of supported types."""
+        pos = self.supported_crs.index(crs)
+        if pos != -1:
+            # Replace the parsed CRS with the declared one, which may have a 'backend' configured.
+            return self.supported_crs[pos]
+
+        if conf.GISSERVER_SUPPORTED_CRS_ONLY:
+            raise InvalidParameterValue(
+                f"Feature '{self.name}' does not support SRID {crs.srid}.",
+                locator=locator,
+            )
+        else:
+            return crs
+
+
+class HDict(dict):
+    """Dict that can be used in lru_cache()."""
 
-        return self.xsd_type.resolve_element_path(xpath)
+    def __hash__(self):
+        return hash(frozenset(self.items()))