django-gisserver 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

gisserver/output/gml32.py

@@ -30,11 +30,12 @@ from gisserver.db import (
     get_db_geometry_target,
     get_geometries_union,
 )
-from gisserver.exceptions import NotFound
-from gisserver.features import FeatureRelation, FeatureType
+from gisserver.exceptions import NotFound, WFSException
+from gisserver.features import FeatureType
 from gisserver.geometries import CRS
 from gisserver.parsers.fes20 import ValueReference
-from gisserver.types import XsdComplexType, XsdElement, XsdNode
+from gisserver.queries import FeatureProjection, FeatureRelation
+from gisserver.types import XsdElement, XsdNode
 
 from .base import OutputRenderer
 from .results import SimpleFeatureCollection
@@ -92,6 +93,7 @@ class GML32Renderer(OutputRenderer):
 
     content_type = "text/xml; charset=utf-8"
     xml_collection_tag = "FeatureCollection"
+    xml_sub_collection_tag = "FeatureCollection"  # Mapserver does not use SimpleFeatureCollection
     chunk_size = 40_000
     gml_seq = 0
 
@@ -127,7 +129,7 @@ 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,
         )
@@ -163,6 +165,36 @@ class GML32Renderer(OutputRenderer):
             ' xmlns:gml="http://www.opengis.net/gml/3.2"'
         )
 
+    def render_exception(self, exception: Exception):
+        """Render the exception in a format that fits with the output.
+
+        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"{buffer}"
+            f"{closing_child}"
+            "  <wfs:truncatedResponse>"
+            f"{exception.as_xml()}"
+            "  </wfs:truncatedResponse>\n"
+            f"</wfs:{self.xml_collection_tag}>\n"
+        )
+
     def render_stream(self):
         """Render the XML as streaming content.
         This renders the standard <wfs:FeatureCollection> / <wfs:ValueCollection>
@@ -193,11 +225,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 +239,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 +251,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,43 +260,45 @@ 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.
         """
+        feature_type = projection.feature_type
+
         # 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')
-
         # 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)
+                    self.write_bounds(projection, 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)
             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_xml_field(projection, xsd_element, value)
 
         self._write(f"</{feature_type.xml_name}>\n")
 
-    def write_bounds(self, feature_type, instance) -> None:
+    def write_bounds(self, projection, instance) -> None:
         """Render the GML bounds for the complete instance"""
-        envelope = feature_type.get_envelope(instance, self.output_crs)
+        envelope = projection.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))
@@ -274,7 +309,7 @@ class GML32Renderer(OutputRenderer):
               </gml:Envelope></gml:boundedBy>\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:
@@ -282,17 +317,11 @@ class GML32Renderer(OutputRenderer):
             if xsd_element.min_occurs:
                 self._write(f'<{xsd_element.xml_name} 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
@@ -300,7 +329,7 @@ class GML32Renderer(OutputRenderer):
             self._write(f'<{xml_name} 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.
@@ -324,16 +353,17 @@ class GML32Renderer(OutputRenderer):
 
             self._write(f"<{xml_name}{extra_xmlns}>{value}</{xml_name}>\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:
+        for sub_element in projection.xsd_child_nodes[xsd_element]:
             sub_value = sub_element.get_value(value)
             if sub_element.is_many:
-                self.write_many(feature_type, sub_element, sub_value)
+                self.write_many(projection, sub_element, sub_value)
             else:
-                self.write_xml_field(feature_type, sub_element, sub_value)
+                self.write_xml_field(projection, sub_element, sub_value)
         self._write(f"</{xsd_element.xml_name}>\n")
 
     def write_gml_field(
@@ -482,23 +512,22 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
     ):
         """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, output_crs, **params)
 
         # Retrieve geometries as pre-rendered instead.
-        gml_elements = feature_type.xsd_type.geometry_elements
-        geo_selects = get_db_geometry_selects(gml_elements, output_crs)
+        geo_selects = get_db_geometry_selects(projection.geometry_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),
+                _as_envelope_gml=cls.get_db_envelope_as_gml(projection, queryset, output_crs),
                 **build_db_annotations(geo_selects, "_as_gml_{name}", AsGML),
             )
 
@@ -507,56 +536,46 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
     @classmethod
     def get_prefetch_queryset(
         cls,
-        feature_type: FeatureType,
+        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)
+        base = super().get_prefetch_queryset(projection, feature_relation, output_crs)
         if base 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)
+        geometries = get_db_geometry_selects(feature_relation.geometry_elements, output_crs)
         if geometries:
             # Exclude geometries from the fields, fetch them as pre-rendered annotations instead.
-            return base.defer(geometries.keys()).annotate(
+            return base.defer(*geometries.keys()).annotate(
                 **build_db_annotations(geometries, "_as_gml_{name}", AsGML),
             )
         else:
             return base
 
     @classmethod
-    def get_db_envelope_as_gml(cls, feature_type, queryset, output_crs) -> AsGML:
+    def get_db_envelope_as_gml(cls, projection: FeatureProjection, queryset, output_crs) -> 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 = cls._get_geometries_union(projection, queryset, output_crs)
         return AsGML(geo_fields_union, envelope=True)
 
     @classmethod
-    def _get_geometries_union(cls, feature_type: FeatureType, queryset, output_crs):
+    def _get_geometries_union(cls, projection: FeatureProjection, queryset, output_crs):
         """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,
+                    gml_element.orm_path,
+                    gml_element.source.srid,
                     output_srid=output_crs.srid,
                 )
-                for model_field in feature_type.geometry_fields
+                for gml_element in projection.geometry_elements
             ],
             using=queryset.db,
         )
@@ -579,8 +598,8 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
         gml = self.render_gml_value(gml_id, value, extra_xmlns=extra_xmlns)
         self._write(f"<{xml_name}{extra_xmlns}>{gml}</{xml_name}>\n")
 
-    def write_bounds(self, feature_type, instance) -> None:
-        """Generate the <gml:boundedBy> from DB prerendering."""
+    def write_bounds(self, projection, instance) -> None:
+        """Generate the <gml:boundedBy> from DB pre-rendering."""
         gml = instance._as_envelope_gml
         if gml is not None:
             self._write(f"<gml:boundedBy>{gml}</gml:boundedBy>\n")
@@ -597,6 +616,7 @@ class GML32ValueRenderer(GML32Renderer):
     content_type = "text/xml; charset=utf-8"
     content_type_plain = "text/plain; charset=utf-8"
     xml_collection_tag = "ValueCollection"
+    xml_sub_collection_tag = "ValueCollection"
     _escape_value = staticmethod(_value_to_xml_string)
     gml_value_getter = itemgetter("member")
 
@@ -608,7 +628,7 @@ class GML32ValueRenderer(GML32Renderer):
     @classmethod
     def decorate_queryset(
         cls,
-        feature_type: FeatureType,
+        projection: FeatureProjection,
         queryset: models.QuerySet,
         output_crs: CRS,
         **params,
@@ -634,15 +654,15 @@ class GML32ValueRenderer(GML32Renderer):
             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:
             self.write_gml_field(
-                feature_type,
+                projection.feature_type,
                 cast(XsdElement, self.xsd_node),
                 instance,
                 extra_xmlns=extra_xmlns,
@@ -668,10 +688,10 @@ class GML32ValueRenderer(GML32Renderer):
                         first = False
         elif self.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,
+                projection,
                 cast(XsdElement, self.xsd_node),
                 value=instance["member"],
                 extra_xmlns=extra_xmlns,
@@ -699,14 +719,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(cls, projection: FeatureProjection, queryset, output_crs, **params):
         """Update the queryset to let the database render the GML output."""
         value_reference = params["valueReference"]
-        match = feature_type.resolve_element(value_reference.xpath)
+        match = projection.feature_type.resolve_element(value_reference.xpath)
         if match.child.is_geometry:
             # Add 'gml_member' to point to the pre-rendered GML version.
+            gml_element = cast(XsdElement, match.child)
             return queryset.values(
-                "pk", gml_member=AsGML(get_db_geometry_target(match, output_crs))
+                "pk", gml_member=AsGML(get_db_geometry_target(gml_element, output_crs))
             )
         else:
             return queryset

gisserver/output/results.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import math
 import operator
+import typing
 from collections.abc import Iterable
 from datetime import timezone
 from functools import cached_property, reduce
@@ -21,6 +22,9 @@ from gisserver.geometries import BoundingBox
 
 from .utils import ChunkedQuerySetIterator, CountingIterator
 
+if typing.TYPE_CHECKING:
+    from gisserver.queries import FeatureProjection, QueryExpression
+
 
 class SimpleFeatureCollection:
     """Wrapper to read a result set.
@@ -31,15 +35,18 @@ class SimpleFeatureCollection:
 
     def __init__(
         self,
+        source_query: QueryExpression,
         feature_type: FeatureType,
         queryset: models.QuerySet,
         start: int,
         stop: int,
     ):
+        self.source_query = source_query
         self.feature_type = feature_type
         self.queryset = queryset
         self.start = start
         self.stop = stop
+
         self._result_cache = None
         self._result_iterator = None
         self._has_more = None
@@ -67,7 +74,7 @@ class SimpleFeatureCollection:
     def iterator(self):
         """Explicitly request the results to be streamed.
 
-        This can be used by output formats that stream may results, and don't
+        This can be used by output formats that stream results, and don't
         access `number_returned`. Note this is not compatible with prefetch_related().
         """
         if self._result_iterator is not None:
@@ -170,7 +177,7 @@ class SimpleFeatureCollection:
             # When requesting the data after the fact, results are counted.
             return self._result_iterator.number_returned
         else:
-            # Count by fetching all data. Otherwise the results are queried twice.
+            # Count by fetching all data. Otherwise, the results are queried twice.
             # For GML/XML, it's not possible the stream the queryset results
             # as the first tag needs to describe the number of results.
             self.fetch_results()
@@ -187,7 +194,7 @@ class SimpleFeatureCollection:
         qs = self.queryset
         clean_annotations = {
             # HACK: remove database optimizations from output renderer.
-            # Otherwise it becomes SELECT COUNT(*) FROM (SELECT AsGML(..), ...)
+            # Otherwise, it becomes SELECT COUNT(*) FROM (SELECT AsGML(..), ...)
             key: value
             for key, value in qs.query.annotations.items()
             if not key.startswith("_as_")
@@ -229,11 +236,18 @@ class SimpleFeatureCollection:
         elif self._has_more is not None:
             return self._has_more  # did page+1 record check, answer is known.
         elif self._is_surely_last_page:
-            return False  # Less results then expected, answer is known.
+            return False  # Fewer results than expected, answer is known.
 
         # This will perform an slow COUNT() query...
         return self.stop < self.number_matched
 
+    @cached_property
+    def projection(self) -> FeatureProjection:
+        """Provide the projection to render these results with."""
+        # Note this attribute would technically be part of the 'query' object,
+        # but since the projection needs to be mapped per feature type, it's stored here for convenience.
+        return self.source_query.get_projection(self.feature_type)
+
     def get_bounding_box(self) -> BoundingBox:
         """Determine bounding box of all items."""
         self.fetch_results()  # Avoid querying results twice
@@ -245,11 +259,11 @@ class SimpleFeatureCollection:
             self.feature_type.geometry_field.name
         ).child
         for instance in self:
-            geomery_value = geometry_field.get_value(instance)
-            if geomery_value is None:
+            geometry_value = geometry_field.get_value(instance)
+            if geometry_value is None:
                 continue
 
-            bbox.extend_to_geometry(geomery_value)
+            bbox.extend_to_geometry(geometry_value)
 
         return bbox
 
@@ -270,6 +284,7 @@ class FeatureCollection:
         previous: str | None = None,
     ):
         """
+        :param source_query: The query that generated this output.
         :param results: All retrieved feature collections (one per FeatureType)
         :param number_matched: Total number of features across all pages
         :param next: URL of the next page
@@ -305,7 +320,7 @@ class FeatureCollection:
                 conf.GISSERVER_COUNT_NUMBER_MATCHED == 2 and self.results[0].start > 0
             ):
                 # Report "unknown" for either all pages, or the second page.
-                # Most clients don't need this metadata and thus we avoid a COUNT query.
+                # Most clients don't need this metadata, and thus we avoid a COUNT query.
                 return None
 
             return sum(c.number_matched for c in self.results)

gisserver/output/utils.py

@@ -5,7 +5,7 @@ from collections.abc import Iterable
 from itertools import islice
 from typing import TypeVar
 
-from django.db import models
+from django.db import connections, models
 from lru import LRU
 
 M = TypeVar("M", bound=models.Model)
@@ -89,7 +89,7 @@ class ChunkedQuerySetIterator(Iterable[M]):
         self._number_returned = 0
         self._in_iterator = True
         try:
-            qs_iter = iter(self.queryset.iterator(chunk_size=self.sql_chunk_size))
+            qs_iter = iter(self._get_queryset_iterator())
 
             # Keep fetching chunks
             while True:
@@ -107,6 +107,22 @@ class ChunkedQuerySetIterator(Iterable[M]):
         finally:
             self._in_iterator = False
 
+    def _get_queryset_iterator(self) -> Iterable:
+        """The body of queryset.iterator(), while circumventing prefetching."""
+        # The old code did return `self.queryset.iterator(chunk_size=self.sql_chunk_size)`
+        # However, Django 4 supports using prefetch_related() with iterator() in that scenario.
+        #
+        # This code is the core of Django's QuerySet.iterator() that only produces the
+        # old-style iteration, without any prefetches. Those are added by this class instead.
+        use_chunked_fetch = not connections[self.queryset.db].settings_dict.get(
+            "DISABLE_SERVER_SIDE_CURSORS"
+        )
+        iterable = self.queryset._iterable_class(
+            self.queryset, chunked_fetch=use_chunked_fetch, chunk_size=self.sql_chunk_size
+        )
+
+        yield from iterable
+
     @property
     def number_returned(self) -> int:
         """Tell how many objects the iterator processed"""

gisserver/output/xmlschema.py

@@ -73,7 +73,7 @@ class XMLSchemaRenderer(OutputRenderer):
 
         # Next, the complexType is rendered that defines the element contents.
         # Next, the complexType(s) are rendered that defines the element contents.
-        # In case any fields are expanded (hence become sub-types), these are also included.
+        # In case any fields are expanded (hence become subtypes), these are also included.
         output.write(self.render_complex_type(xsd_type))
         for complex_type in self._get_complex_types(xsd_type):
             output.write(self.render_complex_type(complex_type))

gisserver/parsers/base.py

@@ -65,7 +65,7 @@ class TagRegistry:
         self.parsers = {}
 
     def register(self, name=None, namespace=None, hidden=False):
-        """Decorator to register an class as XML node parser.
+        """Decorator to register a class as XML node parser.
 
         This registers the decorated class as the designated parser
         for a specific XML tag.
@@ -116,7 +116,7 @@ class TagRegistry:
         """Convert the element into a Python class.
 
         This locates the parser from the registered tag.
-        It's assumed that the tag has an "from_xml()" method too.
+        It's assumed that the tag has a "from_xml()" method too.
         """
         try:
             real_cls = self.resolve_class(element.tag)

gisserver/parsers/fes20/__init__.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from gisserver.exceptions import OperationParsingFailed
+
 from .expressions import ValueReference
 from .filters import Filter
 from .functions import function_registry
@@ -22,3 +26,17 @@ def parse_resource_id_kvp(value) -> IdOperator:
     This returns an IdOperator, as it needs to support multiple pairs.
     """
     return IdOperator([ResourceId(rid) for rid in value.split(",")])
+
+
+def parse_property_name(value) -> list[ValueReference] | None:
+    """Parse the PROPERTYNAME parameter"""
+    if not value or value == "*":
+        return None  # WFS 1 logic
+
+    if "(" in value:
+        raise OperationParsingFailed(
+            "Parameter lists to perform multiple queries are not supported yet.",
+            locator="propertyname",
+        )
+
+    return [ValueReference(x) for x in value.split(",")]

gisserver/parsers/fes20/expressions.py

@@ -49,8 +49,8 @@ OUTPUT_FIELDS = {
 class BinaryOperatorType(TagNameEnum):
     """FES 1.0 Arithmetic operators.
 
-    This are no longer part of the FES 2.0 spec, but clients (like QGis)
-    still assume the server supports these. Hence these need to be included.
+    These are no longer part of the FES 2.0 spec, but clients (like QGis)
+    still assume the server supports these. Hence, these need to be included.
     """
 
     Add = operator.add
@@ -100,7 +100,7 @@ class Literal(Expression):
 
     @cached_property
     def value(self) -> ParsedValue:  # officially <xsd:any>
-        """Access the value of the element, casted to the appropriate data type."""
+        """Access the value of the element, cast to the appropriate data type."""
         if not isinstance(self.raw_value, str):
             return self.raw_value  # GML element or None
         elif self.type:
@@ -197,7 +197,7 @@ class ValueReference(Expression):
         return match.build_rhs(compiler)
 
     def parse_xpath(self, feature_type=None) -> ORMPath:
-        """Convert the XPath into a the required ORM query elements."""
+        """Convert the XPath into the required ORM query elements."""
         if feature_type is not None:
             # Can resolve against XSD paths, find the correct DB field name
             return feature_type.resolve_element(self.xpath)
@@ -209,12 +209,7 @@ class ValueReference(Expression):
     @cached_property
     def element_name(self):
         """Tell which element this reference points to."""
-        try:
-            pos = self.xpath.rindex("/")
-        except ValueError:
-            return self.xpath
-        else:
-            return self.xpath[pos + 1 :]
+        return self.xpath.rpartition("/")[2]
 
 
 @dataclass
@@ -245,8 +240,8 @@ class Function(Expression):
 class BinaryOperator(Expression):
     """Support for FES 1.0 arithmetic operators.
 
-    This are no longer part of the FES 2.0 spec, but clients (like QGis)
-    still assume the server supports these. Hence these need to be included.
+    These are no longer part of the FES 2.0 spec, but clients (like QGis)
+    still assume the server supports these. Hence, these need to be included.
     """
 
     _operatorType: BinaryOperatorType

gisserver/parsers/fes20/functions.py

@@ -97,7 +97,7 @@ class FesFunctionRegistry:
             return _wrapper
 
     def resolve_function(self, function_name) -> FesFunction:
-        """Resole the function using it's name."""
+        """Resole the function using its name."""
         try:
             return self.functions[function_name]
         except KeyError: