Fixed problems associated with the GeometryField SRID cache: it is now keyed by the connection alias rather than the spatial backend name (e.g., spatial_ref_sys tables may have different entries, even if backend is the same), explicitly pass in connection alias to SpatialRefSys query to ensure correct entry is retrieved, and removed unused code from GeometryField.get_distance. Thanks, Josh Livni, for the bug report.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@12258 bcc190cf-cafb-0310-a4f2-bffc1f526a37

django/contrib/gis/db/backends/base.py

@@ -122,6 +122,13 @@ class BaseSpatialOperations(object):
     def spatial_lookup_sql(self, lvalue, lookup_type, value, field):
         raise NotImplmentedError
 
+    # Routines for getting the OGC-compliant models.
+    def geometry_columns(self):
+        raise NotImplementedError
+
+    def spatial_ref_sys(self):
+        raise NotImplementedError
+
 class SpatialRefSysMixin(object):
     """
     The SpatialRefSysMixin is a class used by the database-dependent

django/contrib/gis/db/models/fields.py

@@ -1,45 +1,42 @@
 from django.db.models.fields import Field
+from django.db.models.sql.expressions import SQLEvaluator
 from django.utils.translation import ugettext_lazy as _
 from django.contrib.gis import forms
 from django.contrib.gis.db.models.proxy import GeometryProxy
 from django.contrib.gis.geometry.backend import Geometry, GeometryException
-from django.contrib.gis.measure import Distance
-from django.db.models.sql.expressions import SQLEvaluator
 
-# Local cache of the spatial_ref_sys table, which holds static data.
-# This exists so that we don't have to hit the database each time
-# we construct a distance query.
-_srid_cache = {'postgis' : {},
-               'oracle' : {},
-               'spatialite' : {},
-               }
+# Local cache of the spatial_ref_sys table, which holds SRID data for each
+# spatial database alias. This cache exists so that the database isn't queried
+# for SRID info each time a distance query is constructed.
+_srid_cache = {}
 
 def get_srid_info(srid, connection):
     """
     Returns the units, unit name, and spheroid WKT associated with the
     given SRID from the `spatial_ref_sys` (or equivalent) spatial database
-    table.  These results are cached.
+    table for the given database connection.  These results are cached.
     """
     global _srid_cache
 
-    # No `spatial_ref_sys` table in MySQL.
-    if connection.ops.mysql:
+    try:
+        # The SpatialRefSys model for the spatial backend.
+        SpatialRefSys = connection.ops.spatial_ref_sys()
+    except NotImplementedError:
+        # No `spatial_ref_sys` table in spatial backend (e.g., MySQL).
         return None, None, None
 
-    name = connection.ops.name
-    if not srid in _srid_cache[name]:
-        if connection.ops.postgis:
-            from django.contrib.gis.db.backends.postgis.models import SpatialRefSys
-        elif connection.ops.oracle:
-            from django.contrib.gis.db.backends.oracle.models import SpatialRefSys
-        elif connection.ops.spatialite:
-            from django.contrib.gis.db.backends.spatialite.models import SpatialRefSys
-        sr = SpatialRefSys.objects.get(srid=srid)
+    if not connection.alias in _srid_cache:
+        # Initialize SRID dictionary for database if it doesn't exist.
+        _srid_cache[connection.alias] = {}
+
+    if not srid in _srid_cache[connection.alias]:
+        # Use `SpatialRefSys` model to query for spatial reference info.
+        sr = SpatialRefSys.objects.using(connection.alias).get(srid=srid)
         units, units_name = sr.units
         spheroid = SpatialRefSys.get_spheroid(sr.wkt)
-        _srid_cache[name][srid] = (units, units_name, spheroid)
+        _srid_cache[connection.alias][srid] = (units, units_name, spheroid)
 
-    return _srid_cache[name][srid]
+    return _srid_cache[connection.alias][srid]
 
 class GeometryField(Field):
     "The base GIS field -- maps to the OpenGIS Specification Geometry type."
@@ -141,31 +138,6 @@ class GeometryField(Field):
         """
         return connection.ops.get_distance(self, value, lookup_type)
 
-        if isinstance(dist, Distance):
-            if self.geodetic(connection):
-                # Won't allow Distance objects w/DWithin lookups on PostGIS.
-                if connection.ops.postgis and lookup_type == 'dwithin':
-                    raise ValueError('Only numeric values of degree units are allowed on geographic DWithin queries.')
-
-                # Spherical distance calculation parameter should be in meters.
-                dist_param = dist.m
-            else:
-                dist_param = getattr(dist, Distance.unit_attname(self.units_name(connection)))
-        else:
-            # Assuming the distance is in the units of the field.
-            dist_param = dist
-
-        if connection.ops.oracle and lookup_type == 'dwithin':
-            dist_param = 'distance=%s' % dist_param
-
-        if connection.ops.postgis and self.geodetic(connection) and lookup_type != 'dwithin' and option == 'spheroid':
-            # On PostGIS, by default `ST_distance_sphere` is used; but if the
-            # accuracy of `ST_distance_spheroid` is needed than the spheroid
-            # needs to be passed to the SQL stored procedure.
-            return [self._spheroid, dist_param]
-        else:
-            return [dist_param]
-
     def get_prep_value(self, value):
         """
         Spatial lookup values are either a parameter that is (or may be