Add support for fields query parameter to index endpoint to filter returned filter attributes

Author: manisandro

src/data_service.py

@@ -35,7 +35,7 @@ def __init__(self, tenant, logger, config):
         self.attachments_service = AttachmentsService(tenant, logger)
         self.db_engine = DatabaseEngine()
 
-    def index(self, identity, translator, dataset, bbox, crs, filterexpr, filter_geom):
+    def index(self, identity, translator, dataset, bbox, crs, filterexpr, filter_geom, filter_fields):
         """Find dataset features inside bounding box.
 
         :param str|obj identity: User identity
@@ -46,6 +46,7 @@ def index(self, identity, translator, dataset, bbox, crs, filterexpr, filter_geo
         :param str filterexpr: JSON serialized array of filter expressions:
         [["<attr>", "<op>", "<value>"], "and|or", ["<attr>", "<op>", "<value>"]]
         :param str filter_geom: JSON serialized GeoJSON geometry
+        :param list[string] filter_fields: Field names to return
         """
         dataset_features_provider = self.dataset_features_provider(
             identity, translator, dataset, False
@@ -88,7 +89,7 @@ def index(self, identity, translator, dataset, bbox, crs, filterexpr, filter_geo
 
             try:
                 feature_collection = dataset_features_provider.index(
-                    bbox, srid, filterexpr, filter_geom
+                    bbox, srid, filterexpr, filter_geom, filter_fields
                 )
             except (DataError, ProgrammingError) as e:
                 self.logger.error(e)

src/dataset_features_provider.py

@@ -84,7 +84,7 @@ def deletable(self):
         """Return whether dataset can be deleted."""
         return self.__deletable
 
-    def index(self, bbox, client_srid, filterexpr, filter_geom):
+    def index(self, bbox, client_srid, filterexpr, filter_geom, filter_fields):
         """Find features inside bounding box.
 
         :param list[float] bbox: Bounding box as [<minx>,<miny>,<maxx>,<maxy>]
@@ -93,11 +93,16 @@ def index(self, bbox, client_srid, filterexpr, filter_geom):
         :param (sql, params) filterexpr: A filter expression as a tuple
                                          (sql_expr, bind_params)
         :param str filter_geom: JSON serialized GeoJSON geometry
+        :param list[string] filter_fields: Field names to return
         """
         srid = client_srid or self.srid
 
         own_attributes, join_attributes = self.__extract_join_attributes()
 
+        if filter_fields:
+            own_attributes = [attr for attr in own_attributes if attr in filter_fields or attr == self.primary_key]
+            join_attributes = [attr for attr in join_attributes if attr in filter_fields]
+
         # build query SQL
 
         # select id and permitted attributes
@@ -146,13 +151,15 @@ def index(self, bbox, client_srid, filterexpr, filter_geom):
         if where_clauses:
             where_clause = "WHERE (" + ") AND (".join(where_clauses) + ")"
 
-        geom_sql = self.geom_column_sql(srid, with_bbox=False)
-        if self.geometry_column:
-            # select overall extent
-            geom_sql += (
-                ', ST_Extent(%s) OVER () AS _overall_bbox_' %
-                self.transform_geom_sql('"{geom}"', self.srid, srid)
-            )
+        geom_sql = ""
+        if not filter_fields or "geometry" in filter_fields:
+            geom_sql = self.geom_column_sql(srid, with_bbox=False)
+            if self.geometry_column:
+                # select overall extent
+                geom_sql += (
+                    ', ST_Extent(%s) OVER () AS _overall_bbox_' %
+                    self.transform_geom_sql('"{geom}"', self.srid, srid)
+                )
 
         sql = sql_text(("""
             SELECT {columns}%s
@@ -179,7 +186,7 @@ def index(self, bbox, client_srid, filterexpr, filter_geom):
                 join_attribute_values = self.__query_join_attributes(join_attributes, attribute_values)
                 attribute_values.update(join_attribute_values)
 
-                features.append(self.feature_from_query(attribute_values, srid))
+                features.append(self.feature_from_query(attribute_values, srid, filter_fields))
                 if '_overall_bbox_' in row:
                     overall_bbox = row['_overall_bbox_']
 
@@ -1060,14 +1067,16 @@ def transform_geom_sql(self, geom_sql, geom_srid, target_srid):
 
         return geom_sql
 
-    def feature_from_query(self, row, client_srid):
+    def feature_from_query(self, row, client_srid, filter_fields=None):
         """Build GeoJSON Feature from query result row.
 
         :param obj row: Row result from query
         :param int client_srid: Client SRID or None for dataset SRID
         """
         props = OrderedDict()
         for attr in self.attributes:
+            if filter_fields and not attr in filter_fields:
+                continue
             # Omit hidden fields
             if self.fields.get(attr, {}).get('constraints', {}).get('hidden', False) == True:
                 continue
@@ -1085,7 +1094,7 @@ def feature_from_query(self, row, client_srid):
         geometry = None
         crs = None
         bbox = None
-        if self.geometry_column:
+        if self.geometry_column and (not filter_fields or "geometry" in filter_fields):
             if row['json_geom'] is not None:
                 geometry = json.loads(row['json_geom'])
             else:

src/server.py

@@ -258,6 +258,7 @@ def output(self, key, obj, **kwargs):
 index_parser.add_argument('crs')
 index_parser.add_argument('filter')
 index_parser.add_argument('filter_geom')
+index_parser.add_argument('fields')
 
 feature_multipart_parser = reqparse.RequestParser(argument_class=CaseInsensitiveArgument)
 feature_multipart_parser.add_argument('feature', help='Feature', required=True, location='form')
@@ -292,6 +293,9 @@ class FeatureCollection(Resource):
         '`[["<name>", "<op>", <value>],"and|or",["<name>","<op>",<value>]]`')
     @api.param(
         'filter_geom', 'GeoJSON serialized geometry, used as intersection geometry filter')
+    @api.param(
+        'fields', 'Comma separated list of field names to return'
+    )
     @api.expect(index_parser)
     @api.marshal_with(geojson_feature_collection, skip_none=True)
     @optional_auth
@@ -308,10 +312,11 @@ def get(self, dataset):
         crs = args['crs']
         filterexpr = args['filter']
         filter_geom = args['filter_geom']
+        filter_fields = (args['fields'] or "").split(",")
 
         data_service = data_service_handler()
         result = data_service.index(
-            get_identity(), translator, dataset, bbox, crs, filterexpr, filter_geom
+            get_identity(), translator, dataset, bbox, crs, filterexpr, filter_geom, filter_fields
         )
         if 'error' not in result:
             return result['feature_collection']
@@ -646,7 +651,7 @@ def get(self, dataset, id):
             except:
                 continue
             result = data_service.index(
-                get_identity(), translator, table, None, crs, '[["%s", "=", "%s"]]' % (fk_field_name, id), None
+                get_identity(), translator, table, None, crs, '[["%s", "=", "%s"]]' % (fk_field_name, id), None, None
             )
             ret[table] = {
                 "fk": fk_field_name,
@@ -688,7 +693,7 @@ def get(self):
                 continue
             ret[table] = []
             result = data_service.index(
-                get_identity(), translator, table, None, None, json.dumps(filterexpr[idx]) if filterexpr and len(filterexpr) > idx and filterexpr[idx] else None, None
+                get_identity(), translator, table, None, None, json.dumps(filterexpr[idx]) if filterexpr and len(filterexpr) > idx and filterexpr[idx] else None, None, None
             )
             if 'feature_collection' in result:
                 for feature in result['feature_collection']['features']: