innov
/
django1
1
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Replaced no_mysql by connection features 

Refs #22632. Thanks Tim Graham for the review.
This commit is contained in:
Claude Paroz 2014-08-21 14:26:49 +02:00
parent a7d964ab87
commit ba1d707b0f
5 changed files with 69 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
django/contrib/gis/db/backends/base.py
View File

@ -2,6 +2,7 @@
Base/mixin classes for the spatial backend database operations and the Base/mixin classes for the spatial backend database operations and the
`<Backend>SpatialRefSys` model. `<Backend>SpatialRefSys` model.
""" """
from functools import partial
import re import re
from django.contrib.gis import gdal from django.contrib.gis import gdal
@ -15,42 +16,38 @@ class BaseSpatialFeatures(object):
# Does the database contain a SpatialRefSys model to store SRID information? # Does the database contain a SpatialRefSys model to store SRID information?
has_spatialrefsys_table = True has_spatialrefsys_table = True
# 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
# Can the `distance` GeoQuerySet method be applied on geodetic coordinate systems? # Can the `distance` GeoQuerySet method be applied on geodetic coordinate systems?
supports_distance_geodetic = True supports_distance_geodetic = True
# Does the database supports `left` and `right` lookups?
supports_left_right_lookups = False
# Is the database able to count vertices on polygons (with `num_points`)? # Is the database able to count vertices on polygons (with `num_points`)?
supports_num_points_poly = True supports_num_points_poly = True
# The following properties indicate if the database GIS extensions support # The following properties indicate if the database backend support
# certain methods (dwithin, force_rhr, geohash, ...) # certain lookups (dwithin, left and right, relate, ...)
supports_left_right_lookups = False
@property
def supports_relate_lookup(self):
return 'relate' in self.connection.ops.geometry_functions
@property @property
def has_dwithin_lookup(self): def has_dwithin_lookup(self):
return 'dwithin' in self.connection.ops.distance_functions return 'dwithin' in self.connection.ops.distance_functions
@property # For each of those methods, the class will have a property named
def has_force_rhr_method(self): # `has_<name>_method` (defined in __init__) which accesses connection.ops
return bool(self.connection.ops.force_rhr) # to determine GIS method availability.
geoqueryset_methods = (
@property 'centroid', 'difference', 'envelope', 'force_rhr', 'geohash', 'gml',
def has_geohash_method(self): 'intersection', 'kml', 'num_geom', 'perimeter', 'point_on_surface',
return bool(self.connection.ops.geohash) 'reverse', 'scale', 'snap_to_grid', 'svg', 'sym_difference',
'transform', 'translate', 'union', 'unionagg',
@property )
def has_make_line_method(self):
return bool(self.connection.ops.make_line)
@property
def has_perimeter_method(self):
return bool(self.connection.ops.perimeter)
@property
def has_reverse_method(self):
return bool(self.connection.ops.reverse)
@property
def has_snap_to_grid_method(self):
return bool(self.connection.ops.snap_to_grid)
# Specifies whether the Collect and Extent aggregates are supported by the database # Specifies whether the Collect and Extent aggregates are supported by the database
@property @property
@ -61,6 +58,20 @@ class BaseSpatialFeatures(object):
def supports_extent_aggr(self): def supports_extent_aggr(self):
return 'Extent' in self.connection.ops.valid_aggregates return 'Extent' in self.connection.ops.valid_aggregates
@property
def supports_make_line_aggr(self):
return 'MakeLine' in self.connection.ops.valid_aggregates
def __init__(self, *args):
super(BaseSpatialFeatures, self).__init__(*args)
for method in self.geoqueryset_methods:
# Add dynamically properties for each GQS method, e.g. has_force_rhr_method, etc.
setattr(self.__class__, 'has_%s_method' % method,
property(partial(BaseSpatialFeatures.has_ops_method, method=method)))
def has_ops_method(self, method):
return getattr(self.connection.ops, method, False)
class BaseSpatialOperations(object): class BaseSpatialOperations(object):
""" """

3
django/contrib/gis/db/backends/mysql/base.py
View File

@ -10,6 +10,9 @@ from django.contrib.gis.db.backends.mysql.operations import MySQLOperations
class DatabaseFeatures(BaseSpatialFeatures, MySQLDatabaseFeatures): class DatabaseFeatures(BaseSpatialFeatures, MySQLDatabaseFeatures):
has_spatialrefsys_table = False has_spatialrefsys_table = False
supports_transform = False
supports_real_shape_operations = False
supports_null_geometries = False
supports_num_points_poly = False supports_num_points_poly = False

59
django/contrib/gis/tests/geoapp/tests.py
View File

@ -7,8 +7,7 @@ from unittest import skipUnless
from django.db import connection from django.db import connection
from django.contrib.gis import gdal from django.contrib.gis import gdal
from django.contrib.gis.geos import HAS_GEOS from django.contrib.gis.geos import HAS_GEOS
from django.contrib.gis.tests.utils import ( from django.contrib.gis.tests.utils import mysql, oracle, postgis, spatialite
no_mysql, no_oracle, mysql, oracle, postgis, spatialite)
from django.test import TestCase, skipUnlessDBFeature from django.test import TestCase, skipUnlessDBFeature
from django.utils import six from django.utils import six
@ -104,7 +103,7 @@ class GeoModelTest(TestCase):
self.assertEqual(ply, State.objects.get(name='NullState').poly) self.assertEqual(ply, State.objects.get(name='NullState').poly)
ns.delete() ns.delete()
@no_mysql @skipUnlessDBFeature("supports_transform")
def test_lookup_insert_transform(self): def test_lookup_insert_transform(self):
"Testing automatic transform for lookups and inserts." "Testing automatic transform for lookups and inserts."
# San Antonio in 'WGS84' (SRID 4326) # San Antonio in 'WGS84' (SRID 4326)
@ -176,7 +175,7 @@ class GeoModelTest(TestCase):
self.assertEqual(True, isinstance(f_4.geom, GeometryCollection)) self.assertEqual(True, isinstance(f_4.geom, GeometryCollection))
self.assertEqual(f_3.geom, f_4.geom[2]) self.assertEqual(f_3.geom, f_4.geom[2])
@no_mysql @skipUnlessDBFeature("supports_transform")
def test_inherited_geofields(self): def test_inherited_geofields(self):
"Test GeoQuerySet methods on inherited Geometry fields." "Test GeoQuerySet methods on inherited Geometry fields."
# Creating a Pennsylvanian city. # Creating a Pennsylvanian city.
@ -205,16 +204,16 @@ class GeoModelTest(TestCase):
class GeoLookupTest(TestCase): class GeoLookupTest(TestCase):
fixtures = ['initial'] fixtures = ['initial']
@no_mysql
def test_disjoint_lookup(self): def test_disjoint_lookup(self):
"Testing the `disjoint` lookup type." "Testing the `disjoint` lookup type."
ptown = City.objects.get(name='Pueblo') ptown = City.objects.get(name='Pueblo')
qs1 = City.objects.filter(point__disjoint=ptown.point) qs1 = City.objects.filter(point__disjoint=ptown.point)
self.assertEqual(7, qs1.count()) self.assertEqual(7, qs1.count())
qs2 = State.objects.filter(poly__disjoint=ptown.point) if connection.features.supports_real_shape_operations:
self.assertEqual(1, qs2.count()) qs2 = State.objects.filter(poly__disjoint=ptown.point)
self.assertEqual('Kansas', qs2[0].name) self.assertEqual(1, qs2.count())
self.assertEqual('Kansas', qs2[0].name)
def test_contains_contained_lookups(self): def test_contains_contained_lookups(self):
"Testing the 'contained', 'contains', and 'bbcontains' lookup types." "Testing the 'contained', 'contains', and 'bbcontains' lookup types."
@ -317,7 +316,7 @@ class GeoLookupTest(TestCase):
for c in [c1, c2, c3]: for c in [c1, c2, c3]:
self.assertEqual('Houston', c.name) self.assertEqual('Houston', c.name)
@no_mysql @skipUnlessDBFeature("supports_null_geometries")
def test_null_geometries(self): def test_null_geometries(self):
"Testing NULL geometry support, and the `isnull` lookup type." "Testing NULL geometry support, and the `isnull` lookup type."
# Creating a state with a NULL boundary. # Creating a state with a NULL boundary.
@ -347,7 +346,7 @@ class GeoLookupTest(TestCase):
State.objects.filter(name='Northern Mariana Islands').update(poly=None) State.objects.filter(name='Northern Mariana Islands').update(poly=None)
self.assertEqual(None, State.objects.get(name='Northern Mariana Islands').poly) self.assertEqual(None, State.objects.get(name='Northern Mariana Islands').poly)
@no_mysql @skipUnlessDBFeature("supports_relate_lookup")
def test_relate_lookup(self): def test_relate_lookup(self):
"Testing the 'relate' lookup type." "Testing the 'relate' lookup type."
# To make things more interesting, we will have our Texas reference point in # To make things more interesting, we will have our Texas reference point in
@ -397,7 +396,7 @@ class GeoQuerySetTest(TestCase):
# Please keep the tests in GeoQuerySet method's alphabetic order # Please keep the tests in GeoQuerySet method's alphabetic order
@no_mysql @skipUnlessDBFeature("has_centroid_method")
def test_centroid(self): def test_centroid(self):
"Testing the `centroid` GeoQuerySet method." "Testing the `centroid` GeoQuerySet method."
qs = State.objects.exclude(poly__isnull=True).centroid() qs = State.objects.exclude(poly__isnull=True).centroid()
@ -410,7 +409,10 @@ class GeoQuerySetTest(TestCase):
for s in qs: for s in qs:
self.assertEqual(True, s.poly.centroid.equals_exact(s.centroid, tol)) self.assertEqual(True, s.poly.centroid.equals_exact(s.centroid, tol))
@no_mysql @skipUnlessDBFeature("has_difference_method")
@skipUnlessDBFeature("has_intersection_method")
@skipUnlessDBFeature("has_sym_difference_method")
@skipUnlessDBFeature("has_union_method")
def test_diff_intersection_union(self): def test_diff_intersection_union(self):
"Testing the `difference`, `intersection`, `sym_difference`, and `union` GeoQuerySet methods." "Testing the `difference`, `intersection`, `sym_difference`, and `union` GeoQuerySet methods."
geom = Point(5, 23) geom = Point(5, 23)
@ -439,7 +441,7 @@ class GeoQuerySetTest(TestCase):
self.assertSetEqual(set(g.wkt for g in c.mpoly.union(geom)), self.assertSetEqual(set(g.wkt for g in c.mpoly.union(geom)),
set(g.wkt for g in c.union)) set(g.wkt for g in c.union))
@skipUnless(getattr(connection.ops, 'envelope', False), 'Database does not support envelope operation') @skipUnlessDBFeature("has_envelope_method")
def test_envelope(self): def test_envelope(self):
"Testing the `envelope` GeoQuerySet method." "Testing the `envelope` GeoQuerySet method."
countries = Country.objects.all().envelope() countries = Country.objects.all().envelope()
@ -520,12 +522,9 @@ class GeoQuerySetTest(TestCase):
# Finally, we set every available keyword. # Finally, we set every available keyword.
self.assertEqual(chicago_json, City.objects.geojson(bbox=True, crs=True, precision=5).get(name='Chicago').geojson) self.assertEqual(chicago_json, City.objects.geojson(bbox=True, crs=True, precision=5).get(name='Chicago').geojson)
@skipUnlessDBFeature("has_gml_method")
def test_gml(self): def test_gml(self):
"Testing GML output from the database using GeoQuerySet.gml()." "Testing GML output from the database using GeoQuerySet.gml()."
if mysql or (spatialite and not connection.ops.gml):
self.assertRaises(NotImplementedError, Country.objects.all().gml, field_name='mpoly')
return
# Should throw a TypeError when tyring to obtain GML from a # Should throw a TypeError when tyring to obtain GML from a
# non-geometry field. # non-geometry field.
qs = City.objects.all() qs = City.objects.all()
@ -548,13 +547,9 @@ class GeoQuerySetTest(TestCase):
if postgis: if postgis:
self.assertIn('<gml:pos srsDimension="2">', City.objects.gml(version=3).get(name='Pueblo').gml) self.assertIn('<gml:pos srsDimension="2">', City.objects.gml(version=3).get(name='Pueblo').gml)
@skipUnlessDBFeature("has_kml_method")
def test_kml(self): def test_kml(self):
"Testing KML output from the database using GeoQuerySet.kml()." "Testing KML output from the database using GeoQuerySet.kml()."
# Only PostGIS and Spatialite (>=2.4.0-RC4) support KML serialization
if not (postgis or (spatialite and connection.ops.kml)):
self.assertRaises(NotImplementedError, State.objects.all().kml, field_name='poly')
return
# Should throw a TypeError when trying to obtain KML from a # Should throw a TypeError when trying to obtain KML from a
# non-geometry field. # non-geometry field.
qs = City.objects.all() qs = City.objects.all()
@ -567,7 +562,7 @@ class GeoQuerySetTest(TestCase):
self.assertEqual('<Point><coordinates>-104.609252,38.255001</coordinates></Point>', ptown.kml) self.assertEqual('<Point><coordinates>-104.609252,38.255001</coordinates></Point>', ptown.kml)
# Only PostGIS has support for the MakeLine aggregate. # Only PostGIS has support for the MakeLine aggregate.
@skipUnlessDBFeature("has_make_line_method") @skipUnlessDBFeature("supports_make_line_aggr")
def test_make_line(self): def test_make_line(self):
"Testing the `make_line` GeoQuerySet method." "Testing the `make_line` GeoQuerySet method."
# Ensuring that a `TypeError` is raised on models without PointFields. # Ensuring that a `TypeError` is raised on models without PointFields.
@ -578,7 +573,7 @@ class GeoQuerySetTest(TestCase):
ref_line = GEOSGeometry('LINESTRING(-95.363151 29.763374,-96.801611 32.782057,-97.521157 34.464642,174.783117 -41.315268,-104.609252 38.255001,-95.23506 38.971823,-87.650175 41.850385,-123.305196 48.462611)', srid=4326) ref_line = GEOSGeometry('LINESTRING(-95.363151 29.763374,-96.801611 32.782057,-97.521157 34.464642,174.783117 -41.315268,-104.609252 38.255001,-95.23506 38.971823,-87.650175 41.850385,-123.305196 48.462611)', srid=4326)
self.assertEqual(ref_line, City.objects.make_line()) self.assertEqual(ref_line, City.objects.make_line())
@no_mysql @skipUnlessDBFeature("has_num_geom_method")
def test_num_geom(self): def test_num_geom(self):
"Testing the `num_geom` GeoQuerySet method." "Testing the `num_geom` GeoQuerySet method."
# Both 'countries' only have two geometries. # Both 'countries' only have two geometries.
@ -605,7 +600,7 @@ class GeoQuerySetTest(TestCase):
for c in City.objects.num_points(): for c in City.objects.num_points():
self.assertEqual(1, c.num_points) self.assertEqual(1, c.num_points)
@no_mysql @skipUnlessDBFeature("has_point_on_surface_method")
def test_point_on_surface(self): def test_point_on_surface(self):
"Testing the `point_on_surface` GeoQuerySet method." "Testing the `point_on_surface` GeoQuerySet method."
# Reference values. # Reference values.
@ -641,8 +636,7 @@ class GeoQuerySetTest(TestCase):
if oracle: if oracle:
self.assertRaises(TypeError, State.objects.reverse_geom) self.assertRaises(TypeError, State.objects.reverse_geom)
@no_mysql @skipUnlessDBFeature("has_scale_method")
@no_oracle
def test_scale(self): def test_scale(self):
"Testing the `scale` GeoQuerySet method." "Testing the `scale` GeoQuerySet method."
xfac, yfac = 2, 3 xfac, yfac = 2, 3
@ -692,11 +686,9 @@ class GeoQuerySetTest(TestCase):
ref = fromstr('MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))') ref = fromstr('MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))')
self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol)) self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol))
@skipUnlessDBFeature("has_svg_method")
def test_svg(self): def test_svg(self):
"Testing SVG output using GeoQuerySet.svg()." "Testing SVG output using GeoQuerySet.svg()."
if mysql or oracle:
self.assertRaises(NotImplementedError, City.objects.svg)
return
self.assertRaises(TypeError, City.objects.svg, precision='foo') self.assertRaises(TypeError, City.objects.svg, precision='foo')
# SELECT AsSVG(geoapp_city.point, 0, 8) FROM geoapp_city WHERE name = 'Pueblo'; # SELECT AsSVG(geoapp_city.point, 0, 8) FROM geoapp_city WHERE name = 'Pueblo';
@ -707,7 +699,7 @@ class GeoQuerySetTest(TestCase):
self.assertEqual(svg1, City.objects.svg().get(name='Pueblo').svg) self.assertEqual(svg1, City.objects.svg().get(name='Pueblo').svg)
self.assertEqual(svg2, City.objects.svg(relative=5).get(name='Pueblo').svg) self.assertEqual(svg2, City.objects.svg(relative=5).get(name='Pueblo').svg)
@no_mysql @skipUnlessDBFeature("has_transform_method")
def test_transform(self): def test_transform(self):
"Testing the transform() GeoQuerySet method." "Testing the transform() GeoQuerySet method."
# Pre-transformed points for Houston and Pueblo. # Pre-transformed points for Houston and Pueblo.
@ -730,8 +722,7 @@ class GeoQuerySetTest(TestCase):
self.assertAlmostEqual(ptown.x, p.point.x, prec) self.assertAlmostEqual(ptown.x, p.point.x, prec)
self.assertAlmostEqual(ptown.y, p.point.y, prec) self.assertAlmostEqual(ptown.y, p.point.y, prec)
@no_mysql @skipUnlessDBFeature("has_translate_method")
@no_oracle
def test_translate(self): def test_translate(self):
"Testing the `translate` GeoQuerySet method." "Testing the `translate` GeoQuerySet method."
xfac, yfac = 5, -23 xfac, yfac = 5, -23
@ -744,7 +735,7 @@ class GeoQuerySetTest(TestCase):
self.assertAlmostEqual(c1[0] + xfac, c2[0], 5) self.assertAlmostEqual(c1[0] + xfac, c2[0], 5)
self.assertAlmostEqual(c1[1] + yfac, c2[1], 5) self.assertAlmostEqual(c1[1] + yfac, c2[1], 5)
@no_mysql @skipUnlessDBFeature("has_unionagg_method")
def test_unionagg(self): def test_unionagg(self):
"Testing the `unionagg` (aggregate union) GeoQuerySet method." "Testing the `unionagg` (aggregate union) GeoQuerySet method."
tx = Country.objects.get(name='Texas').mpoly tx = Country.objects.get(name='Texas').mpoly

6
django/contrib/gis/tests/relatedapp/tests.py
View File

@ -1,7 +1,7 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.gis.geos import HAS_GEOS from django.contrib.gis.geos import HAS_GEOS
from django.contrib.gis.tests.utils import mysql, no_mysql, no_oracle from django.contrib.gis.tests.utils import mysql, no_oracle
from django.test import TestCase, skipUnlessDBFeature from django.test import TestCase, skipUnlessDBFeature
if HAS_GEOS: if HAS_GEOS:
@ -36,7 +36,7 @@ class RelatedGeoModelTest(TestCase):
self.assertEqual(st, c.state) self.assertEqual(st, c.state)
self.assertEqual(Point(lon, lat), c.location.point) self.assertEqual(Point(lon, lat), c.location.point)
@no_mysql @skipUnlessDBFeature("has_transform_method")
def test03_transform_related(self): def test03_transform_related(self):
"Testing the `transform` GeoQuerySet method on related geographic models." "Testing the `transform` GeoQuerySet method on related geographic models."
# All the transformations are to state plane coordinate systems using # All the transformations are to state plane coordinate systems using
@ -80,7 +80,7 @@ class RelatedGeoModelTest(TestCase):
for ref_val, e_val in zip(ref, e): for ref_val, e_val in zip(ref, e):
self.assertAlmostEqual(ref_val, e_val, tol) self.assertAlmostEqual(ref_val, e_val, tol)
@no_mysql @skipUnlessDBFeature("has_unionagg_method")
def test04b_related_union_aggregate(self): def test04b_related_union_aggregate(self):
"Testing the `unionagg` GeoQuerySet aggregates on related geographic models." "Testing the `unionagg` GeoQuerySet aggregates on related geographic models."
# This combines the Extent and Union aggregates into one query # This combines the Extent and Union aggregates into one query

8
django/contrib/gis/tests/utils.py
View File

@ -21,14 +21,6 @@ def no_oracle(func):
return no_backend(func, 'oracle') return no_backend(func, 'oracle')
def no_postgis(func):
return no_backend(func, 'postgis')
def no_mysql(func):
return no_backend(func, 'mysql')
# Shortcut booleans to omit only portions of tests. # Shortcut booleans to omit only portions of tests.
_default_db = settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'].rsplit('.')[-1] _default_db = settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'].rsplit('.')[-1]
oracle = _default_db == 'oracle' oracle = _default_db == 'oracle'