Add GeoDjango support

Author: timgraham

django_mongodb_backend/introspection.py

@@ -1,12 +1,12 @@
 from django.db.backends.base.introspection import BaseDatabaseIntrospection
 from django.db.models import Index
-from pymongo import ASCENDING, DESCENDING
+from pymongo import ASCENDING, DESCENDING, GEOSPHERE
 
 from django_mongodb_backend.indexes import SearchIndex, VectorSearchIndex
 
 
 class DatabaseIntrospection(BaseDatabaseIntrospection):
-    ORDER_DIR = {ASCENDING: "ASC", DESCENDING: "DESC"}
+    ORDER_DIR = {ASCENDING: "ASC", DESCENDING: "DESC", GEOSPHERE: "GEO"}
 
     def table_names(self, cursor=None, include_views=False):
         return sorted([x["name"] for x in self.connection.database.list_collections()])

django_mongodb_backend_gis/__init__.py

@@ -0,0 +1,3 @@
+from .lookups import register_lookups
+
+register_lookups()

django_mongodb_backend_gis/adapter.py

@@ -0,0 +1,21 @@
+import collections
+
+
+class Adapter(collections.UserDict):
+    def __init__(self, obj, geography=False):
+        """
+        Initialize on the spatial object.
+        """
+        if obj.__class__.__name__ == "GeometryCollection":
+            self.data = {
+                "type": obj.__class__.__name__,
+                "geometries": [self.get_data(x) for x in obj],
+            }
+        else:
+            self.data = self.get_data(obj)
+
+    def get_data(self, obj):
+        return {
+            "type": obj.__class__.__name__,
+            "coordinates": obj.coords,
+        }

django_mongodb_backend_gis/base.py

@@ -0,0 +1,11 @@
+from django_mongodb_backend.base import DatabaseWrapper as BaseDatabaseWrapper
+
+from .features import DatabaseFeatures
+from .operations import DatabaseOperations
+from .schema import DatabaseSchemaEditor
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    SchemaEditorClass = DatabaseSchemaEditor
+    features_class = DatabaseFeatures
+    ops_class = DatabaseOperations

django_mongodb_backend_gis/features.py

@@ -0,0 +1,67 @@
+from django.contrib.gis.db.backends.base.features import BaseSpatialFeatures
+from django.utils.functional import cached_property
+
+from django_mongodb_backend.features import DatabaseFeatures as MongoFeatures
+
+
+class DatabaseFeatures(BaseSpatialFeatures, MongoFeatures):
+    has_spatialrefsys_table = False
+    supports_transform = False
+
+    @cached_property
+    def django_test_expected_failures(self):
+        expected_failures = super().django_test_expected_failures
+        expected_failures.update(
+            {
+                # SRIDs aren't populated: AssertionError: 4326 != None
+                # self.assertEqual(4326, nullcity.point.srid)
+                "gis_tests.geoapp.tests.GeoModelTest.test_proxy",
+                # MongoDB does not support the within lookup
+                "gis_tests.relatedapp.tests.RelatedGeoModelTest.test06_f_expressions",
+                # 'Adapter' object has no attribute 'srid'
+                "gis_tests.geoapp.test_expressions.GeoExpressionsTests.test_geometry_value_annotation",
+                # Object of type ObjectId is not JSON serializable
+                "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_fields_option",
+                "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_geometry_field_option",
+                "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_serialization_base",
+                "gis_tests.geoapp.test_serializers.GeoJSONSerializerTests.test_srid_option",
+                # KeyError: 'within' connection.ops.gis_operators[self.lookup_name]
+                "gis_tests.geoapp.tests.GeoModelTest.test_gis_query_as_string",
+                # No lookups are supported (yet?)
+                "gis_tests.geoapp.tests.GeoLookupTest.test_gis_lookups_with_complex_expressions",
+                # Trying to remove spatial index fails:
+                # "index not found with name [gis_neighborhood_geom_id]"
+                "gis_tests.gis_migrations.test_operations.OperationTests.test_alter_field_remove_spatial_index",
+            }
+        )
+        return expected_failures
+
+    @cached_property
+    def django_test_skips(self):
+        skips = super().django_test_skips
+        skips.update(
+            {
+                "inspectdb not supported.": {
+                    "gis_tests.inspectapp.tests.InspectDbTests",
+                },
+                "Raw SQL not supported": {
+                    "gis_tests.geoapp.tests.GeoModelTest.test_raw_sql_query",
+                },
+                "MongoDB doesn't support the SRID(s) used in this test.": {
+                    # Error messages:
+                    # - Can't extract geo keys
+                    # - Longitude/latitude is out of bounds
+                    "gis_tests.geoapp.test_expressions.GeoExpressionsTests.test_update_from_other_field",
+                    "gis_tests.layermap.tests.LayerMapTest.test_encoded_name",
+                    # SouthTexasCity fixture objects use SRID 2278 which is ignored
+                    # by the patched version of loaddata in the Django fork.
+                    "gis_tests.distapp.tests.DistanceTest.test_init",
+                },
+                "ImproperlyConfigured isn't raised when using RasterField": {
+                    # Normally RasterField.db_type() raises an error, but MongoDB
+                    # migrations don't need to call it, so the check doesn't happen.
+                    "gis_tests.gis_migrations.test_operations.NoRasterSupportTests",
+                },
+            },
+        )
+        return skips

django_mongodb_backend_gis/lookups.py

@@ -0,0 +1,10 @@
+from django.contrib.gis.db.models.lookups import GISLookup
+from django.db import NotSupportedError
+
+
+def gis_lookup(self, compiler, connection):  # noqa: ARG001
+    raise NotSupportedError(f"MongoDB does not support the {self.lookup_name} lookup.")
+
+
+def register_lookups():
+    GISLookup.as_mql = gis_lookup

django_mongodb_backend_gis/operations.py

@@ -0,0 +1,109 @@
+from django.contrib.gis import geos
+from django.contrib.gis.db import models
+from django.contrib.gis.db.backends.base.operations import BaseSpatialOperations
+
+from django_mongodb_backend.operations import (
+    DatabaseOperations as MongoOperations,
+)
+
+from .adapter import Adapter
+
+
+class DatabaseOperations(BaseSpatialOperations, MongoOperations):
+    Adapter = Adapter
+
+    disallowed_aggregates = (
+        models.Collect,
+        models.Extent,
+        models.Extent3D,
+        models.MakeLine,
+        models.Union,
+    )
+
+    @property
+    def gis_operators(self):
+        return {}
+
+    unsupported_functions = {
+        "Area",
+        "AsGeoJSON",
+        "AsGML",
+        "AsKML",
+        "AsSVG",
+        "AsWKB",
+        "AsWKT",
+        "Azimuth",
+        "BoundingCircle",
+        "Centroid",
+        "ClosestPoint",
+        "Difference",
+        "Distance",
+        "Envelope",
+        "ForcePolygonCW",
+        "FromWKB",
+        "FromWKT",
+        "GeoHash",
+        "GeometryDistance",
+        "Intersection",
+        "IsEmpty",
+        "IsValid",
+        "Length",
+        "LineLocatePoint",
+        "MakeValid",
+        "MemSize",
+        "NumGeometries",
+        "NumPoints",
+        "Perimeter",
+        "PointOnSurface",
+        "Reverse",
+        "Scale",
+        "SnapToGrid",
+        "SymDifference",
+        "Transform",
+        "Translate",
+        "Union",
+    }
+
+    def geo_db_type(self, f):
+        return "object"
+
+    def get_geometry_converter(self, expression):
+        srid = expression.output_field.srid
+
+        def geom_from_coordinates(geom_class, coordinates):
+            is_polygon = geom_class.__name__ == "Polygon"
+            return geom_class(*coordinates if is_polygon else coordinates, srid=srid)
+
+        def converter(value, expression, connection):  # noqa: ARG001
+            if value is None:
+                return None
+
+            geom_class = getattr(geos, value["type"])
+            if geom_class.__name__ == "GeometryCollection":
+                return geom_class(
+                    [
+                        geom_from_coordinates(getattr(geos, v["type"]), v["coordinates"])
+                        for v in value["geometries"]
+                    ],
+                    srid=srid,
+                )
+            if issubclass(geom_class, geos.GeometryCollection):
+                sub_geom_class = geom_class._allowed
+                # MultiLineString allows both LineString and LinearRing but should be
+                # initialized with LineString.
+                if isinstance(sub_geom_class, tuple):
+                    sub_geom_class = sub_geom_class[0]
+                return geom_class(
+                    [
+                        sub_geom_class(
+                            *value["coordinates"][x]
+                            if geom_class.__name__ == "MultiPolygon"
+                            else value["coordinates"][x]
+                        )
+                        for x in range(len(value["coordinates"]))
+                    ],
+                    srid=srid,
+                )
+            return geom_from_coordinates(geom_class, value["coordinates"])
+
+        return converter

django_mongodb_backend_gis/schema.py

@@ -0,0 +1,58 @@
+from pymongo import GEOSPHERE
+from pymongo.operations import IndexModel
+
+from django_mongodb_backend.schema import DatabaseSchemaEditor as BaseSchemaEditor
+
+
+class DatabaseSchemaEditor(BaseSchemaEditor):
+    def _field_should_be_indexed(self, model, field):
+        if getattr(field, "spatial_index", False):
+            return True
+        return super()._field_should_be_indexed(model, field)
+
+    def _add_field_index(self, model, field, *, column_prefix=""):
+        if hasattr(field, "geodetic"):
+            self._add_spatial_index(model, field)
+        else:
+            super()._add_field_index(model, field, column_prefix=column_prefix)
+
+    def _alter_field(
+        self,
+        model,
+        old_field,
+        new_field,
+        old_type,
+        new_type,
+        old_db_params,
+        new_db_params,
+        strict=False,
+    ):
+        super()._alter_field(
+            model,
+            old_field,
+            new_field,
+            old_type,
+            new_type,
+            old_db_params,
+            new_db_params,
+            strict=strict,
+        )
+        old_field_spatial_index = getattr(old_field, "spatial_index", False)
+        new_field_spatial_index = getattr(new_field, "spatial_index", False)
+        if not old_field_spatial_index and new_field_spatial_index:
+            self._add_spatial_index(model, new_field)
+        elif old_field_spatial_index and not new_field_spatial_index:
+            self._delete_spatial_index(model, new_field)
+
+    def _add_spatial_index(self, model, field):
+        index_name = self._create_spatial_index_name(model, field)
+        self.get_collection(model._meta.db_table).create_indexes(
+            [IndexModel([(field.column, GEOSPHERE)], name=index_name)]
+        )
+
+    def _delete_spatial_index(self, model, field):
+        index_name = self._create_spatial_index_name(model, field)
+        self.get_collection(model._meta.db_table).drop_index(index_name)
+
+    def _create_spatial_index_name(self, model, field):
+        return f"{model._meta.db_table}_{field.column}_id"