änderung1

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/base/features.py

@@ -0,0 +1,98 @@
+import re
+
+from django.contrib.gis.db.models import aggregates
+
+
+class BaseSpatialFeatures:
+    gis_enabled = True
+
+    # Does the database contain a SpatialRefSys model to store SRID information?
+    has_spatialrefsys_table = True
+
+    # Does the backend support the django.contrib.gis.utils.add_srs_entry() utility?
+    supports_add_srs_entry = True
+    # Does the backend introspect GeometryField to its subtypes?
+    supports_geometry_field_introspection = True
+
+    # Does the backend support storing 3D geometries?
+    supports_3d_storage = False
+    # Reference implementation of 3D functions is:
+    # https://postgis.net/docs/PostGIS_Special_Functions_Index.html#PostGIS_3D_Functions
+    supports_3d_functions = False
+    # Does the database support SRID transform operations?
+    supports_transform = True
+    # Do geometric relationship operations operate on real shapes (or only on bounding boxes)?
+    supports_real_shape_operations = True
+    # Can geometry fields be null?
+    supports_null_geometries = True
+    # Are empty geometries supported?
+    supports_empty_geometries = False
+    # Can the function be applied on geodetic coordinate systems?
+    supports_distance_geodetic = True
+    supports_length_geodetic = True
+    supports_perimeter_geodetic = False
+    supports_area_geodetic = True
+    # Is the database able to count vertices on polygons (with `num_points`)?
+    supports_num_points_poly = True
+
+    # The following properties indicate if the database backend support
+    # certain lookups (dwithin, left and right, relate, ...)
+    supports_left_right_lookups = False
+
+    # Does the database have raster support?
+    supports_raster = False
+
+    # Does the database support a unique index on geometry fields?
+    supports_geometry_field_unique_index = True
+
+    @property
+    def supports_bbcontains_lookup(self):
+        return 'bbcontains' in self.connection.ops.gis_operators
+
+    @property
+    def supports_contained_lookup(self):
+        return 'contained' in self.connection.ops.gis_operators
+
+    @property
+    def supports_crosses_lookup(self):
+        return 'crosses' in self.connection.ops.gis_operators
+
+    @property
+    def supports_distances_lookups(self):
+        return self.has_Distance_function
+
+    @property
+    def supports_dwithin_lookup(self):
+        return 'dwithin' in self.connection.ops.gis_operators
+
+    @property
+    def supports_relate_lookup(self):
+        return 'relate' in self.connection.ops.gis_operators
+
+    @property
+    def supports_isvalid_lookup(self):
+        return self.has_IsValid_function
+
+    # Is the aggregate supported by the database?
+    @property
+    def supports_collect_aggr(self):
+        return aggregates.Collect not in self.connection.ops.disallowed_aggregates
+
+    @property
+    def supports_extent_aggr(self):
+        return aggregates.Extent not in self.connection.ops.disallowed_aggregates
+
+    @property
+    def supports_make_line_aggr(self):
+        return aggregates.MakeLine not in self.connection.ops.disallowed_aggregates
+
+    @property
+    def supports_union_aggr(self):
+        return aggregates.Union not in self.connection.ops.disallowed_aggregates
+
+    def __getattr__(self, name):
+        m = re.match(r'has_(\w*)_function$', name)
+        if m:
+            func_name = m.group(1)
+            return func_name not in self.connection.ops.unsupported_functions
+        raise AttributeError

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/base/models.py

@@ -0,0 +1,136 @@
+from django.contrib.gis import gdal
+
+
+class SpatialRefSysMixin:
+    """
+    The SpatialRefSysMixin is a class used by the database-dependent
+    SpatialRefSys objects to reduce redundant code.
+    """
+    @property
+    def srs(self):
+        """
+        Return a GDAL SpatialReference object.
+        """
+        # TODO: Is caching really necessary here?  Is complexity worth it?
+        if hasattr(self, '_srs'):
+            # Returning a clone of the cached SpatialReference object.
+            return self._srs.clone()
+        else:
+            # Attempting to cache a SpatialReference object.
+
+            # Trying to get from WKT first.
+            try:
+                self._srs = gdal.SpatialReference(self.wkt)
+                return self.srs
+            except Exception as e:
+                msg = e
+
+            try:
+                self._srs = gdal.SpatialReference(self.proj4text)
+                return self.srs
+            except Exception as e:
+                msg = e
+
+            raise Exception('Could not get OSR SpatialReference from WKT: %s\nError:\n%s' % (self.wkt, msg))
+
+    @property
+    def ellipsoid(self):
+        """
+        Return a tuple of the ellipsoid parameters:
+        (semimajor axis, semiminor axis, and inverse flattening).
+        """
+        return self.srs.ellipsoid
+
+    @property
+    def name(self):
+        "Return the projection name."
+        return self.srs.name
+
+    @property
+    def spheroid(self):
+        "Return the spheroid name for this spatial reference."
+        return self.srs['spheroid']
+
+    @property
+    def datum(self):
+        "Return the datum for this spatial reference."
+        return self.srs['datum']
+
+    @property
+    def projected(self):
+        "Is this Spatial Reference projected?"
+        return self.srs.projected
+
+    @property
+    def local(self):
+        "Is this Spatial Reference local?"
+        return self.srs.local
+
+    @property
+    def geographic(self):
+        "Is this Spatial Reference geographic?"
+        return self.srs.geographic
+
+    @property
+    def linear_name(self):
+        "Return the linear units name."
+        return self.srs.linear_name
+
+    @property
+    def linear_units(self):
+        "Return the linear units."
+        return self.srs.linear_units
+
+    @property
+    def angular_name(self):
+        "Return the name of the angular units."
+        return self.srs.angular_name
+
+    @property
+    def angular_units(self):
+        "Return the angular units."
+        return self.srs.angular_units
+
+    @property
+    def units(self):
+        "Return a tuple of the units and the name."
+        if self.projected or self.local:
+            return (self.linear_units, self.linear_name)
+        elif self.geographic:
+            return (self.angular_units, self.angular_name)
+        else:
+            return (None, None)
+
+    @classmethod
+    def get_units(cls, wkt):
+        """
+        Return a tuple of (unit_value, unit_name) for the given WKT without
+        using any of the database fields.
+        """
+        return gdal.SpatialReference(wkt).units
+
+    @classmethod
+    def get_spheroid(cls, wkt, string=True):
+        """
+        Class method used by GeometryField on initialization to
+        retrieve the `SPHEROID[..]` parameters from the given WKT.
+        """
+        srs = gdal.SpatialReference(wkt)
+        sphere_params = srs.ellipsoid
+        sphere_name = srs['spheroid']
+
+        if not string:
+            return sphere_name, sphere_params
+        else:
+            # `string` parameter used to place in format acceptable by PostGIS
+            if len(sphere_params) == 3:
+                radius, flattening = sphere_params[0], sphere_params[2]
+            else:
+                radius, flattening = sphere_params
+            return 'SPHEROID["%s",%s,%s]' % (sphere_name, radius, flattening)
+
+    def __str__(self):
+        """
+        Return the string representation, a 'pretty' OGC WKT.
+        """
+        return str(self.srs)

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/base/operations.py

@@ -0,0 +1,162 @@
+from django.contrib.gis.db.models import GeometryField
+from django.contrib.gis.db.models.functions import Distance
+from django.contrib.gis.measure import (
+    Area as AreaMeasure, Distance as DistanceMeasure,
+)
+from django.db.utils import NotSupportedError
+from django.utils.functional import cached_property
+
+
+class BaseSpatialOperations:
+    # Quick booleans for the type of this spatial backend, and
+    # an attribute for the spatial database version tuple (if applicable)
+    postgis = False
+    spatialite = False
+    mysql = False
+    oracle = False
+    spatial_version = None
+
+    # How the geometry column should be selected.
+    select = '%s'
+
+    @cached_property
+    def select_extent(self):
+        return self.select
+
+    # Does the spatial database have a geometry or geography type?
+    geography = False
+    geometry = False
+
+    # Aggregates
+    disallowed_aggregates = ()
+
+    geom_func_prefix = ''
+
+    # Mapping between Django function names and backend names, when names do not
+    # match; used in spatial_function_name().
+    function_names = {}
+
+    # Blacklist/set of known unsupported functions of the backend
+    unsupported_functions = {
+        'Area', 'AsGeoJSON', 'AsGML', 'AsKML', 'AsSVG', 'Azimuth',
+        'BoundingCircle', 'Centroid', 'Difference', 'Distance', 'Envelope',
+        'ForceRHR', 'GeoHash', 'Intersection', 'IsValid', 'Length',
+        'LineLocatePoint', 'MakeValid', 'MemSize', 'NumGeometries',
+        'NumPoints', 'Perimeter', 'PointOnSurface', 'Reverse', 'Scale',
+        'SnapToGrid', 'SymDifference', 'Transform', 'Translate', 'Union',
+    }
+
+    # Constructors
+    from_text = False
+
+    # Default conversion functions for aggregates; will be overridden if implemented
+    # for the spatial backend.
+    def convert_extent(self, box, srid):
+        raise NotImplementedError('Aggregate extent not implemented for this spatial backend.')
+
+    def convert_extent3d(self, box, srid):
+        raise NotImplementedError('Aggregate 3D extent not implemented for this spatial backend.')
+
+    # For quoting column values, rather than columns.
+    def geo_quote_name(self, name):
+        return "'%s'" % name
+
+    # GeometryField operations
+    def geo_db_type(self, f):
+        """
+        Return the database column type for the geometry field on
+        the spatial backend.
+        """
+        raise NotImplementedError('subclasses of BaseSpatialOperations must provide a geo_db_type() method')
+
+    def get_distance(self, f, value, lookup_type):
+        """
+        Return the distance parameters for the given geometry field,
+        lookup value, and lookup type.
+        """
+        raise NotImplementedError('Distance operations not available on this spatial backend.')
+
+    def get_geom_placeholder(self, f, value, compiler):
+        """
+        Return the placeholder for the given geometry field with the given
+        value.  Depending on the spatial backend, the placeholder may contain a
+        stored procedure call to the transformation function of the spatial
+        backend.
+        """
+        def transform_value(value, field):
+            return value is not None and value.srid != field.srid
+
+        if hasattr(value, 'as_sql'):
+            return (
+                '%s(%%s, %s)' % (self.spatial_function_name('Transform'), f.srid)
+                if transform_value(value.output_field, f)
+                else '%s'
+            )
+        if transform_value(value, f):
+            # Add Transform() to the SQL placeholder.
+            return '%s(%s(%%s,%s), %s)' % (
+                self.spatial_function_name('Transform'),
+                self.from_text, value.srid, f.srid,
+            )
+        elif self.connection.features.has_spatialrefsys_table:
+            return '%s(%%s,%s)' % (self.from_text, f.srid)
+        else:
+            # For backwards compatibility on MySQL (#27464).
+            return '%s(%%s)' % self.from_text
+
+    def check_expression_support(self, expression):
+        if isinstance(expression, self.disallowed_aggregates):
+            raise NotSupportedError(
+                "%s spatial aggregation is not supported by this database backend." % expression.name
+            )
+        super().check_expression_support(expression)
+
+    def spatial_aggregate_name(self, agg_name):
+        raise NotImplementedError('Aggregate support not implemented for this spatial backend.')
+
+    def spatial_function_name(self, func_name):
+        if func_name in self.unsupported_functions:
+            raise NotSupportedError("This backend doesn't support the %s function." % func_name)
+        return self.function_names.get(func_name, self.geom_func_prefix + func_name)
+
+    # Routines for getting the OGC-compliant models.
+    def geometry_columns(self):
+        raise NotImplementedError('Subclasses of BaseSpatialOperations must provide a geometry_columns() method.')
+
+    def spatial_ref_sys(self):
+        raise NotImplementedError('subclasses of BaseSpatialOperations must a provide spatial_ref_sys() method')
+
+    distance_expr_for_lookup = staticmethod(Distance)
+
+    def get_db_converters(self, expression):
+        converters = super().get_db_converters(expression)
+        if isinstance(expression.output_field, GeometryField):
+            converters.append(self.get_geometry_converter(expression))
+        return converters
+
+    def get_geometry_converter(self, expression):
+        raise NotImplementedError(
+            'Subclasses of BaseSpatialOperations must provide a '
+            'get_geometry_converter() method.'
+        )
+
+    def get_area_att_for_field(self, field):
+        if field.geodetic(self.connection):
+            if self.connection.features.supports_area_geodetic:
+                return 'sq_m'
+            raise NotImplementedError('Area on geodetic coordinate systems not supported.')
+        else:
+            units_name = field.units_name(self.connection)
+            if units_name:
+                return AreaMeasure.unit_attname(units_name)
+
+    def get_distance_att_for_field(self, field):
+        dist_att = None
+        if field.geodetic(self.connection):
+            if self.connection.features.supports_distance_geodetic:
+                dist_att = 'm'
+        else:
+            units = field.units_name(self.connection)
+            if units:
+                dist_att = DistanceMeasure.unit_attname(units)
+        return dist_att

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/mysql/schema.py

@@ -0,0 +1,77 @@
+import logging
+
+from django.contrib.gis.db.models.fields import GeometryField
+from django.db.backends.mysql.schema import DatabaseSchemaEditor
+from django.db.utils import OperationalError
+
+logger = logging.getLogger('django.contrib.gis')
+
+
+class MySQLGISSchemaEditor(DatabaseSchemaEditor):
+    sql_add_spatial_index = 'CREATE SPATIAL INDEX %(index)s ON %(table)s(%(column)s)'
+    sql_drop_spatial_index = 'DROP INDEX %(index)s ON %(table)s'
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.geometry_sql = []
+
+    def skip_default(self, field):
+        return (
+            super().skip_default(field) or
+            # Geometry fields are stored as BLOB/TEXT and can't have defaults.
+            isinstance(field, GeometryField)
+        )
+
+    def column_sql(self, model, field, include_default=False):
+        column_sql = super().column_sql(model, field, include_default)
+        # MySQL doesn't support spatial indexes on NULL columns
+        if isinstance(field, GeometryField) and field.spatial_index and not field.null:
+            qn = self.connection.ops.quote_name
+            db_table = model._meta.db_table
+            self.geometry_sql.append(
+                self.sql_add_spatial_index % {
+                    'index': qn(self._create_spatial_index_name(model, field)),
+                    'table': qn(db_table),
+                    'column': qn(field.column),
+                }
+            )
+        return column_sql
+
+    def create_model(self, model):
+        super().create_model(model)
+        self.create_spatial_indexes()
+
+    def add_field(self, model, field):
+        super().add_field(model, field)
+        self.create_spatial_indexes()
+
+    def remove_field(self, model, field):
+        if isinstance(field, GeometryField) and field.spatial_index:
+            qn = self.connection.ops.quote_name
+            sql = self.sql_drop_spatial_index % {
+                'index': qn(self._create_spatial_index_name(model, field)),
+                'table': qn(model._meta.db_table),
+            }
+            try:
+                self.execute(sql)
+            except OperationalError:
+                logger.error(
+                    "Couldn't remove spatial index: %s (may be expected "
+                    "if your storage engine doesn't support them).", sql
+                )
+
+        super().remove_field(model, field)
+
+    def _create_spatial_index_name(self, model, field):
+        return '%s_%s_id' % (model._meta.db_table, field.column)
+
+    def create_spatial_indexes(self):
+        for sql in self.geometry_sql:
+            try:
+                self.execute(sql)
+            except OperationalError:
+                logger.error(
+                    "Cannot create SPATIAL INDEX %s. Only MyISAM and (as of "
+                    "MySQL 5.7.5) InnoDB support them.", sql
+                )
+        self.geometry_sql = []

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/oracle/adapter.py

@@ -0,0 +1,57 @@
+from cx_Oracle import CLOB
+
+from django.contrib.gis.db.backends.base.adapter import WKTAdapter
+from django.contrib.gis.geos import GeometryCollection, Polygon
+
+
+class OracleSpatialAdapter(WKTAdapter):
+    input_size = CLOB
+
+    def __init__(self, geom):
+        """
+        Oracle requires that polygon rings are in proper orientation. This
+        affects spatial operations and an invalid orientation may cause
+        failures. Correct orientations are:
+         * Outer ring - counter clockwise
+         * Inner ring(s) - clockwise
+        """
+        if isinstance(geom, Polygon):
+            self._fix_polygon(geom)
+        elif isinstance(geom, GeometryCollection):
+            self._fix_geometry_collection(geom)
+
+        self.wkt = geom.wkt
+        self.srid = geom.srid
+
+    def _fix_polygon(self, poly):
+        """Fix single polygon orientation as described in __init__()."""
+        if self._isClockwise(poly.exterior_ring):
+            poly.exterior_ring = list(reversed(poly.exterior_ring))
+
+        for i in range(1, len(poly)):
+            if not self._isClockwise(poly[i]):
+                poly[i] = list(reversed(poly[i]))
+
+        return poly
+
+    def _fix_geometry_collection(self, coll):
+        """
+        Fix polygon orientations in geometry collections as described in
+        __init__().
+        """
+        for i, geom in enumerate(coll):
+            if isinstance(geom, Polygon):
+                coll[i] = self._fix_polygon(geom)
+
+    def _isClockwise(self, coords):
+        """
+        A modified shoelace algorithm to determine polygon orientation.
+        See https://en.wikipedia.org/wiki/Shoelace_formula.
+        """
+        n = len(coords)
+        area = 0.0
+        for i in range(n):
+            j = (i + 1) % n
+            area += coords[i][0] * coords[j][1]
+            area -= coords[j][0] * coords[i][1]
+        return area < 0.0

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/oracle/base.py

@@ -0,0 +1,16 @@
+from django.db.backends.oracle.base import (
+    DatabaseWrapper as OracleDatabaseWrapper,
+)
+
+from .features import DatabaseFeatures
+from .introspection import OracleIntrospection
+from .operations import OracleOperations
+from .schema import OracleGISSchemaEditor
+
+
+class DatabaseWrapper(OracleDatabaseWrapper):
+    SchemaEditorClass = OracleGISSchemaEditor
+    # Classes instantiated in __init__().
+    features_class = DatabaseFeatures
+    introspection_class = OracleIntrospection
+    ops_class = OracleOperations

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/oracle/introspection.py

@@ -0,0 +1,42 @@
+import cx_Oracle
+
+from django.db.backends.oracle.introspection import DatabaseIntrospection
+
+
+class OracleIntrospection(DatabaseIntrospection):
+    # Associating any OBJECTVAR instances with GeometryField.  Of course,
+    # this won't work right on Oracle objects that aren't MDSYS.SDO_GEOMETRY,
+    # but it is the only object type supported within Django anyways.
+    data_types_reverse = DatabaseIntrospection.data_types_reverse.copy()
+    data_types_reverse[cx_Oracle.OBJECT] = 'GeometryField'
+
+    def get_geometry_type(self, table_name, geo_col):
+        with self.connection.cursor() as cursor:
+            # Querying USER_SDO_GEOM_METADATA to get the SRID and dimension information.
+            try:
+                cursor.execute(
+                    'SELECT "DIMINFO", "SRID" FROM "USER_SDO_GEOM_METADATA" '
+                    'WHERE "TABLE_NAME"=%s AND "COLUMN_NAME"=%s',
+                    (table_name.upper(), geo_col.upper())
+                )
+                row = cursor.fetchone()
+            except Exception as exc:
+                raise Exception(
+                    'Could not find entry in USER_SDO_GEOM_METADATA '
+                    'corresponding to "%s"."%s"' % (table_name, geo_col)
+                ) from exc
+
+            # TODO: Research way to find a more specific geometry field type for
+            # the column's contents.
+            field_type = 'GeometryField'
+
+            # Getting the field parameters.
+            field_params = {}
+            dim, srid = row
+            if srid != 4326:
+                field_params['srid'] = srid
+            # Size of object array (SDO_DIM_ARRAY) is number of dimensions.
+            dim = dim.size()
+            if dim != 2:
+                field_params['dim'] = dim
+        return field_type, field_params

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/oracle/operations.py

@@ -0,0 +1,217 @@
+"""
+ This module contains the spatial lookup types, and the `get_geo_where_clause`
+ routine for Oracle Spatial.
+
+ Please note that WKT support is broken on the XE version, and thus
+ this backend will not work on such platforms.  Specifically, XE lacks
+ support for an internal JVM, and Java libraries are required to use
+ the WKT constructors.
+"""
+import re
+
+from django.contrib.gis.db.backends.base.operations import (
+    BaseSpatialOperations,
+)
+from django.contrib.gis.db.backends.oracle.adapter import OracleSpatialAdapter
+from django.contrib.gis.db.backends.utils import SpatialOperator
+from django.contrib.gis.db.models import aggregates
+from django.contrib.gis.geos.geometry import GEOSGeometry, GEOSGeometryBase
+from django.contrib.gis.geos.prototypes.io import wkb_r
+from django.contrib.gis.measure import Distance
+from django.db.backends.oracle.operations import DatabaseOperations
+
+DEFAULT_TOLERANCE = '0.05'
+
+
+class SDOOperator(SpatialOperator):
+    sql_template = "%(func)s(%(lhs)s, %(rhs)s) = 'TRUE'"
+
+
+class SDODWithin(SpatialOperator):
+    sql_template = "SDO_WITHIN_DISTANCE(%(lhs)s, %(rhs)s, %%s) = 'TRUE'"
+
+
+class SDODisjoint(SpatialOperator):
+    sql_template = "SDO_GEOM.RELATE(%%(lhs)s, 'DISJOINT', %%(rhs)s, %s) = 'DISJOINT'" % DEFAULT_TOLERANCE
+
+
+class SDORelate(SpatialOperator):
+    sql_template = "SDO_RELATE(%(lhs)s, %(rhs)s, 'mask=%(mask)s') = 'TRUE'"
+
+    def check_relate_argument(self, arg):
+        masks = 'TOUCH|OVERLAPBDYDISJOINT|OVERLAPBDYINTERSECT|EQUAL|INSIDE|COVEREDBY|CONTAINS|COVERS|ANYINTERACT|ON'
+        mask_regex = re.compile(r'^(%s)(\+(%s))*$' % (masks, masks), re.I)
+        if not isinstance(arg, str) or not mask_regex.match(arg):
+            raise ValueError('Invalid SDO_RELATE mask: "%s"' % arg)
+
+    def as_sql(self, connection, lookup, template_params, sql_params):
+        template_params['mask'] = sql_params.pop()
+        return super().as_sql(connection, lookup, template_params, sql_params)
+
+
+class OracleOperations(BaseSpatialOperations, DatabaseOperations):
+
+    name = 'oracle'
+    oracle = True
+    disallowed_aggregates = (aggregates.Collect, aggregates.Extent3D, aggregates.MakeLine)
+
+    Adapter = OracleSpatialAdapter
+
+    extent = 'SDO_AGGR_MBR'
+    unionagg = 'SDO_AGGR_UNION'
+
+    from_text = 'SDO_GEOMETRY'
+
+    function_names = {
+        'Area': 'SDO_GEOM.SDO_AREA',
+        'BoundingCircle': 'SDO_GEOM.SDO_MBC',
+        'Centroid': 'SDO_GEOM.SDO_CENTROID',
+        'Difference': 'SDO_GEOM.SDO_DIFFERENCE',
+        'Distance': 'SDO_GEOM.SDO_DISTANCE',
+        'Envelope': 'SDO_GEOM_MBR',
+        'Intersection': 'SDO_GEOM.SDO_INTERSECTION',
+        'IsValid': 'SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT',
+        'Length': 'SDO_GEOM.SDO_LENGTH',
+        'NumGeometries': 'SDO_UTIL.GETNUMELEM',
+        'NumPoints': 'SDO_UTIL.GETNUMVERTICES',
+        'Perimeter': 'SDO_GEOM.SDO_LENGTH',
+        'PointOnSurface': 'SDO_GEOM.SDO_POINTONSURFACE',
+        'Reverse': 'SDO_UTIL.REVERSE_LINESTRING',
+        'SymDifference': 'SDO_GEOM.SDO_XOR',
+        'Transform': 'SDO_CS.TRANSFORM',
+        'Union': 'SDO_GEOM.SDO_UNION',
+    }
+
+    # We want to get SDO Geometries as WKT because it is much easier to
+    # instantiate GEOS proxies from WKT than SDO_GEOMETRY(...) strings.
+    # However, this adversely affects performance (i.e., Java is called
+    # to convert to WKT on every query).  If someone wishes to write a
+    # SDO_GEOMETRY(...) parser in Python, let me know =)
+    select = 'SDO_UTIL.TO_WKBGEOMETRY(%s)'
+
+    gis_operators = {
+        'contains': SDOOperator(func='SDO_CONTAINS'),
+        'coveredby': SDOOperator(func='SDO_COVEREDBY'),
+        'covers': SDOOperator(func='SDO_COVERS'),
+        'disjoint': SDODisjoint(),
+        'intersects': SDOOperator(func='SDO_OVERLAPBDYINTERSECT'),  # TODO: Is this really the same as ST_Intersects()?
+        'equals': SDOOperator(func='SDO_EQUAL'),
+        'exact': SDOOperator(func='SDO_EQUAL'),
+        'overlaps': SDOOperator(func='SDO_OVERLAPS'),
+        'same_as': SDOOperator(func='SDO_EQUAL'),
+        'relate': SDORelate(),  # Oracle uses a different syntax, e.g., 'mask=inside+touch'
+        'touches': SDOOperator(func='SDO_TOUCH'),
+        'within': SDOOperator(func='SDO_INSIDE'),
+        'dwithin': SDODWithin(),
+    }
+
+    unsupported_functions = {
+        'AsGeoJSON', 'AsKML', 'AsSVG', 'Azimuth',
+        'ForcePolygonCW', 'ForceRHR', 'GeoHash', 'LineLocatePoint',
+        'MakeValid', 'MemSize', 'Scale', 'SnapToGrid', 'Translate',
+    }
+
+    def geo_quote_name(self, name):
+        return super().geo_quote_name(name).upper()
+
+    def convert_extent(self, clob):
+        if clob:
+            # Generally, Oracle returns a polygon for the extent -- however,
+            # it can return a single point if there's only one Point in the
+            # table.
+            ext_geom = GEOSGeometry(memoryview(clob.read()))
+            gtype = str(ext_geom.geom_type)
+            if gtype == 'Polygon':
+                # Construct the 4-tuple from the coordinates in the polygon.
+                shell = ext_geom.shell
+                ll, ur = shell[0][:2], shell[2][:2]
+            elif gtype == 'Point':
+                ll = ext_geom.coords[:2]
+                ur = ll
+            else:
+                raise Exception('Unexpected geometry type returned for extent: %s' % gtype)
+            xmin, ymin = ll
+            xmax, ymax = ur
+            return (xmin, ymin, xmax, ymax)
+        else:
+            return None
+
+    def geo_db_type(self, f):
+        """
+        Return the geometry database type for Oracle. Unlike other spatial
+        backends, no stored procedure is necessary and it's the same for all
+        geometry types.
+        """
+        return 'MDSYS.SDO_GEOMETRY'
+
+    def get_distance(self, f, value, lookup_type):
+        """
+        Return the distance parameters given the value and the lookup type.
+        On Oracle, geometry columns with a geodetic coordinate system behave
+        implicitly like a geography column, and thus meters will be used as
+        the distance parameter on them.
+        """
+        if not value:
+            return []
+        value = value[0]
+        if isinstance(value, Distance):
+            if f.geodetic(self.connection):
+                dist_param = value.m
+            else:
+                dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection)))
+        else:
+            dist_param = value
+
+        # dwithin lookups on Oracle require a special string parameter
+        # that starts with "distance=".
+        if lookup_type == 'dwithin':
+            dist_param = 'distance=%s' % dist_param
+
+        return [dist_param]
+
+    def get_geom_placeholder(self, f, value, compiler):
+        if value is None:
+            return 'NULL'
+        return super().get_geom_placeholder(f, value, compiler)
+
+    def spatial_aggregate_name(self, agg_name):
+        """
+        Return the spatial aggregate SQL name.
+        """
+        agg_name = 'unionagg' if agg_name.lower() == 'union' else agg_name.lower()
+        return getattr(self, agg_name)
+
+    # Routines for getting the OGC-compliant models.
+    def geometry_columns(self):
+        from django.contrib.gis.db.backends.oracle.models import OracleGeometryColumns
+        return OracleGeometryColumns
+
+    def spatial_ref_sys(self):
+        from django.contrib.gis.db.backends.oracle.models import OracleSpatialRefSys
+        return OracleSpatialRefSys
+
+    def modify_insert_params(self, placeholder, params):
+        """Drop out insert parameters for NULL placeholder. Needed for Oracle Spatial
+        backend due to #10888.
+        """
+        if placeholder == 'NULL':
+            return []
+        return super().modify_insert_params(placeholder, params)
+
+    def get_geometry_converter(self, expression):
+        read = wkb_r().read
+        srid = expression.output_field.srid
+        if srid == -1:
+            srid = None
+        geom_class = expression.output_field.geom_class
+
+        def converter(value, expression, connection):
+            if value is not None:
+                geom = GEOSGeometryBase(read(memoryview(value.read())), geom_class)
+                if srid:
+                    geom.srid = srid
+                return geom
+        return converter
+
+    def get_area_att_for_field(self, field):
+        return 'sq_m'

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/oracle/schema.py

@@ -0,0 +1,94 @@
+from django.contrib.gis.db.models.fields import GeometryField
+from django.db.backends.oracle.schema import DatabaseSchemaEditor
+from django.db.backends.utils import strip_quotes, truncate_name
+
+
+class OracleGISSchemaEditor(DatabaseSchemaEditor):
+    sql_add_geometry_metadata = ("""
+        INSERT INTO USER_SDO_GEOM_METADATA
+            ("TABLE_NAME", "COLUMN_NAME", "DIMINFO", "SRID")
+        VALUES (
+            %(table)s,
+            %(column)s,
+            MDSYS.SDO_DIM_ARRAY(
+                MDSYS.SDO_DIM_ELEMENT('LONG', %(dim0)s, %(dim2)s, %(tolerance)s),
+                MDSYS.SDO_DIM_ELEMENT('LAT', %(dim1)s, %(dim3)s, %(tolerance)s)
+            ),
+            %(srid)s
+        )""")
+    sql_add_spatial_index = 'CREATE INDEX %(index)s ON %(table)s(%(column)s) INDEXTYPE IS MDSYS.SPATIAL_INDEX'
+    sql_drop_spatial_index = 'DROP INDEX %(index)s'
+    sql_clear_geometry_table_metadata = 'DELETE FROM USER_SDO_GEOM_METADATA WHERE TABLE_NAME = %(table)s'
+    sql_clear_geometry_field_metadata = (
+        'DELETE FROM USER_SDO_GEOM_METADATA WHERE TABLE_NAME = %(table)s '
+        'AND COLUMN_NAME = %(column)s'
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.geometry_sql = []
+
+    def geo_quote_name(self, name):
+        return self.connection.ops.geo_quote_name(name)
+
+    def column_sql(self, model, field, include_default=False):
+        column_sql = super().column_sql(model, field, include_default)
+        if isinstance(field, GeometryField):
+            db_table = model._meta.db_table
+            self.geometry_sql.append(
+                self.sql_add_geometry_metadata % {
+                    'table': self.geo_quote_name(db_table),
+                    'column': self.geo_quote_name(field.column),
+                    'dim0': field._extent[0],
+                    'dim1': field._extent[1],
+                    'dim2': field._extent[2],
+                    'dim3': field._extent[3],
+                    'tolerance': field._tolerance,
+                    'srid': field.srid,
+                }
+            )
+            if field.spatial_index:
+                self.geometry_sql.append(
+                    self.sql_add_spatial_index % {
+                        'index': self.quote_name(self._create_spatial_index_name(model, field)),
+                        'table': self.quote_name(db_table),
+                        'column': self.quote_name(field.column),
+                    }
+                )
+        return column_sql
+
+    def create_model(self, model):
+        super().create_model(model)
+        self.run_geometry_sql()
+
+    def delete_model(self, model):
+        super().delete_model(model)
+        self.execute(self.sql_clear_geometry_table_metadata % {
+            'table': self.geo_quote_name(model._meta.db_table),
+        })
+
+    def add_field(self, model, field):
+        super().add_field(model, field)
+        self.run_geometry_sql()
+
+    def remove_field(self, model, field):
+        if isinstance(field, GeometryField):
+            self.execute(self.sql_clear_geometry_field_metadata % {
+                'table': self.geo_quote_name(model._meta.db_table),
+                'column': self.geo_quote_name(field.column),
+            })
+            if field.spatial_index:
+                self.execute(self.sql_drop_spatial_index % {
+                    'index': self.quote_name(self._create_spatial_index_name(model, field)),
+                })
+        super().remove_field(model, field)
+
+    def run_geometry_sql(self):
+        for sql in self.geometry_sql:
+            self.execute(sql)
+        self.geometry_sql = []
+
+    def _create_spatial_index_name(self, model, field):
+        # Oracle doesn't allow object names > 30 characters. Use this scheme
+        # instead of self._create_index_name() for backwards compatibility.
+        return truncate_name('%s_%s_id' % (strip_quotes(model._meta.db_table), field.column), 30)

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/adapter.py

@@ -0,0 +1,65 @@
+"""
+ This object provides quoting for GEOS geometries into PostgreSQL/PostGIS.
+"""
+from psycopg2 import Binary
+from psycopg2.extensions import ISQLQuote
+
+from django.contrib.gis.db.backends.postgis.pgraster import to_pgraster
+from django.contrib.gis.geos import GEOSGeometry
+
+
+class PostGISAdapter:
+    def __init__(self, obj, geography=False):
+        """
+        Initialize on the spatial object.
+        """
+        self.is_geometry = isinstance(obj, (GEOSGeometry, PostGISAdapter))
+
+        # Getting the WKB (in string form, to allow easy pickling of
+        # the adaptor) and the SRID from the geometry or raster.
+        if self.is_geometry:
+            self.ewkb = bytes(obj.ewkb)
+            self._adapter = Binary(self.ewkb)
+        else:
+            self.ewkb = to_pgraster(obj)
+
+        self.srid = obj.srid
+        self.geography = geography
+
+    def __conform__(self, proto):
+        """Does the given protocol conform to what Psycopg2 expects?"""
+        if proto == ISQLQuote:
+            return self
+        else:
+            raise Exception('Error implementing psycopg2 protocol. Is psycopg2 installed?')
+
+    def __eq__(self, other):
+        return isinstance(other, PostGISAdapter) and self.ewkb == other.ewkb
+
+    def __hash__(self):
+        return hash(self.ewkb)
+
+    def __str__(self):
+        return self.getquoted()
+
+    def prepare(self, conn):
+        """
+        This method allows escaping the binary in the style required by the
+        server's `standard_conforming_string` setting.
+        """
+        if self.is_geometry:
+            self._adapter.prepare(conn)
+
+    def getquoted(self):
+        """
+        Return a properly quoted string for use in PostgreSQL/PostGIS.
+        """
+        if self.is_geometry:
+            # Psycopg will figure out whether to use E'\\000' or '\000'.
+            return '%s(%s)' % (
+                'ST_GeogFromWKB' if self.geography else 'ST_GeomFromEWKB',
+                self._adapter.getquoted().decode()
+            )
+        else:
+            # For rasters, add explicit type cast to WKB string.
+            return "'%s'::raster" % self.ewkb

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/base.py

@@ -0,0 +1,26 @@
+from django.db.backends.base.base import NO_DB_ALIAS
+from django.db.backends.postgresql.base import (
+    DatabaseWrapper as Psycopg2DatabaseWrapper,
+)
+
+from .features import DatabaseFeatures
+from .introspection import PostGISIntrospection
+from .operations import PostGISOperations
+from .schema import PostGISSchemaEditor
+
+
+class DatabaseWrapper(Psycopg2DatabaseWrapper):
+    SchemaEditorClass = PostGISSchemaEditor
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if kwargs.get('alias', '') != NO_DB_ALIAS:
+            self.features = DatabaseFeatures(self)
+            self.ops = PostGISOperations(self)
+            self.introspection = PostGISIntrospection(self)
+
+    def prepare_database(self):
+        super().prepare_database()
+        # Check that postgis extension is installed.
+        with self.cursor() as cursor:
+            cursor.execute("CREATE EXTENSION IF NOT EXISTS postgis")

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/features.py

@@ -0,0 +1,12 @@
+from django.contrib.gis.db.backends.base.features import BaseSpatialFeatures
+from django.db.backends.postgresql.features import (
+    DatabaseFeatures as Psycopg2DatabaseFeatures,
+)
+
+
+class DatabaseFeatures(BaseSpatialFeatures, Psycopg2DatabaseFeatures):
+    supports_3d_storage = True
+    supports_3d_functions = True
+    supports_left_right_lookups = True
+    supports_raster = True
+    supports_empty_geometries = True

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/introspection.py

@@ -0,0 +1,100 @@
+from django.contrib.gis.gdal import OGRGeomType
+from django.db.backends.postgresql.introspection import DatabaseIntrospection
+
+
+class GeoIntrospectionError(Exception):
+    pass
+
+
+class PostGISIntrospection(DatabaseIntrospection):
+    # Reverse dictionary for PostGIS geometry types not populated until
+    # introspection is actually performed.
+    postgis_types_reverse = {}
+
+    ignored_tables = DatabaseIntrospection.ignored_tables + [
+        'geography_columns',
+        'geometry_columns',
+        'raster_columns',
+        'spatial_ref_sys',
+        'raster_overviews',
+    ]
+
+    def get_postgis_types(self):
+        """
+        Return a dictionary with keys that are the PostgreSQL object
+        identification integers for the PostGIS geometry and/or
+        geography types (if supported).
+        """
+        field_types = [
+            ('geometry', 'GeometryField'),
+            # The value for the geography type is actually a tuple
+            # to pass in the `geography=True` keyword to the field
+            # definition.
+            ('geography', ('GeometryField', {'geography': True})),
+        ]
+        postgis_types = {}
+
+        # The OID integers associated with the geometry type may
+        # be different across versions; hence, this is why we have
+        # to query the PostgreSQL pg_type table corresponding to the
+        # PostGIS custom data types.
+        oid_sql = 'SELECT "oid" FROM "pg_type" WHERE "typname" = %s'
+        with self.connection.cursor() as cursor:
+            for field_type in field_types:
+                cursor.execute(oid_sql, (field_type[0],))
+                for result in cursor.fetchall():
+                    postgis_types[result[0]] = field_type[1]
+        return postgis_types
+
+    def get_field_type(self, data_type, description):
+        if not self.postgis_types_reverse:
+            # If the PostGIS types reverse dictionary is not populated, do so
+            # now.  In order to prevent unnecessary requests upon connection
+            # initialization, the `data_types_reverse` dictionary is not updated
+            # with the PostGIS custom types until introspection is actually
+            # performed -- in other words, when this function is called.
+            self.postgis_types_reverse = self.get_postgis_types()
+            self.data_types_reverse.update(self.postgis_types_reverse)
+        return super().get_field_type(data_type, description)
+
+    def get_geometry_type(self, table_name, geo_col):
+        """
+        The geometry type OID used by PostGIS does not indicate the particular
+        type of field that a geometry column is (e.g., whether it's a
+        PointField or a PolygonField).  Thus, this routine queries the PostGIS
+        metadata tables to determine the geometry type.
+        """
+        with self.connection.cursor() as cursor:
+            try:
+                # First seeing if this geometry column is in the `geometry_columns`
+                cursor.execute('SELECT "coord_dimension", "srid", "type" '
+                               'FROM "geometry_columns" '
+                               'WHERE "f_table_name"=%s AND "f_geometry_column"=%s',
+                               (table_name, geo_col))
+                row = cursor.fetchone()
+                if not row:
+                    raise GeoIntrospectionError
+            except GeoIntrospectionError:
+                cursor.execute('SELECT "coord_dimension", "srid", "type" '
+                               'FROM "geography_columns" '
+                               'WHERE "f_table_name"=%s AND "f_geography_column"=%s',
+                               (table_name, geo_col))
+                row = cursor.fetchone()
+
+            if not row:
+                raise Exception('Could not find a geometry or geography column for "%s"."%s"' %
+                                (table_name, geo_col))
+
+            # OGRGeomType does not require GDAL and makes it easy to convert
+            # from OGC geom type name to Django field.
+            field_type = OGRGeomType(row[2]).django
+
+            # Getting any GeometryField keyword arguments that are not the default.
+            dim = row[0]
+            srid = row[1]
+            field_params = {}
+            if srid != 4326:
+                field_params['srid'] = srid
+            if dim != 2:
+                field_params['dim'] = dim
+        return field_type, field_params

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/operations.py

@@ -0,0 +1,396 @@
+import re
+
+from django.conf import settings
+from django.contrib.gis.db.backends.base.operations import (
+    BaseSpatialOperations,
+)
+from django.contrib.gis.db.backends.utils import SpatialOperator
+from django.contrib.gis.db.models import GeometryField, RasterField
+from django.contrib.gis.gdal import GDALRaster
+from django.contrib.gis.geos.geometry import GEOSGeometryBase
+from django.contrib.gis.geos.prototypes.io import wkb_r
+from django.contrib.gis.measure import Distance
+from django.core.exceptions import ImproperlyConfigured
+from django.db.backends.postgresql.operations import DatabaseOperations
+from django.db.models import Func, Value
+from django.db.utils import NotSupportedError, ProgrammingError
+from django.utils.functional import cached_property
+from django.utils.version import get_version_tuple
+
+from .adapter import PostGISAdapter
+from .models import PostGISGeometryColumns, PostGISSpatialRefSys
+from .pgraster import from_pgraster
+
+# Identifier to mark raster lookups as bilateral.
+BILATERAL = 'bilateral'
+
+
+class PostGISOperator(SpatialOperator):
+    def __init__(self, geography=False, raster=False, **kwargs):
+        # Only a subset of the operators and functions are available for the
+        # geography type.
+        self.geography = geography
+        # Only a subset of the operators and functions are available for the
+        # raster type. Lookups that don't support raster will be converted to
+        # polygons. If the raster argument is set to BILATERAL, then the
+        # operator cannot handle mixed geom-raster lookups.
+        self.raster = raster
+        super().__init__(**kwargs)
+
+    def as_sql(self, connection, lookup, template_params, *args):
+        if lookup.lhs.output_field.geography and not self.geography:
+            raise ValueError('PostGIS geography does not support the "%s" '
+                             'function/operator.' % (self.func or self.op,))
+
+        template_params = self.check_raster(lookup, template_params)
+        return super().as_sql(connection, lookup, template_params, *args)
+
+    def check_raster(self, lookup, template_params):
+        spheroid = lookup.rhs_params and lookup.rhs_params[-1] == 'spheroid'
+
+        # Check which input is a raster.
+        lhs_is_raster = lookup.lhs.field.geom_type == 'RASTER'
+        rhs_is_raster = isinstance(lookup.rhs, GDALRaster)
+
+        # Look for band indices and inject them if provided.
+        if lookup.band_lhs is not None and lhs_is_raster:
+            if not self.func:
+                raise ValueError('Band indices are not allowed for this operator, it works on bbox only.')
+            template_params['lhs'] = '%s, %s' % (template_params['lhs'], lookup.band_lhs)
+
+        if lookup.band_rhs is not None and rhs_is_raster:
+            if not self.func:
+                raise ValueError('Band indices are not allowed for this operator, it works on bbox only.')
+            template_params['rhs'] = '%s, %s' % (template_params['rhs'], lookup.band_rhs)
+
+        # Convert rasters to polygons if necessary.
+        if not self.raster or spheroid:
+            # Operators without raster support.
+            if lhs_is_raster:
+                template_params['lhs'] = 'ST_Polygon(%s)' % template_params['lhs']
+            if rhs_is_raster:
+                template_params['rhs'] = 'ST_Polygon(%s)' % template_params['rhs']
+        elif self.raster == BILATERAL:
+            # Operators with raster support but don't support mixed (rast-geom)
+            # lookups.
+            if lhs_is_raster and not rhs_is_raster:
+                template_params['lhs'] = 'ST_Polygon(%s)' % template_params['lhs']
+            elif rhs_is_raster and not lhs_is_raster:
+                template_params['rhs'] = 'ST_Polygon(%s)' % template_params['rhs']
+
+        return template_params
+
+
+class ST_Polygon(Func):
+    function = 'ST_Polygon'
+
+    def __init__(self, expr):
+        super().__init__(expr)
+        expr = self.source_expressions[0]
+        if isinstance(expr, Value) and not expr._output_field_or_none:
+            self.source_expressions[0] = Value(expr.value, output_field=RasterField(srid=expr.value.srid))
+
+    @cached_property
+    def output_field(self):
+        return GeometryField(srid=self.source_expressions[0].field.srid)
+
+
+class PostGISOperations(BaseSpatialOperations, DatabaseOperations):
+    name = 'postgis'
+    postgis = True
+    geography = True
+    geom_func_prefix = 'ST_'
+
+    Adapter = PostGISAdapter
+
+    collect = geom_func_prefix + 'Collect'
+    extent = geom_func_prefix + 'Extent'
+    extent3d = geom_func_prefix + '3DExtent'
+    length3d = geom_func_prefix + '3DLength'
+    makeline = geom_func_prefix + 'MakeLine'
+    perimeter3d = geom_func_prefix + '3DPerimeter'
+    unionagg = geom_func_prefix + 'Union'
+
+    gis_operators = {
+        'bbcontains': PostGISOperator(op='~', raster=True),
+        'bboverlaps': PostGISOperator(op='&&', geography=True, raster=True),
+        'contained': PostGISOperator(op='@', raster=True),
+        'overlaps_left': PostGISOperator(op='&<', raster=BILATERAL),
+        'overlaps_right': PostGISOperator(op='&>', raster=BILATERAL),
+        'overlaps_below': PostGISOperator(op='&<|'),
+        'overlaps_above': PostGISOperator(op='|&>'),
+        'left': PostGISOperator(op='<<'),
+        'right': PostGISOperator(op='>>'),
+        'strictly_below': PostGISOperator(op='<<|'),
+        'strictly_above': PostGISOperator(op='|>>'),
+        'same_as': PostGISOperator(op='~=', raster=BILATERAL),
+        'exact': PostGISOperator(op='~=', raster=BILATERAL),  # alias of same_as
+        'contains': PostGISOperator(func='ST_Contains', raster=BILATERAL),
+        'contains_properly': PostGISOperator(func='ST_ContainsProperly', raster=BILATERAL),
+        'coveredby': PostGISOperator(func='ST_CoveredBy', geography=True, raster=BILATERAL),
+        'covers': PostGISOperator(func='ST_Covers', geography=True, raster=BILATERAL),
+        'crosses': PostGISOperator(func='ST_Crosses'),
+        'disjoint': PostGISOperator(func='ST_Disjoint', raster=BILATERAL),
+        'equals': PostGISOperator(func='ST_Equals'),
+        'intersects': PostGISOperator(func='ST_Intersects', geography=True, raster=BILATERAL),
+        'overlaps': PostGISOperator(func='ST_Overlaps', raster=BILATERAL),
+        'relate': PostGISOperator(func='ST_Relate'),
+        'touches': PostGISOperator(func='ST_Touches', raster=BILATERAL),
+        'within': PostGISOperator(func='ST_Within', raster=BILATERAL),
+        'dwithin': PostGISOperator(func='ST_DWithin', geography=True, raster=BILATERAL),
+    }
+
+    unsupported_functions = set()
+
+    select = '%s::bytea'
+    select_extent = None
+
+    @cached_property
+    def function_names(self):
+        function_names = {
+            'BoundingCircle': 'ST_MinimumBoundingCircle',
+            'NumPoints': 'ST_NPoints',
+        }
+        if self.spatial_version < (2, 2, 0):
+            function_names.update({
+                'DistanceSphere': 'ST_distance_sphere',
+                'DistanceSpheroid': 'ST_distance_spheroid',
+                'LengthSpheroid': 'ST_length_spheroid',
+                'MemSize': 'ST_mem_size',
+            })
+        if self.spatial_version < (2, 4, 0):
+            function_names['ForcePolygonCW'] = 'ST_ForceRHR'
+        return function_names
+
+    @cached_property
+    def spatial_version(self):
+        """Determine the version of the PostGIS library."""
+        # Trying to get the PostGIS version because the function
+        # signatures will depend on the version used.  The cost
+        # here is a database query to determine the version, which
+        # can be mitigated by setting `POSTGIS_VERSION` with a 3-tuple
+        # comprising user-supplied values for the major, minor, and
+        # subminor revision of PostGIS.
+        if hasattr(settings, 'POSTGIS_VERSION'):
+            version = settings.POSTGIS_VERSION
+        else:
+            # Run a basic query to check the status of the connection so we're
+            # sure we only raise the error below if the problem comes from
+            # PostGIS and not from PostgreSQL itself (see #24862).
+            self._get_postgis_func('version')
+
+            try:
+                vtup = self.postgis_version_tuple()
+            except ProgrammingError:
+                raise ImproperlyConfigured(
+                    'Cannot determine PostGIS version for database "%s" '
+                    'using command "SELECT postgis_lib_version()". '
+                    'GeoDjango requires at least PostGIS version 2.1. '
+                    'Was the database created from a spatial database '
+                    'template?' % self.connection.settings_dict['NAME']
+                )
+            version = vtup[1:]
+        return version
+
+    def convert_extent(self, box):
+        """
+        Return a 4-tuple extent for the `Extent` aggregate by converting
+        the bounding box text returned by PostGIS (`box` argument), for
+        example: "BOX(-90.0 30.0, -85.0 40.0)".
+        """
+        if box is None:
+            return None
+        ll, ur = box[4:-1].split(',')
+        xmin, ymin = map(float, ll.split())
+        xmax, ymax = map(float, ur.split())
+        return (xmin, ymin, xmax, ymax)
+
+    def convert_extent3d(self, box3d):
+        """
+        Return a 6-tuple extent for the `Extent3D` aggregate by converting
+        the 3d bounding-box text returned by PostGIS (`box3d` argument), for
+        example: "BOX3D(-90.0 30.0 1, -85.0 40.0 2)".
+        """
+        if box3d is None:
+            return None
+        ll, ur = box3d[6:-1].split(',')
+        xmin, ymin, zmin = map(float, ll.split())
+        xmax, ymax, zmax = map(float, ur.split())
+        return (xmin, ymin, zmin, xmax, ymax, zmax)
+
+    def geo_db_type(self, f):
+        """
+        Return the database field type for the given spatial field.
+        """
+        if f.geom_type == 'RASTER':
+            return 'raster'
+
+        # Type-based geometries.
+        # TODO: Support 'M' extension.
+        if f.dim == 3:
+            geom_type = f.geom_type + 'Z'
+        else:
+            geom_type = f.geom_type
+        if f.geography:
+            if f.srid != 4326:
+                raise NotSupportedError('PostGIS only supports geography columns with an SRID of 4326.')
+
+            return 'geography(%s,%d)' % (geom_type, f.srid)
+        else:
+            return 'geometry(%s,%d)' % (geom_type, f.srid)
+
+    def get_distance(self, f, dist_val, lookup_type):
+        """
+        Retrieve the distance parameters for the given geometry field,
+        distance lookup value, and the distance lookup type.
+
+        This is the most complex implementation of the spatial backends due to
+        what is supported on geodetic geometry columns vs. what's available on
+        projected geometry columns.  In addition, it has to take into account
+        the geography column type.
+        """
+        # Getting the distance parameter
+        value = dist_val[0]
+
+        # Shorthand boolean flags.
+        geodetic = f.geodetic(self.connection)
+        geography = f.geography
+
+        if isinstance(value, Distance):
+            if geography:
+                dist_param = value.m
+            elif geodetic:
+                if lookup_type == 'dwithin':
+                    raise ValueError('Only numeric values of degree units are '
+                                     'allowed on geographic DWithin queries.')
+                dist_param = value.m
+            else:
+                dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection)))
+        else:
+            # Assuming the distance is in the units of the field.
+            dist_param = value
+
+        return [dist_param]
+
+    def get_geom_placeholder(self, f, value, compiler):
+        """
+        Provide a proper substitution value for Geometries or rasters that are
+        not in the SRID of the field. Specifically, this routine will
+        substitute in the ST_Transform() function call.
+        """
+        transform_func = self.spatial_function_name('Transform')
+        if hasattr(value, 'as_sql'):
+            if value.field.srid == f.srid:
+                placeholder = '%s'
+            else:
+                placeholder = '%s(%%s, %s)' % (transform_func, f.srid)
+            return placeholder
+
+        # Get the srid for this object
+        if value is None:
+            value_srid = None
+        else:
+            value_srid = value.srid
+
+        # Adding Transform() to the SQL placeholder if the value srid
+        # is not equal to the field srid.
+        if value_srid is None or value_srid == f.srid:
+            placeholder = '%s'
+        else:
+            placeholder = '%s(%%s, %s)' % (transform_func, f.srid)
+
+        return placeholder
+
+    def _get_postgis_func(self, func):
+        """
+        Helper routine for calling PostGIS functions and returning their result.
+        """
+        # Close out the connection.  See #9437.
+        with self.connection.temporary_connection() as cursor:
+            cursor.execute('SELECT %s()' % func)
+            return cursor.fetchone()[0]
+
+    def postgis_geos_version(self):
+        "Return the version of the GEOS library used with PostGIS."
+        return self._get_postgis_func('postgis_geos_version')
+
+    def postgis_lib_version(self):
+        "Return the version number of the PostGIS library used with PostgreSQL."
+        return self._get_postgis_func('postgis_lib_version')
+
+    def postgis_proj_version(self):
+        "Return the version of the PROJ.4 library used with PostGIS."
+        return self._get_postgis_func('postgis_proj_version')
+
+    def postgis_version(self):
+        "Return PostGIS version number and compile-time options."
+        return self._get_postgis_func('postgis_version')
+
+    def postgis_full_version(self):
+        "Return PostGIS version number and compile-time options."
+        return self._get_postgis_func('postgis_full_version')
+
+    def postgis_version_tuple(self):
+        """
+        Return the PostGIS version as a tuple (version string, major,
+        minor, subminor).
+        """
+        version = self.postgis_lib_version()
+        return (version,) + get_version_tuple(version)
+
+    def proj_version_tuple(self):
+        """
+        Return the version of PROJ.4 used by PostGIS as a tuple of the
+        major, minor, and subminor release numbers.
+        """
+        proj_regex = re.compile(r'(\d+)\.(\d+)\.(\d+)')
+        proj_ver_str = self.postgis_proj_version()
+        m = proj_regex.search(proj_ver_str)
+        if m:
+            return tuple(map(int, [m.group(1), m.group(2), m.group(3)]))
+        else:
+            raise Exception('Could not determine PROJ.4 version from PostGIS.')
+
+    def spatial_aggregate_name(self, agg_name):
+        if agg_name == 'Extent3D':
+            return self.extent3d
+        else:
+            return self.geom_func_prefix + agg_name
+
+    # Routines for getting the OGC-compliant models.
+    def geometry_columns(self):
+        return PostGISGeometryColumns
+
+    def spatial_ref_sys(self):
+        return PostGISSpatialRefSys
+
+    def parse_raster(self, value):
+        """Convert a PostGIS HEX String into a dict readable by GDALRaster."""
+        return from_pgraster(value)
+
+    def distance_expr_for_lookup(self, lhs, rhs, **kwargs):
+        return super().distance_expr_for_lookup(
+            self._normalize_distance_lookup_arg(lhs),
+            self._normalize_distance_lookup_arg(rhs),
+            **kwargs
+        )
+
+    @staticmethod
+    def _normalize_distance_lookup_arg(arg):
+        is_raster = (
+            arg.field.geom_type == 'RASTER'
+            if hasattr(arg, 'field') else
+            isinstance(arg, GDALRaster)
+        )
+        return ST_Polygon(arg) if is_raster else arg
+
+    def get_geometry_converter(self, expression):
+        read = wkb_r().read
+        geom_class = expression.output_field.geom_class
+
+        def converter(value, expression, connection):
+            return None if value is None else GEOSGeometryBase(read(value), geom_class)
+        return converter
+
+    def get_area_att_for_field(self, field):
+        return 'sq_m'

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/postgis/pgraster.py

@@ -0,0 +1,141 @@
+import struct
+
+from django.forms import ValidationError
+
+from .const import (
+    GDAL_TO_POSTGIS, GDAL_TO_STRUCT, POSTGIS_HEADER_STRUCTURE, POSTGIS_TO_GDAL,
+    STRUCT_SIZE,
+)
+
+
+def pack(structure, data):
+    """
+    Pack data into hex string with little endian format.
+    """
+    return struct.pack('<' + structure, *data)
+
+
+def unpack(structure, data):
+    """
+    Unpack little endian hexlified binary string into a list.
+    """
+    return struct.unpack('<' + structure, bytes.fromhex(data))
+
+
+def chunk(data, index):
+    """
+    Split a string into two parts at the input index.
+    """
+    return data[:index], data[index:]
+
+
+def from_pgraster(data):
+    """
+    Convert a PostGIS HEX String into a dictionary.
+    """
+    if data is None:
+        return
+
+    # Split raster header from data
+    header, data = chunk(data, 122)
+    header = unpack(POSTGIS_HEADER_STRUCTURE, header)
+
+    # Parse band data
+    bands = []
+    pixeltypes = []
+    while data:
+        # Get pixel type for this band
+        pixeltype, data = chunk(data, 2)
+        pixeltype = unpack('B', pixeltype)[0]
+
+        # Subtract nodata byte from band nodata value if it exists
+        has_nodata = pixeltype >= 64
+        if has_nodata:
+            pixeltype -= 64
+
+        # Convert datatype from PostGIS to GDAL & get pack type and size
+        pixeltype = POSTGIS_TO_GDAL[pixeltype]
+        pack_type = GDAL_TO_STRUCT[pixeltype]
+        pack_size = 2 * STRUCT_SIZE[pack_type]
+
+        # Parse band nodata value. The nodata value is part of the
+        # PGRaster string even if the nodata flag is True, so it always
+        # has to be chunked off the data string.
+        nodata, data = chunk(data, pack_size)
+        nodata = unpack(pack_type, nodata)[0]
+
+        # Chunk and unpack band data (pack size times nr of pixels)
+        band, data = chunk(data, pack_size * header[10] * header[11])
+        band_result = {'data': bytes.fromhex(band)}
+
+        # If the nodata flag is True, set the nodata value.
+        if has_nodata:
+            band_result['nodata_value'] = nodata
+
+        # Append band data to band list
+        bands.append(band_result)
+
+        # Store pixeltype of this band in pixeltypes array
+        pixeltypes.append(pixeltype)
+
+    # Check that all bands have the same pixeltype.
+    # This is required by GDAL. PostGIS rasters could have different pixeltypes
+    # for bands of the same raster.
+    if len(set(pixeltypes)) != 1:
+        raise ValidationError("Band pixeltypes are not all equal.")
+
+    return {
+        'srid': int(header[9]),
+        'width': header[10], 'height': header[11],
+        'datatype': pixeltypes[0],
+        'origin': (header[5], header[6]),
+        'scale': (header[3], header[4]),
+        'skew': (header[7], header[8]),
+        'bands': bands,
+    }
+
+
+def to_pgraster(rast):
+    """
+    Convert a GDALRaster into PostGIS Raster format.
+    """
+    # Prepare the raster header data as a tuple. The first two numbers are
+    # the endianness and the PostGIS Raster Version, both are fixed by
+    # PostGIS at the moment.
+    rasterheader = (
+        1, 0, len(rast.bands), rast.scale.x, rast.scale.y,
+        rast.origin.x, rast.origin.y, rast.skew.x, rast.skew.y,
+        rast.srs.srid, rast.width, rast.height,
+    )
+
+    # Pack raster header.
+    result = pack(POSTGIS_HEADER_STRUCTURE, rasterheader)
+
+    for band in rast.bands:
+        # The PostGIS raster band header has exactly two elements, a 8BUI byte
+        # and the nodata value.
+        #
+        # The 8BUI stores both the PostGIS pixel data type and a nodata flag.
+        # It is composed as the datatype integer plus 64 as a flag for existing
+        # nodata values:
+        # 8BUI_VALUE = PG_PIXEL_TYPE (0-11) + FLAG (0 or 64)
+        #
+        # For example, if the byte value is 71, then the datatype is
+        # 71-64 = 7 (32BSI) and the nodata value is True.
+        structure = 'B' + GDAL_TO_STRUCT[band.datatype()]
+
+        # Get band pixel type in PostGIS notation
+        pixeltype = GDAL_TO_POSTGIS[band.datatype()]
+
+        # Set the nodata flag
+        if band.nodata_value is not None:
+            pixeltype += 64
+
+        # Pack band header
+        bandheader = pack(structure, (pixeltype, band.nodata_value or 0))
+
+        # Add packed header and band data to result
+        result += bandheader + band.data(as_memoryview=True)
+
+    # Convert raster to hex string before passing it to the DB.
+    return result.hex()

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/spatialite/client.py

@@ -0,0 +1,5 @@
+from django.db.backends.sqlite3.client import DatabaseClient
+
+
+class SpatiaLiteClient(DatabaseClient):
+    executable_name = 'spatialite'

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/spatialite/introspection.py

@@ -0,0 +1,73 @@
+from django.contrib.gis.gdal import OGRGeomType
+from django.db.backends.sqlite3.introspection import (
+    DatabaseIntrospection, FlexibleFieldLookupDict,
+)
+
+
+class GeoFlexibleFieldLookupDict(FlexibleFieldLookupDict):
+    """
+    Sublcass that includes updates the `base_data_types_reverse` dict
+    for geometry field types.
+    """
+    base_data_types_reverse = {
+        **FlexibleFieldLookupDict.base_data_types_reverse,
+        'point': 'GeometryField',
+        'linestring': 'GeometryField',
+        'polygon': 'GeometryField',
+        'multipoint': 'GeometryField',
+        'multilinestring': 'GeometryField',
+        'multipolygon': 'GeometryField',
+        'geometrycollection': 'GeometryField',
+    }
+
+
+class SpatiaLiteIntrospection(DatabaseIntrospection):
+    data_types_reverse = GeoFlexibleFieldLookupDict()
+
+    def get_geometry_type(self, table_name, geo_col):
+        with self.connection.cursor() as cursor:
+            # Querying the `geometry_columns` table to get additional metadata.
+            cursor.execute('SELECT coord_dimension, srid, geometry_type '
+                           'FROM geometry_columns '
+                           'WHERE f_table_name=%s AND f_geometry_column=%s',
+                           (table_name, geo_col))
+            row = cursor.fetchone()
+            if not row:
+                raise Exception('Could not find a geometry column for "%s"."%s"' %
+                                (table_name, geo_col))
+
+            # OGRGeomType does not require GDAL and makes it easy to convert
+            # from OGC geom type name to Django field.
+            ogr_type = row[2]
+            if isinstance(ogr_type, int) and ogr_type > 1000:
+                # SpatiaLite uses SFSQL 1.2 offsets 1000 (Z), 2000 (M), and
+                # 3000 (ZM) to indicate the presence of higher dimensional
+                # coordinates (M not yet supported by Django).
+                ogr_type = ogr_type % 1000 + OGRGeomType.wkb25bit
+            field_type = OGRGeomType(ogr_type).django
+
+            # Getting any GeometryField keyword arguments that are not the default.
+            dim = row[0]
+            srid = row[1]
+            field_params = {}
+            if srid != 4326:
+                field_params['srid'] = srid
+            if (isinstance(dim, str) and 'Z' in dim) or dim == 3:
+                field_params['dim'] = 3
+        return field_type, field_params
+
+    def get_constraints(self, cursor, table_name):
+        constraints = super().get_constraints(cursor, table_name)
+        cursor.execute('SELECT f_geometry_column '
+                       'FROM geometry_columns '
+                       'WHERE f_table_name=%s AND spatial_index_enabled=1', (table_name,))
+        for row in cursor.fetchall():
+            constraints['%s__spatial__index' % row[0]] = {
+                "columns": [row[0]],
+                "primary_key": False,
+                "unique": False,
+                "foreign_key": None,
+                "check": False,
+                "index": True,
+            }
+        return constraints

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/spatialite/operations.py

@@ -0,0 +1,219 @@
+"""
+SQL functions reference lists:
+https://www.gaia-gis.it/gaia-sins/spatialite-sql-4.2.1.html
+"""
+from django.contrib.gis.db.backends.base.operations import (
+    BaseSpatialOperations,
+)
+from django.contrib.gis.db.backends.spatialite.adapter import SpatiaLiteAdapter
+from django.contrib.gis.db.backends.utils import SpatialOperator
+from django.contrib.gis.db.models import aggregates
+from django.contrib.gis.geos.geometry import GEOSGeometry, GEOSGeometryBase
+from django.contrib.gis.geos.prototypes.io import wkb_r, wkt_r
+from django.contrib.gis.measure import Distance
+from django.core.exceptions import ImproperlyConfigured
+from django.db.backends.sqlite3.operations import DatabaseOperations
+from django.utils.functional import cached_property
+from django.utils.version import get_version_tuple
+
+
+class SpatialiteNullCheckOperator(SpatialOperator):
+    def as_sql(self, connection, lookup, template_params, sql_params):
+        sql, params = super().as_sql(connection, lookup, template_params, sql_params)
+        return '%s > 0' % sql, params
+
+
+class SpatiaLiteOperations(BaseSpatialOperations, DatabaseOperations):
+    name = 'spatialite'
+    spatialite = True
+
+    Adapter = SpatiaLiteAdapter
+
+    collect = 'Collect'
+    extent = 'Extent'
+    makeline = 'MakeLine'
+    unionagg = 'GUnion'
+
+    from_text = 'GeomFromText'
+
+    gis_operators = {
+        # Binary predicates
+        'equals': SpatialiteNullCheckOperator(func='Equals'),
+        'disjoint': SpatialiteNullCheckOperator(func='Disjoint'),
+        'touches': SpatialiteNullCheckOperator(func='Touches'),
+        'crosses': SpatialiteNullCheckOperator(func='Crosses'),
+        'within': SpatialiteNullCheckOperator(func='Within'),
+        'overlaps': SpatialiteNullCheckOperator(func='Overlaps'),
+        'contains': SpatialiteNullCheckOperator(func='Contains'),
+        'intersects': SpatialiteNullCheckOperator(func='Intersects'),
+        'relate': SpatialiteNullCheckOperator(func='Relate'),
+        'coveredby': SpatialiteNullCheckOperator(func='CoveredBy'),
+        'covers': SpatialiteNullCheckOperator(func='Covers'),
+        # Returns true if B's bounding box completely contains A's bounding box.
+        'contained': SpatialOperator(func='MbrWithin'),
+        # Returns true if A's bounding box completely contains B's bounding box.
+        'bbcontains': SpatialOperator(func='MbrContains'),
+        # Returns true if A's bounding box overlaps B's bounding box.
+        'bboverlaps': SpatialOperator(func='MbrOverlaps'),
+        # These are implemented here as synonyms for Equals
+        'same_as': SpatialiteNullCheckOperator(func='Equals'),
+        'exact': SpatialiteNullCheckOperator(func='Equals'),
+        # Distance predicates
+        'dwithin': SpatialOperator(func='PtDistWithin'),
+    }
+
+    disallowed_aggregates = (aggregates.Extent3D,)
+
+    @cached_property
+    def select(self):
+        return 'CAST (AsEWKB(%s) AS BLOB)' if self.spatial_version >= (4, 3, 0) else 'AsText(%s)'
+
+    function_names = {
+        'ForcePolygonCW': 'ST_ForceLHR',
+        'Length': 'ST_Length',
+        'LineLocatePoint': 'ST_Line_Locate_Point',
+        'NumPoints': 'ST_NPoints',
+        'Reverse': 'ST_Reverse',
+        'Scale': 'ScaleCoords',
+        'Translate': 'ST_Translate',
+        'Union': 'ST_Union',
+    }
+
+    @cached_property
+    def unsupported_functions(self):
+        unsupported = {'BoundingCircle', 'ForceRHR', 'MemSize'}
+        if not self.lwgeom_version():
+            unsupported |= {'Azimuth', 'GeoHash', 'IsValid', 'MakeValid'}
+        return unsupported
+
+    @cached_property
+    def spatial_version(self):
+        """Determine the version of the SpatiaLite library."""
+        try:
+            version = self.spatialite_version_tuple()[1:]
+        except Exception as exc:
+            raise ImproperlyConfigured(
+                'Cannot determine the SpatiaLite version for the "%s" database. '
+                'Was the SpatiaLite initialization SQL loaded on this database?' % (
+                    self.connection.settings_dict['NAME'],
+                )
+            ) from exc
+        if version < (4, 1, 0):
+            raise ImproperlyConfigured('GeoDjango only supports SpatiaLite versions 4.1.0 and above.')
+        return version
+
+    def convert_extent(self, box):
+        """
+        Convert the polygon data received from SpatiaLite to min/max values.
+        """
+        if box is None:
+            return None
+        shell = GEOSGeometry(box).shell
+        xmin, ymin = shell[0][:2]
+        xmax, ymax = shell[2][:2]
+        return (xmin, ymin, xmax, ymax)
+
+    def geo_db_type(self, f):
+        """
+        Return None because geometry columns are added via the
+        `AddGeometryColumn` stored procedure on SpatiaLite.
+        """
+        return None
+
+    def get_distance(self, f, value, lookup_type):
+        """
+        Return the distance parameters for the given geometry field,
+        lookup value, and lookup type.
+        """
+        if not value:
+            return []
+        value = value[0]
+        if isinstance(value, Distance):
+            if f.geodetic(self.connection):
+                if lookup_type == 'dwithin':
+                    raise ValueError(
+                        'Only numeric values of degree units are allowed on '
+                        'geographic DWithin queries.'
+                    )
+                dist_param = value.m
+            else:
+                dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection)))
+        else:
+            dist_param = value
+        return [dist_param]
+
+    def _get_spatialite_func(self, func):
+        """
+        Helper routine for calling SpatiaLite functions and returning
+        their result.
+        Any error occurring in this method should be handled by the caller.
+        """
+        cursor = self.connection._cursor()
+        try:
+            cursor.execute('SELECT %s' % func)
+            row = cursor.fetchone()
+        finally:
+            cursor.close()
+        return row[0]
+
+    def geos_version(self):
+        "Return the version of GEOS used by SpatiaLite as a string."
+        return self._get_spatialite_func('geos_version()')
+
+    def proj4_version(self):
+        "Return the version of the PROJ.4 library used by SpatiaLite."
+        return self._get_spatialite_func('proj4_version()')
+
+    def lwgeom_version(self):
+        """Return the version of LWGEOM library used by SpatiaLite."""
+        return self._get_spatialite_func('lwgeom_version()')
+
+    def spatialite_version(self):
+        "Return the SpatiaLite library version as a string."
+        return self._get_spatialite_func('spatialite_version()')
+
+    def spatialite_version_tuple(self):
+        """
+        Return the SpatiaLite version as a tuple (version string, major,
+        minor, subminor).
+        """
+        version = self.spatialite_version()
+        return (version,) + get_version_tuple(version)
+
+    def spatial_aggregate_name(self, agg_name):
+        """
+        Return the spatial aggregate SQL template and function for the
+        given Aggregate instance.
+        """
+        agg_name = 'unionagg' if agg_name.lower() == 'union' else agg_name.lower()
+        return getattr(self, agg_name)
+
+    # Routines for getting the OGC-compliant models.
+    def geometry_columns(self):
+        from django.contrib.gis.db.backends.spatialite.models import SpatialiteGeometryColumns
+        return SpatialiteGeometryColumns
+
+    def spatial_ref_sys(self):
+        from django.contrib.gis.db.backends.spatialite.models import SpatialiteSpatialRefSys
+        return SpatialiteSpatialRefSys
+
+    def get_geometry_converter(self, expression):
+        geom_class = expression.output_field.geom_class
+        if self.spatial_version >= (4, 3, 0):
+            read = wkb_r().read
+
+            def converter(value, expression, connection):
+                return None if value is None else GEOSGeometryBase(read(value), geom_class)
+        else:
+            read = wkt_r().read
+            srid = expression.output_field.srid
+            if srid == -1:
+                srid = None
+
+            def converter(value, expression, connection):
+                if value is not None:
+                    geom = GEOSGeometryBase(read(value), geom_class)
+                    if srid:
+                        geom.srid = srid
+                    return geom
+        return converter

venv/lib/python3.7/site-packages/django/contrib/gis/db/backends/spatialite/schema.py

@@ -0,0 +1,165 @@
+from django.db.backends.sqlite3.schema import DatabaseSchemaEditor
+from django.db.utils import DatabaseError
+
+
+class SpatialiteSchemaEditor(DatabaseSchemaEditor):
+    sql_add_geometry_column = (
+        "SELECT AddGeometryColumn(%(table)s, %(column)s, %(srid)s, "
+        "%(geom_type)s, %(dim)s, %(null)s)"
+    )
+    sql_add_spatial_index = "SELECT CreateSpatialIndex(%(table)s, %(column)s)"
+    sql_drop_spatial_index = "DROP TABLE idx_%(table)s_%(column)s"
+    sql_recover_geometry_metadata = (
+        "SELECT RecoverGeometryColumn(%(table)s, %(column)s, %(srid)s, "
+        "%(geom_type)s, %(dim)s)"
+    )
+    sql_remove_geometry_metadata = "SELECT DiscardGeometryColumn(%(table)s, %(column)s)"
+    sql_discard_geometry_columns = "DELETE FROM %(geom_table)s WHERE f_table_name = %(table)s"
+    sql_update_geometry_columns = (
+        "UPDATE %(geom_table)s SET f_table_name = %(new_table)s "
+        "WHERE f_table_name = %(old_table)s"
+    )
+
+    geometry_tables = [
+        "geometry_columns",
+        "geometry_columns_auth",
+        "geometry_columns_time",
+        "geometry_columns_statistics",
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.geometry_sql = []
+
+    def geo_quote_name(self, name):
+        return self.connection.ops.geo_quote_name(name)
+
+    def column_sql(self, model, field, include_default=False):
+        from django.contrib.gis.db.models.fields import GeometryField
+        if not isinstance(field, GeometryField):
+            return super().column_sql(model, field, include_default)
+
+        # Geometry columns are created by the `AddGeometryColumn` function
+        self.geometry_sql.append(
+            self.sql_add_geometry_column % {
+                "table": self.geo_quote_name(model._meta.db_table),
+                "column": self.geo_quote_name(field.column),
+                "srid": field.srid,
+                "geom_type": self.geo_quote_name(field.geom_type),
+                "dim": field.dim,
+                "null": int(not field.null),
+            }
+        )
+
+        if field.spatial_index:
+            self.geometry_sql.append(
+                self.sql_add_spatial_index % {
+                    "table": self.quote_name(model._meta.db_table),
+                    "column": self.quote_name(field.column),
+                }
+            )
+        return None, None
+
+    def remove_geometry_metadata(self, model, field):
+        self.execute(
+            self.sql_remove_geometry_metadata % {
+                "table": self.quote_name(model._meta.db_table),
+                "column": self.quote_name(field.column),
+            }
+        )
+        self.execute(
+            self.sql_drop_spatial_index % {
+                "table": model._meta.db_table,
+                "column": field.column,
+            }
+        )
+
+    def create_model(self, model):
+        super().create_model(model)
+        # Create geometry columns
+        for sql in self.geometry_sql:
+            self.execute(sql)
+        self.geometry_sql = []
+
+    def delete_model(self, model, **kwargs):
+        from django.contrib.gis.db.models.fields import GeometryField
+        # Drop spatial metadata (dropping the table does not automatically remove them)
+        for field in model._meta.local_fields:
+            if isinstance(field, GeometryField):
+                self.remove_geometry_metadata(model, field)
+        # Make sure all geom stuff is gone
+        for geom_table in self.geometry_tables:
+            try:
+                self.execute(
+                    self.sql_discard_geometry_columns % {
+                        "geom_table": geom_table,
+                        "table": self.quote_name(model._meta.db_table),
+                    }
+                )
+            except DatabaseError:
+                pass
+        super().delete_model(model, **kwargs)
+
+    def add_field(self, model, field):
+        from django.contrib.gis.db.models.fields import GeometryField
+        if isinstance(field, GeometryField):
+            # Populate self.geometry_sql
+            self.column_sql(model, field)
+            for sql in self.geometry_sql:
+                self.execute(sql)
+            self.geometry_sql = []
+        else:
+            super().add_field(model, field)
+
+    def remove_field(self, model, field):
+        from django.contrib.gis.db.models.fields import GeometryField
+        # NOTE: If the field is a geometry field, the table is just recreated,
+        # the parent's remove_field can't be used cause it will skip the
+        # recreation if the field does not have a database type. Geometry fields
+        # do not have a db type cause they are added and removed via stored
+        # procedures.
+        if isinstance(field, GeometryField):
+            self._remake_table(model, delete_field=field)
+        else:
+            super().remove_field(model, field)
+
+    def alter_db_table(self, model, old_db_table, new_db_table, disable_constraints=True):
+        from django.contrib.gis.db.models.fields import GeometryField
+        # Remove geometry-ness from temp table
+        for field in model._meta.local_fields:
+            if isinstance(field, GeometryField):
+                self.execute(
+                    self.sql_remove_geometry_metadata % {
+                        "table": self.quote_name(old_db_table),
+                        "column": self.quote_name(field.column),
+                    }
+                )
+        # Alter table
+        super().alter_db_table(model, old_db_table, new_db_table, disable_constraints)
+        # Repoint any straggler names
+        for geom_table in self.geometry_tables:
+            try:
+                self.execute(
+                    self.sql_update_geometry_columns % {
+                        "geom_table": geom_table,
+                        "old_table": self.quote_name(old_db_table),
+                        "new_table": self.quote_name(new_db_table),
+                    }
+                )
+            except DatabaseError:
+                pass
+        # Re-add geometry-ness and rename spatial index tables
+        for field in model._meta.local_fields:
+            if isinstance(field, GeometryField):
+                self.execute(self.sql_recover_geometry_metadata % {
+                    "table": self.geo_quote_name(new_db_table),
+                    "column": self.geo_quote_name(field.column),
+                    "srid": field.srid,
+                    "geom_type": self.geo_quote_name(field.geom_type),
+                    "dim": field.dim,
+                })
+            if getattr(field, 'spatial_index', False):
+                self.execute(self.sql_rename_table % {
+                    "old_table": self.quote_name("idx_%s_%s" % (old_db_table, field.column)),
+                    "new_table": self.quote_name("idx_%s_%s" % (new_db_table, field.column)),
+                })

venv/lib/python3.7/site-packages/django/contrib/gis/db/models/__init__.py

@@ -0,0 +1,18 @@
+from django.db.models import *  # NOQA isort:skip
+from django.db.models import __all__ as models_all  # isort:skip
+import django.contrib.gis.db.models.functions  # NOQA
+import django.contrib.gis.db.models.lookups  # NOQA
+from django.contrib.gis.db.models.aggregates import *  # NOQA
+from django.contrib.gis.db.models.aggregates import __all__ as aggregates_all
+from django.contrib.gis.db.models.fields import (
+    GeometryCollectionField, GeometryField, LineStringField,
+    MultiLineStringField, MultiPointField, MultiPolygonField, PointField,
+    PolygonField, RasterField,
+)
+
+__all__ = models_all + aggregates_all
+__all__ += [
+    'GeometryCollectionField', 'GeometryField', 'LineStringField',
+    'MultiLineStringField', 'MultiPointField', 'MultiPolygonField', 'PointField',
+    'PolygonField', 'RasterField',
+]

venv/lib/python3.7/site-packages/django/contrib/gis/db/models/aggregates.py

@@ -0,0 +1,76 @@
+from django.contrib.gis.db.models.fields import (
+    ExtentField, GeometryCollectionField, GeometryField, LineStringField,
+)
+from django.db.models.aggregates import Aggregate
+from django.utils.functional import cached_property
+
+__all__ = ['Collect', 'Extent', 'Extent3D', 'MakeLine', 'Union']
+
+
+class GeoAggregate(Aggregate):
+    function = None
+    is_extent = False
+
+    @cached_property
+    def output_field(self):
+        return self.output_field_class(self.source_expressions[0].output_field.srid)
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        # this will be called again in parent, but it's needed now - before
+        # we get the spatial_aggregate_name
+        connection.ops.check_expression_support(self)
+        return super().as_sql(
+            compiler,
+            connection,
+            function=function or connection.ops.spatial_aggregate_name(self.name),
+            **extra_context
+        )
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        tolerance = self.extra.get('tolerance') or getattr(self, 'tolerance', 0.05)
+        template = None if self.is_extent else '%(function)s(SDOAGGRTYPE(%(expressions)s,%(tolerance)s))'
+        return self.as_sql(compiler, connection, template=template, tolerance=tolerance, **extra_context)
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        c = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
+        for expr in c.get_source_expressions():
+            if not hasattr(expr.field, 'geom_type'):
+                raise ValueError('Geospatial aggregates only allowed on geometry fields.')
+        return c
+
+
+class Collect(GeoAggregate):
+    name = 'Collect'
+    output_field_class = GeometryCollectionField
+
+
+class Extent(GeoAggregate):
+    name = 'Extent'
+    is_extent = '2D'
+
+    def __init__(self, expression, **extra):
+        super().__init__(expression, output_field=ExtentField(), **extra)
+
+    def convert_value(self, value, expression, connection):
+        return connection.ops.convert_extent(value)
+
+
+class Extent3D(GeoAggregate):
+    name = 'Extent3D'
+    is_extent = '3D'
+
+    def __init__(self, expression, **extra):
+        super().__init__(expression, output_field=ExtentField(), **extra)
+
+    def convert_value(self, value, expression, connection):
+        return connection.ops.convert_extent3d(value)
+
+
+class MakeLine(GeoAggregate):
+    name = 'MakeLine'
+    output_field_class = LineStringField
+
+
+class Union(GeoAggregate):
+    name = 'Union'
+    output_field_class = GeometryField

venv/lib/python3.7/site-packages/django/contrib/gis/db/models/functions.py

@@ -0,0 +1,471 @@
+import warnings
+from decimal import Decimal
+
+from django.contrib.gis.db.models.fields import BaseSpatialField, GeometryField
+from django.contrib.gis.db.models.sql import AreaField, DistanceField
+from django.contrib.gis.geos import GEOSGeometry
+from django.core.exceptions import FieldError
+from django.db.models import (
+    BooleanField, FloatField, IntegerField, TextField, Transform,
+)
+from django.db.models.expressions import Func, Value
+from django.db.models.functions import Cast
+from django.db.utils import NotSupportedError
+from django.utils.deprecation import RemovedInDjango30Warning
+from django.utils.functional import cached_property
+
+NUMERIC_TYPES = (int, float, Decimal)
+
+
+class GeoFuncMixin:
+    function = None
+    geom_param_pos = (0,)
+
+    def __init__(self, *expressions, **extra):
+        super().__init__(*expressions, **extra)
+
+        # Ensure that value expressions are geometric.
+        for pos in self.geom_param_pos:
+            expr = self.source_expressions[pos]
+            if not isinstance(expr, Value):
+                continue
+            try:
+                output_field = expr.output_field
+            except FieldError:
+                output_field = None
+            geom = expr.value
+            if not isinstance(geom, GEOSGeometry) or output_field and not isinstance(output_field, GeometryField):
+                raise TypeError("%s function requires a geometric argument in position %d." % (self.name, pos + 1))
+            if not geom.srid and not output_field:
+                raise ValueError("SRID is required for all geometries.")
+            if not output_field:
+                self.source_expressions[pos] = Value(geom, output_field=GeometryField(srid=geom.srid))
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    @cached_property
+    def geo_field(self):
+        return self.source_expressions[self.geom_param_pos[0]].field
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        if not self.function and not function:
+            function = connection.ops.spatial_function_name(self.name)
+        return super().as_sql(compiler, connection, function=function, **extra_context)
+
+    def resolve_expression(self, *args, **kwargs):
+        res = super().resolve_expression(*args, **kwargs)
+
+        # Ensure that expressions are geometric.
+        source_fields = res.get_source_fields()
+        for pos in self.geom_param_pos:
+            field = source_fields[pos]
+            if not isinstance(field, GeometryField):
+                raise TypeError(
+                    "%s function requires a GeometryField in position %s, got %s." % (
+                        self.name, pos + 1, type(field).__name__,
+                    )
+                )
+
+        base_srid = res.geo_field.srid
+        for pos in self.geom_param_pos[1:]:
+            expr = res.source_expressions[pos]
+            expr_srid = expr.output_field.srid
+            if expr_srid != base_srid:
+                # Automatic SRID conversion so objects are comparable.
+                res.source_expressions[pos] = Transform(expr, base_srid).resolve_expression(*args, **kwargs)
+        return res
+
+    def _handle_param(self, value, param_name='', check_types=None):
+        if not hasattr(value, 'resolve_expression'):
+            if check_types and not isinstance(value, check_types):
+                raise TypeError(
+                    "The %s parameter has the wrong type: should be %s." % (
+                        param_name, check_types)
+                )
+        return value
+
+
+class GeoFunc(GeoFuncMixin, Func):
+    pass
+
+
+class GeomOutputGeoFunc(GeoFunc):
+    @cached_property
+    def output_field(self):
+        return GeometryField(srid=self.geo_field.srid)
+
+
+class SQLiteDecimalToFloatMixin:
+    """
+    By default, Decimal values are converted to str by the SQLite backend, which
+    is not acceptable by the GIS functions expecting numeric values.
+    """
+    def as_sqlite(self, compiler, connection, **extra_context):
+        for expr in self.get_source_expressions():
+            if hasattr(expr, 'value') and isinstance(expr.value, Decimal):
+                expr.value = float(expr.value)
+        return super().as_sql(compiler, connection, **extra_context)
+
+
+class OracleToleranceMixin:
+    tolerance = 0.05
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        tol = self.extra.get('tolerance', self.tolerance)
+        return self.as_sql(
+            compiler, connection,
+            template="%%(function)s(%%(expressions)s, %s)" % tol,
+            **extra_context
+        )
+
+
+class Area(OracleToleranceMixin, GeoFunc):
+    arity = 1
+
+    @cached_property
+    def output_field(self):
+        return AreaField(self.geo_field)
+
+    def as_sql(self, compiler, connection, **extra_context):
+        if not connection.features.supports_area_geodetic and self.geo_field.geodetic(connection):
+            raise NotSupportedError('Area on geodetic coordinate systems not supported.')
+        return super().as_sql(compiler, connection, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        if self.geo_field.geodetic(connection):
+            extra_context['template'] = '%(function)s(%(expressions)s, %(spheroid)d)'
+            extra_context['spheroid'] = True
+        return self.as_sql(compiler, connection, **extra_context)
+
+
+class Azimuth(GeoFunc):
+    output_field = FloatField()
+    arity = 2
+    geom_param_pos = (0, 1)
+
+
+class AsGeoJSON(GeoFunc):
+    output_field = TextField()
+
+    def __init__(self, expression, bbox=False, crs=False, precision=8, **extra):
+        expressions = [expression]
+        if precision is not None:
+            expressions.append(self._handle_param(precision, 'precision', int))
+        options = 0
+        if crs and bbox:
+            options = 3
+        elif bbox:
+            options = 1
+        elif crs:
+            options = 2
+        if options:
+            expressions.append(options)
+        super().__init__(*expressions, **extra)
+
+
+class AsGML(GeoFunc):
+    geom_param_pos = (1,)
+    output_field = TextField()
+
+    def __init__(self, expression, version=2, precision=8, **extra):
+        expressions = [version, expression]
+        if precision is not None:
+            expressions.append(self._handle_param(precision, 'precision', int))
+        super().__init__(*expressions, **extra)
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        source_expressions = self.get_source_expressions()
+        version = source_expressions[0]
+        clone = self.copy()
+        clone.set_source_expressions([source_expressions[1]])
+        extra_context['function'] = 'SDO_UTIL.TO_GML311GEOMETRY' if version.value == 3 else 'SDO_UTIL.TO_GMLGEOMETRY'
+        return super(AsGML, clone).as_sql(compiler, connection, **extra_context)
+
+
+class AsKML(AsGML):
+    def as_sqlite(self, compiler, connection, **extra_context):
+        # No version parameter
+        clone = self.copy()
+        clone.set_source_expressions(self.get_source_expressions()[1:])
+        return clone.as_sql(compiler, connection, **extra_context)
+
+
+class AsSVG(GeoFunc):
+    output_field = TextField()
+
+    def __init__(self, expression, relative=False, precision=8, **extra):
+        relative = relative if hasattr(relative, 'resolve_expression') else int(relative)
+        expressions = [
+            expression,
+            relative,
+            self._handle_param(precision, 'precision', int),
+        ]
+        super().__init__(*expressions, **extra)
+
+
+class BoundingCircle(OracleToleranceMixin, GeoFunc):
+    def __init__(self, expression, num_seg=48, **extra):
+        super().__init__(expression, num_seg, **extra)
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        clone = self.copy()
+        clone.set_source_expressions([self.get_source_expressions()[0]])
+        return super(BoundingCircle, clone).as_oracle(compiler, connection, **extra_context)
+
+
+class Centroid(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 1
+
+
+class Difference(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 2
+    geom_param_pos = (0, 1)
+
+
+class DistanceResultMixin:
+    @cached_property
+    def output_field(self):
+        return DistanceField(self.geo_field)
+
+    def source_is_geography(self):
+        return self.geo_field.geography and self.geo_field.srid == 4326
+
+
+class Distance(DistanceResultMixin, OracleToleranceMixin, GeoFunc):
+    geom_param_pos = (0, 1)
+    spheroid = None
+
+    def __init__(self, expr1, expr2, spheroid=None, **extra):
+        expressions = [expr1, expr2]
+        if spheroid is not None:
+            self.spheroid = self._handle_param(spheroid, 'spheroid', bool)
+        super().__init__(*expressions, **extra)
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        clone = self.copy()
+        function = None
+        expr2 = clone.source_expressions[1]
+        geography = self.source_is_geography()
+        if expr2.output_field.geography != geography:
+            if isinstance(expr2, Value):
+                expr2.output_field.geography = geography
+            else:
+                clone.source_expressions[1] = Cast(
+                    expr2,
+                    GeometryField(srid=expr2.output_field.srid, geography=geography),
+                )
+
+        if not geography and self.geo_field.geodetic(connection):
+            # Geometry fields with geodetic (lon/lat) coordinates need special distance functions
+            if self.spheroid:
+                # DistanceSpheroid is more accurate and resource intensive than DistanceSphere
+                function = connection.ops.spatial_function_name('DistanceSpheroid')
+                # Replace boolean param by the real spheroid of the base field
+                clone.source_expressions.append(Value(self.geo_field.spheroid(connection)))
+            else:
+                function = connection.ops.spatial_function_name('DistanceSphere')
+        return super(Distance, clone).as_sql(compiler, connection, function=function, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        if self.geo_field.geodetic(connection):
+            # SpatiaLite returns NULL instead of zero on geodetic coordinates
+            extra_context['template'] = 'COALESCE(%(function)s(%(expressions)s, %(spheroid)s), 0)'
+            extra_context['spheroid'] = int(bool(self.spheroid))
+        return super().as_sql(compiler, connection, **extra_context)
+
+
+class Envelope(GeomOutputGeoFunc):
+    arity = 1
+
+
+class ForcePolygonCW(GeomOutputGeoFunc):
+    arity = 1
+
+
+class ForceRHR(GeomOutputGeoFunc):
+    arity = 1
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            'ForceRHR is deprecated in favor of ForcePolygonCW.',
+            RemovedInDjango30Warning, stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+
+class GeoHash(GeoFunc):
+    output_field = TextField()
+
+    def __init__(self, expression, precision=None, **extra):
+        expressions = [expression]
+        if precision is not None:
+            expressions.append(self._handle_param(precision, 'precision', int))
+        super().__init__(*expressions, **extra)
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        clone = self.copy()
+        # If no precision is provided, set it to the maximum.
+        if len(clone.source_expressions) < 2:
+            clone.source_expressions.append(Value(100))
+        return clone.as_sql(compiler, connection, **extra_context)
+
+
+class Intersection(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 2
+    geom_param_pos = (0, 1)
+
+
+@BaseSpatialField.register_lookup
+class IsValid(OracleToleranceMixin, GeoFuncMixin, Transform):
+    lookup_name = 'isvalid'
+    output_field = BooleanField()
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        sql, params = super().as_oracle(compiler, connection, **extra_context)
+        return "CASE %s WHEN 'TRUE' THEN 1 ELSE 0 END" % sql, params
+
+
+class Length(DistanceResultMixin, OracleToleranceMixin, GeoFunc):
+    def __init__(self, expr1, spheroid=True, **extra):
+        self.spheroid = spheroid
+        super().__init__(expr1, **extra)
+
+    def as_sql(self, compiler, connection, **extra_context):
+        if self.geo_field.geodetic(connection) and not connection.features.supports_length_geodetic:
+            raise NotSupportedError("This backend doesn't support Length on geodetic fields")
+        return super().as_sql(compiler, connection, **extra_context)
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        clone = self.copy()
+        function = None
+        if self.source_is_geography():
+            clone.source_expressions.append(Value(self.spheroid))
+        elif self.geo_field.geodetic(connection):
+            # Geometry fields with geodetic (lon/lat) coordinates need length_spheroid
+            function = connection.ops.spatial_function_name('LengthSpheroid')
+            clone.source_expressions.append(Value(self.geo_field.spheroid(connection)))
+        else:
+            dim = min(f.dim for f in self.get_source_fields() if f)
+            if dim > 2:
+                function = connection.ops.length3d
+        return super(Length, clone).as_sql(compiler, connection, function=function, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        function = None
+        if self.geo_field.geodetic(connection):
+            function = 'GeodesicLength' if self.spheroid else 'GreatCircleLength'
+        return super().as_sql(compiler, connection, function=function, **extra_context)
+
+
+class LineLocatePoint(GeoFunc):
+    output_field = FloatField()
+    arity = 2
+    geom_param_pos = (0, 1)
+
+
+class MakeValid(GeoFunc):
+    pass
+
+
+class MemSize(GeoFunc):
+    output_field = IntegerField()
+    arity = 1
+
+
+class NumGeometries(GeoFunc):
+    output_field = IntegerField()
+    arity = 1
+
+
+class NumPoints(GeoFunc):
+    output_field = IntegerField()
+    arity = 1
+
+
+class Perimeter(DistanceResultMixin, OracleToleranceMixin, GeoFunc):
+    arity = 1
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        function = None
+        if self.geo_field.geodetic(connection) and not self.source_is_geography():
+            raise NotSupportedError("ST_Perimeter cannot use a non-projected non-geography field.")
+        dim = min(f.dim for f in self.get_source_fields())
+        if dim > 2:
+            function = connection.ops.perimeter3d
+        return super().as_sql(compiler, connection, function=function, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        if self.geo_field.geodetic(connection):
+            raise NotSupportedError("Perimeter cannot use a non-projected field.")
+        return super().as_sql(compiler, connection, **extra_context)
+
+
+class PointOnSurface(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 1
+
+
+class Reverse(GeoFunc):
+    arity = 1
+
+
+class Scale(SQLiteDecimalToFloatMixin, GeomOutputGeoFunc):
+    def __init__(self, expression, x, y, z=0.0, **extra):
+        expressions = [
+            expression,
+            self._handle_param(x, 'x', NUMERIC_TYPES),
+            self._handle_param(y, 'y', NUMERIC_TYPES),
+        ]
+        if z != 0.0:
+            expressions.append(self._handle_param(z, 'z', NUMERIC_TYPES))
+        super().__init__(*expressions, **extra)
+
+
+class SnapToGrid(SQLiteDecimalToFloatMixin, GeomOutputGeoFunc):
+    def __init__(self, expression, *args, **extra):
+        nargs = len(args)
+        expressions = [expression]
+        if nargs in (1, 2):
+            expressions.extend(
+                [self._handle_param(arg, '', NUMERIC_TYPES) for arg in args]
+            )
+        elif nargs == 4:
+            # Reverse origin and size param ordering
+            expressions += [
+                *(self._handle_param(arg, '', NUMERIC_TYPES) for arg in args[2:]),
+                *(self._handle_param(arg, '', NUMERIC_TYPES) for arg in args[0:2]),
+            ]
+        else:
+            raise ValueError('Must provide 1, 2, or 4 arguments to `SnapToGrid`.')
+        super().__init__(*expressions, **extra)
+
+
+class SymDifference(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 2
+    geom_param_pos = (0, 1)
+
+
+class Transform(GeomOutputGeoFunc):
+    def __init__(self, expression, srid, **extra):
+        expressions = [
+            expression,
+            self._handle_param(srid, 'srid', int),
+        ]
+        if 'output_field' not in extra:
+            extra['output_field'] = GeometryField(srid=srid)
+        super().__init__(*expressions, **extra)
+
+
+class Translate(Scale):
+    def as_sqlite(self, compiler, connection, **extra_context):
+        clone = self.copy()
+        if len(self.source_expressions) < 4:
+            # Always provide the z parameter for ST_Translate
+            clone.source_expressions.append(Value(0))
+        return super(Translate, clone).as_sqlite(compiler, connection, **extra_context)
+
+
+class Union(OracleToleranceMixin, GeomOutputGeoFunc):
+    arity = 2
+    geom_param_pos = (0, 1)

venv/lib/python3.7/site-packages/django/contrib/gis/db/models/proxy.py

@@ -0,0 +1,80 @@
+"""
+The SpatialProxy object allows for lazy-geometries and lazy-rasters. The proxy
+uses Python descriptors for instantiating and setting Geometry or Raster
+objects corresponding to geographic model fields.
+
+Thanks to Robert Coup for providing this functionality (see #4322).
+"""
+from django.db.models.query_utils import DeferredAttribute
+
+
+class SpatialProxy(DeferredAttribute):
+    def __init__(self, klass, field, load_func=None):
+        """
+        Initialize on the given Geometry or Raster class (not an instance)
+        and the corresponding field.
+        """
+        self._field = field
+        self._klass = klass
+        self._load_func = load_func or klass
+        super().__init__(field.attname)
+
+    def __get__(self, instance, cls=None):
+        """
+        Retrieve the geometry or raster, initializing it using the
+        corresponding class specified during initialization and the value of
+        the field. Currently, GEOS or OGR geometries as well as GDALRasters are
+        supported.
+        """
+        if instance is None:
+            # Accessed on a class, not an instance
+            return self
+
+        # Getting the value of the field.
+        try:
+            geo_value = instance.__dict__[self._field.attname]
+        except KeyError:
+            geo_value = super().__get__(instance, cls)
+
+        if isinstance(geo_value, self._klass):
+            geo_obj = geo_value
+        elif (geo_value is None) or (geo_value == ''):
+            geo_obj = None
+        else:
+            # Otherwise, a geometry or raster object is built using the field's
+            # contents, and the model's corresponding attribute is set.
+            geo_obj = self._load_func(geo_value)
+            setattr(instance, self._field.attname, geo_obj)
+        return geo_obj
+
+    def __set__(self, instance, value):
+        """
+        Retrieve the proxied geometry or raster with the corresponding class
+        specified during initialization.
+
+        To set geometries, use values of None, HEXEWKB, or WKT.
+        To set rasters, use JSON or dict values.
+        """
+        # The geographic type of the field.
+        gtype = self._field.geom_type
+
+        if gtype == 'RASTER' and (value is None or isinstance(value, (str, dict, self._klass))):
+            # For raster fields, assure input is None or a string, dict, or
+            # raster instance.
+            pass
+        elif isinstance(value, self._klass):
+            # The geometry type must match that of the field -- unless the
+            # general GeometryField is used.
+            if value.srid is None:
+                # Assigning the field SRID if the geometry has no SRID.
+                value.srid = self._field.srid
+        elif value is None or isinstance(value, (str, memoryview)):
+            # Set geometries with None, WKT, HEX, or WKB
+            pass
+        else:
+            raise TypeError('Cannot set %s SpatialProxy (%s) with value of type: %s' % (
+                instance.__class__.__name__, gtype, type(value)))
+
+        # Setting the objects dictionary with the value, and returning.
+        instance.__dict__[self._field.attname] = value
+        return value

venv/lib/python3.7/site-packages/django/contrib/gis/db/models/sql/__init__.py

@@ -0,0 +1,7 @@
+from django.contrib.gis.db.models.sql.conversion import (
+    AreaField, DistanceField,
+)
+
+__all__ = [
+    'AreaField', 'DistanceField',
+]