diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/contrib/gis/db')
46 files changed, 0 insertions, 4562 deletions
diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/adapter.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/adapter.py deleted file mode 100644 index ca77124..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/adapter.py +++ /dev/null @@ -1,19 +0,0 @@ -class WKTAdapter(object): - """ - This provides an adaptor for Geometries sent to the - MySQL and Oracle database backends. - """ - def __init__(self, geom): - self.wkt = geom.wkt - self.srid = geom.srid - - def __eq__(self, other): - if not isinstance(other, WKTAdapter): - return False - return self.wkt == other.wkt and self.srid == other.srid - - def __str__(self): - return self.wkt - - def prepare_database_save(self, unused): - return self diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/base.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/base.py deleted file mode 100644 index 7db7ce5..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/base.py +++ /dev/null @@ -1,349 +0,0 @@ -""" -Base/mixin classes for the spatial backend database operations and the -`SpatialRefSys` model the backend. -""" -import re - -from django.contrib.gis import gdal -from django.utils import six -from django.utils.encoding import python_2_unicode_compatible - - -class BaseSpatialOperations(object): - """ - This module holds the base `BaseSpatialBackend` object, which is - instantiated by each spatial database backend with the features - it has. - """ - distance_functions = {} - geometry_functions = {} - geometry_operators = {} - geography_operators = {} - geography_functions = {} - gis_terms = set() - truncate_params = {} - - # 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 = None - - # Does the spatial database have a geometry or geography type? - geography = False - geometry = False - - area = False - centroid = False - difference = False - distance = False - distance_sphere = False - distance_spheroid = False - envelope = False - force_rhr = False - mem_size = False - bounding_circle = False - num_geom = False - num_points = False - perimeter = False - perimeter3d = False - point_on_surface = False - polygonize = False - reverse = False - scale = False - snap_to_grid = False - sym_difference = False - transform = False - translate = False - union = False - - # Aggregates - collect = False - extent = False - extent3d = False - make_line = False - unionagg = False - - # Serialization - geohash = False - geojson = False - gml = False - kml = False - svg = False - - # Constructors - from_text = False - from_wkb = False - - # Default conversion functions for aggregates; will be overridden if implemented - # for the spatial backend. - def convert_extent(self, box): - raise NotImplementedError('Aggregate extent not implemented for this spatial backend.') - - def convert_extent3d(self, box): - raise NotImplementedError('Aggregate 3D extent not implemented for this spatial backend.') - - def convert_geom(self, geom_val, geom_field): - raise NotImplementedError('Aggregate method 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): - """ - Returns the database column type for the geometry field on - the spatial backend. - """ - raise NotImplementedError - - def get_distance(self, f, value, lookup_type): - """ - Returns 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): - """ - Returns 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. - """ - raise NotImplementedError - - def get_expression_column(self, evaluator): - """ - Helper method to return the quoted column string from the evaluator - for its expression. - """ - for expr, col_tup in evaluator.cols: - if expr is evaluator.expression: - return '%s.%s' % tuple(map(self.quote_name, col_tup)) - raise Exception("Could not find the column for the expression.") - - # Spatial SQL Construction - def spatial_aggregate_sql(self, agg): - raise NotImplementedError('Aggregate support not implemented for this spatial backend.') - - def spatial_lookup_sql(self, lvalue, lookup_type, value, field): - raise NotImplementedError - - # Routines for getting the OGC-compliant models. - def geometry_columns(self): - raise NotImplementedError - - def spatial_ref_sys(self): - raise NotImplementedError - -@python_2_unicode_compatible -class SpatialRefSysMixin(object): - """ - The SpatialRefSysMixin is a class used by the database-dependent - SpatialRefSys objects to reduce redundnant code. - """ - # For pulling out the spheroid from the spatial reference string. This - # regular expression is used only if the user does not have GDAL installed. - # TODO: Flattening not used in all ellipsoids, could also be a minor axis, - # or 'b' parameter. - spheroid_regex = re.compile(r'.+SPHEROID\[\"(?P<name>.+)\",(?P<major>\d+(\.\d+)?),(?P<flattening>\d{3}\.\d+),') - - # For pulling out the units on platforms w/o GDAL installed. - # TODO: Figure out how to pull out angular units of projected coordinate system and - # fix for LOCAL_CS types. GDAL should be highly recommended for performing - # distance queries. - units_regex = re.compile(r'.+UNIT ?\["(?P<unit_name>[\w \'\(\)]+)", ?(?P<unit>[\d\.]+)(,AUTHORITY\["(?P<unit_auth_name>[\w \'\(\)]+)","(?P<unit_auth_val>\d+)"\])?\]([\w ]+)?(,AUTHORITY\["(?P<auth_name>[\w \'\(\)]+)","(?P<auth_val>\d+)"\])?\]$') - - @property - def srs(self): - """ - Returns a GDAL SpatialReference object, if GDAL is installed. - """ - if gdal.HAS_GDAL: - # 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 msg: - pass - - try: - self._srs = gdal.SpatialReference(self.proj4text) - return self.srs - except Exception as msg: - pass - - raise Exception('Could not get OSR SpatialReference from WKT: %s\nError:\n%s' % (self.wkt, msg)) - else: - raise Exception('GDAL is not installed.') - - @property - def ellipsoid(self): - """ - Returns a tuple of the ellipsoid parameters: - (semimajor axis, semiminor axis, and inverse flattening). - """ - if gdal.HAS_GDAL: - return self.srs.ellipsoid - else: - m = self.spheroid_regex.match(self.wkt) - if m: return (float(m.group('major')), float(m.group('flattening'))) - else: return None - - @property - def name(self): - "Returns the projection name." - return self.srs.name - - @property - def spheroid(self): - "Returns the spheroid name for this spatial reference." - return self.srs['spheroid'] - - @property - def datum(self): - "Returns the datum for this spatial reference." - return self.srs['datum'] - - @property - def projected(self): - "Is this Spatial Reference projected?" - if gdal.HAS_GDAL: - return self.srs.projected - else: - return self.wkt.startswith('PROJCS') - - @property - def local(self): - "Is this Spatial Reference local?" - if gdal.HAS_GDAL: - return self.srs.local - else: - return self.wkt.startswith('LOCAL_CS') - - @property - def geographic(self): - "Is this Spatial Reference geographic?" - if gdal.HAS_GDAL: - return self.srs.geographic - else: - return self.wkt.startswith('GEOGCS') - - @property - def linear_name(self): - "Returns the linear units name." - if gdal.HAS_GDAL: - return self.srs.linear_name - elif self.geographic: - return None - else: - m = self.units_regex.match(self.wkt) - return m.group('unit_name') - - @property - def linear_units(self): - "Returns the linear units." - if gdal.HAS_GDAL: - return self.srs.linear_units - elif self.geographic: - return None - else: - m = self.units_regex.match(self.wkt) - return m.group('unit') - - @property - def angular_name(self): - "Returns the name of the angular units." - if gdal.HAS_GDAL: - return self.srs.angular_name - elif self.projected: - return None - else: - m = self.units_regex.match(self.wkt) - return m.group('unit_name') - - @property - def angular_units(self): - "Returns the angular units." - if gdal.HAS_GDAL: - return self.srs.angular_units - elif self.projected: - return None - else: - m = self.units_regex.match(self.wkt) - return m.group('unit') - - @property - def units(self): - "Returns 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): - """ - Class method used by GeometryField on initialization to - retrive the units on the given WKT, without having to use - any of the database fields. - """ - if gdal.HAS_GDAL: - return gdal.SpatialReference(wkt).units - else: - m = cls.units_regex.match(wkt) - return m.group('unit'), m.group('unit_name') - - @classmethod - def get_spheroid(cls, wkt, string=True): - """ - Class method used by GeometryField on initialization to - retrieve the `SPHEROID[..]` parameters from the given WKT. - """ - if gdal.HAS_GDAL: - srs = gdal.SpatialReference(wkt) - sphere_params = srs.ellipsoid - sphere_name = srs['spheroid'] - else: - m = cls.spheroid_regex.match(wkt) - if m: - sphere_params = (float(m.group('major')), float(m.group('flattening'))) - sphere_name = m.group('name') - else: - return None - - 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): - """ - Returns the string representation. If GDAL is installed, - it will be 'pretty' OGC WKT. - """ - try: - return six.text_type(self.srs) - except: - return six.text_type(self.wkt) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/base.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/base.py deleted file mode 100644 index 7d94458..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/base.py +++ /dev/null @@ -1,13 +0,0 @@ -from django.db.backends.mysql.base import * -from django.db.backends.mysql.base import DatabaseWrapper as MySQLDatabaseWrapper -from django.contrib.gis.db.backends.mysql.creation import MySQLCreation -from django.contrib.gis.db.backends.mysql.introspection import MySQLIntrospection -from django.contrib.gis.db.backends.mysql.operations import MySQLOperations - -class DatabaseWrapper(MySQLDatabaseWrapper): - - def __init__(self, *args, **kwargs): - super(DatabaseWrapper, self).__init__(*args, **kwargs) - self.creation = MySQLCreation(self) - self.ops = MySQLOperations(self) - self.introspection = MySQLIntrospection(self) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/compiler.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/compiler.py deleted file mode 100644 index f4654ef..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/compiler.py +++ /dev/null @@ -1,35 +0,0 @@ -from django.contrib.gis.db.models.sql.compiler import GeoSQLCompiler as BaseGeoSQLCompiler -from django.db.backends.mysql import compiler - -SQLCompiler = compiler.SQLCompiler - -class GeoSQLCompiler(BaseGeoSQLCompiler, SQLCompiler): - def resolve_columns(self, row, fields=()): - """ - Integrate the cases handled both by the base GeoSQLCompiler and the - main MySQL compiler (converting 0/1 to True/False for boolean fields). - - Refs #15169. - - """ - row = BaseGeoSQLCompiler.resolve_columns(self, row, fields) - return SQLCompiler.resolve_columns(self, row, fields) - - -class SQLInsertCompiler(compiler.SQLInsertCompiler, GeoSQLCompiler): - pass - -class SQLDeleteCompiler(compiler.SQLDeleteCompiler, GeoSQLCompiler): - pass - -class SQLUpdateCompiler(compiler.SQLUpdateCompiler, GeoSQLCompiler): - pass - -class SQLAggregateCompiler(compiler.SQLAggregateCompiler, GeoSQLCompiler): - pass - -class SQLDateCompiler(compiler.SQLDateCompiler, GeoSQLCompiler): - pass - -class SQLDateTimeCompiler(compiler.SQLDateTimeCompiler, GeoSQLCompiler): - pass diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/creation.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/creation.py deleted file mode 100644 index dda77ea..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/creation.py +++ /dev/null @@ -1,18 +0,0 @@ -from django.db.backends.mysql.creation import DatabaseCreation - -class MySQLCreation(DatabaseCreation): - - def sql_indexes_for_field(self, model, f, style): - from django.contrib.gis.db.models.fields import GeometryField - output = super(MySQLCreation, self).sql_indexes_for_field(model, f, style) - - if isinstance(f, GeometryField) and f.spatial_index: - qn = self.connection.ops.quote_name - db_table = model._meta.db_table - idx_name = '%s_%s_id' % (db_table, f.column) - output.append(style.SQL_KEYWORD('CREATE SPATIAL INDEX ') + - style.SQL_TABLE(qn(idx_name)) + - style.SQL_KEYWORD(' ON ') + - style.SQL_TABLE(qn(db_table)) + '(' + - style.SQL_FIELD(qn(f.column)) + ');') - return output diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/introspection.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/introspection.py deleted file mode 100644 index 59d0f62..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/introspection.py +++ /dev/null @@ -1,32 +0,0 @@ -from MySQLdb.constants import FIELD_TYPE - -from django.contrib.gis.gdal import OGRGeomType -from django.db.backends.mysql.introspection import DatabaseIntrospection - -class MySQLIntrospection(DatabaseIntrospection): - # Updating the data_types_reverse dictionary with the appropriate - # type for Geometry fields. - data_types_reverse = DatabaseIntrospection.data_types_reverse.copy() - data_types_reverse[FIELD_TYPE.GEOMETRY] = 'GeometryField' - - def get_geometry_type(self, table_name, geo_col): - cursor = self.connection.cursor() - try: - # In order to get the specific geometry type of the field, - # we introspect on the table definition using `DESCRIBE`. - cursor.execute('DESCRIBE %s' % - self.connection.ops.quote_name(table_name)) - # Increment over description info until we get to the geometry - # column. - for column, typ, null, key, default, extra in cursor.fetchall(): - if column == geo_col: - # Using OGRGeomType to convert from OGC name to Django field. - # MySQL does not support 3D or SRIDs, so the field params - # are empty. - field_type = OGRGeomType(typ).django - field_params = {} - break - finally: - cursor.close() - - return field_type, field_params diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/operations.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/operations.py deleted file mode 100644 index 26cec74..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/mysql/operations.py +++ /dev/null @@ -1,67 +0,0 @@ -from django.db.backends.mysql.base import DatabaseOperations - -from django.contrib.gis.db.backends.adapter import WKTAdapter -from django.contrib.gis.db.backends.base import BaseSpatialOperations - - -class MySQLOperations(DatabaseOperations, BaseSpatialOperations): - - compiler_module = 'django.contrib.gis.db.backends.mysql.compiler' - mysql = True - name = 'mysql' - select = 'AsText(%s)' - from_wkb = 'GeomFromWKB' - from_text = 'GeomFromText' - - Adapter = WKTAdapter - Adaptor = Adapter # Backwards-compatibility alias. - - geometry_functions = { - 'bbcontains': 'MBRContains', # For consistency w/PostGIS API - 'bboverlaps': 'MBROverlaps', # .. .. - 'contained': 'MBRWithin', # .. .. - 'contains': 'MBRContains', - 'disjoint': 'MBRDisjoint', - 'equals': 'MBREqual', - 'exact': 'MBREqual', - 'intersects': 'MBRIntersects', - 'overlaps': 'MBROverlaps', - 'same_as': 'MBREqual', - 'touches': 'MBRTouches', - 'within': 'MBRWithin', - } - - gis_terms = set(geometry_functions) | set(['isnull']) - - def geo_db_type(self, f): - return f.geom_type - - def get_geom_placeholder(self, value, srid): - """ - The placeholder here has to include MySQL's WKT constructor. Because - MySQL does not support spatial transformations, there is no need to - modify the placeholder based on the contents of the given value. - """ - if hasattr(value, 'expression'): - placeholder = self.get_expression_column(value) - else: - placeholder = '%s(%%s)' % self.from_text - return placeholder - - def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn): - alias, col, db_type = lvalue - - geo_col = '%s.%s' % (qn(alias), qn(col)) - - lookup_info = self.geometry_functions.get(lookup_type, False) - if lookup_info: - sql = "%s(%s, %s)" % (lookup_info, geo_col, - self.get_geom_placeholder(value, field.srid)) - return sql, [] - - # TODO: Is this really necessary? MySQL can't handle NULL geometries - # in its spatial indexes anyways. - if lookup_type == 'isnull': - return "%s IS %sNULL" % (geo_col, ('' if value else 'NOT ')), [] - - raise TypeError("Got invalid lookup_type: %s" % repr(lookup_type)) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/adapter.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/adapter.py deleted file mode 100644 index ea340d9..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/adapter.py +++ /dev/null @@ -1,5 +0,0 @@ -from cx_Oracle import CLOB -from django.contrib.gis.db.backends.adapter import WKTAdapter - -class OracleSpatialAdapter(WKTAdapter): - input_size = CLOB diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/base.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/base.py deleted file mode 100644 index 398b3d3..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/base.py +++ /dev/null @@ -1,12 +0,0 @@ -from django.db.backends.oracle.base import * -from django.db.backends.oracle.base import DatabaseWrapper as OracleDatabaseWrapper -from django.contrib.gis.db.backends.oracle.creation import OracleCreation -from django.contrib.gis.db.backends.oracle.introspection import OracleIntrospection -from django.contrib.gis.db.backends.oracle.operations import OracleOperations - -class DatabaseWrapper(OracleDatabaseWrapper): - def __init__(self, *args, **kwargs): - super(DatabaseWrapper, self).__init__(*args, **kwargs) - self.ops = OracleOperations(self) - self.creation = OracleCreation(self) - self.introspection = OracleIntrospection(self) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/compiler.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/compiler.py deleted file mode 100644 index d00af7f..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/compiler.py +++ /dev/null @@ -1,25 +0,0 @@ -from django.contrib.gis.db.models.sql.compiler import GeoSQLCompiler as BaseGeoSQLCompiler -from django.db.backends.oracle import compiler - -SQLCompiler = compiler.SQLCompiler - -class GeoSQLCompiler(BaseGeoSQLCompiler, SQLCompiler): - pass - -class SQLInsertCompiler(compiler.SQLInsertCompiler, GeoSQLCompiler): - pass - -class SQLDeleteCompiler(compiler.SQLDeleteCompiler, GeoSQLCompiler): - pass - -class SQLUpdateCompiler(compiler.SQLUpdateCompiler, GeoSQLCompiler): - pass - -class SQLAggregateCompiler(compiler.SQLAggregateCompiler, GeoSQLCompiler): - pass - -class SQLDateCompiler(compiler.SQLDateCompiler, GeoSQLCompiler): - pass - -class SQLDateTimeCompiler(compiler.SQLDateTimeCompiler, GeoSQLCompiler): - pass diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/creation.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/creation.py deleted file mode 100644 index 043da91..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/creation.py +++ /dev/null @@ -1,42 +0,0 @@ -from django.db.backends.oracle.creation import DatabaseCreation -from django.db.backends.util import truncate_name - -class OracleCreation(DatabaseCreation): - - def sql_indexes_for_field(self, model, f, style): - "Return any spatial index creation SQL for the field." - from django.contrib.gis.db.models.fields import GeometryField - - output = super(OracleCreation, self).sql_indexes_for_field(model, f, style) - - if isinstance(f, GeometryField): - gqn = self.connection.ops.geo_quote_name - qn = self.connection.ops.quote_name - db_table = model._meta.db_table - - output.append(style.SQL_KEYWORD('INSERT INTO ') + - style.SQL_TABLE('USER_SDO_GEOM_METADATA') + - ' (%s, %s, %s, %s)\n ' % tuple(map(qn, ['TABLE_NAME', 'COLUMN_NAME', 'DIMINFO', 'SRID'])) + - style.SQL_KEYWORD(' VALUES ') + '(\n ' + - style.SQL_TABLE(gqn(db_table)) + ',\n ' + - style.SQL_FIELD(gqn(f.column)) + ',\n ' + - style.SQL_KEYWORD("MDSYS.SDO_DIM_ARRAY") + '(\n ' + - style.SQL_KEYWORD("MDSYS.SDO_DIM_ELEMENT") + - ("('LONG', %s, %s, %s),\n " % (f._extent[0], f._extent[2], f._tolerance)) + - style.SQL_KEYWORD("MDSYS.SDO_DIM_ELEMENT") + - ("('LAT', %s, %s, %s)\n ),\n" % (f._extent[1], f._extent[3], f._tolerance)) + - ' %s\n );' % f.srid) - - if f.spatial_index: - # Getting the index name, Oracle doesn't allow object - # names > 30 characters. - idx_name = truncate_name('%s_%s_id' % (db_table, f.column), 30) - - output.append(style.SQL_KEYWORD('CREATE INDEX ') + - style.SQL_TABLE(qn(idx_name)) + - style.SQL_KEYWORD(' ON ') + - style.SQL_TABLE(qn(db_table)) + '(' + - style.SQL_FIELD(qn(f.column)) + ') ' + - style.SQL_KEYWORD('INDEXTYPE IS ') + - style.SQL_TABLE('MDSYS.SPATIAL_INDEX') + ';') - return output diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/introspection.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/introspection.py deleted file mode 100644 index d6c8f45..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/introspection.py +++ /dev/null @@ -1,44 +0,0 @@ -import cx_Oracle -import sys -from django.db.backends.oracle.introspection import DatabaseIntrospection -from django.utils import six - -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): - cursor = self.connection.cursor() - try: - # 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 msg: - new_msg = ( - 'Could not find entry in USER_SDO_GEOM_METADATA ' - 'corresponding to "%s"."%s"\n' - 'Error message: %s.') % (table_name, geo_col, msg) - six.reraise(Exception, Exception(new_msg), sys.exc_info()[2]) - - # 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 - # Length of object array ( SDO_DIM_ARRAY ) is number of dimensions. - dim = len(dim) - if dim != 2: - field_params['dim'] = dim - finally: - cursor.close() - - return field_type, field_params diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/models.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/models.py deleted file mode 100644 index b7deb3a..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/models.py +++ /dev/null @@ -1,66 +0,0 @@ -""" - The GeometryColumns and SpatialRefSys models for the Oracle spatial - backend. - - It should be noted that Oracle Spatial does not have database tables - named according to the OGC standard, so the closest analogs are used. - For example, the `USER_SDO_GEOM_METADATA` is used for the GeometryColumns - model and the `SDO_COORD_REF_SYS` is used for the SpatialRefSys model. -""" -from django.contrib.gis.db import models -from django.contrib.gis.db.backends.base import SpatialRefSysMixin -from django.utils.encoding import python_2_unicode_compatible - -@python_2_unicode_compatible -class GeometryColumns(models.Model): - "Maps to the Oracle USER_SDO_GEOM_METADATA table." - table_name = models.CharField(max_length=32) - column_name = models.CharField(max_length=1024) - srid = models.IntegerField(primary_key=True) - # TODO: Add support for `diminfo` column (type MDSYS.SDO_DIM_ARRAY). - class Meta: - db_table = 'USER_SDO_GEOM_METADATA' - managed = False - - @classmethod - def table_name_col(cls): - """ - Returns the name of the metadata column used to store the - the feature table name. - """ - return 'table_name' - - @classmethod - def geom_col_name(cls): - """ - Returns the name of the metadata column used to store the - the feature geometry column. - """ - return 'column_name' - - def __str__(self): - return '%s - %s (SRID: %s)' % (self.table_name, self.column_name, self.srid) - -class SpatialRefSys(models.Model, SpatialRefSysMixin): - "Maps to the Oracle MDSYS.CS_SRS table." - cs_name = models.CharField(max_length=68) - srid = models.IntegerField(primary_key=True) - auth_srid = models.IntegerField() - auth_name = models.CharField(max_length=256) - wktext = models.CharField(max_length=2046) - # Optional geometry representing the bounds of this coordinate - # system. By default, all are NULL in the table. - cs_bounds = models.PolygonField(null=True) - objects = models.GeoManager() - - class Meta: - db_table = 'CS_SRS' - managed = False - - @property - def wkt(self): - return self.wktext - - @classmethod - def wkt_col(cls): - return 'wktext' diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/operations.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/operations.py deleted file mode 100644 index 84217c3..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/oracle/operations.py +++ /dev/null @@ -1,304 +0,0 @@ -""" - 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 decimal import Decimal - -from django.db.backends.oracle.base import DatabaseOperations -from django.contrib.gis.db.backends.base import BaseSpatialOperations -from django.contrib.gis.db.backends.oracle.adapter import OracleSpatialAdapter -from django.contrib.gis.db.backends.util import SpatialFunction -from django.contrib.gis.geometry.backend import Geometry -from django.contrib.gis.measure import Distance -from django.utils import six - - -class SDOOperation(SpatialFunction): - "Base class for SDO* Oracle operations." - sql_template = "%(function)s(%(geo_col)s, %(geometry)s) %(operator)s '%(result)s'" - - def __init__(self, func, **kwargs): - kwargs.setdefault('operator', '=') - kwargs.setdefault('result', 'TRUE') - super(SDOOperation, self).__init__(func, **kwargs) - -class SDODistance(SpatialFunction): - "Class for Distance queries." - sql_template = ('%(function)s(%(geo_col)s, %(geometry)s, %(tolerance)s) ' - '%(operator)s %(result)s') - dist_func = 'SDO_GEOM.SDO_DISTANCE' - - def __init__(self, op, tolerance=0.05): - super(SDODistance, self).__init__(self.dist_func, - tolerance=tolerance, - operator=op, result='%s') - -class SDODWithin(SpatialFunction): - dwithin_func = 'SDO_WITHIN_DISTANCE' - sql_template = "%(function)s(%(geo_col)s, %(geometry)s, %%s) = 'TRUE'" - - def __init__(self): - super(SDODWithin, self).__init__(self.dwithin_func) - -class SDOGeomRelate(SpatialFunction): - "Class for using SDO_GEOM.RELATE." - relate_func = 'SDO_GEOM.RELATE' - sql_template = ("%(function)s(%(geo_col)s, '%(mask)s', %(geometry)s, " - "%(tolerance)s) %(operator)s '%(mask)s'") - - def __init__(self, mask, tolerance=0.05): - # SDO_GEOM.RELATE(...) has a peculiar argument order: column, mask, geom, tolerance. - # Moreover, the runction result is the mask (e.g., 'DISJOINT' instead of 'TRUE'). - super(SDOGeomRelate, self).__init__(self.relate_func, operator='=', - mask=mask, tolerance=tolerance) - -class SDORelate(SpatialFunction): - "Class for using SDO_RELATE." - masks = 'TOUCH|OVERLAPBDYDISJOINT|OVERLAPBDYINTERSECT|EQUAL|INSIDE|COVEREDBY|CONTAINS|COVERS|ANYINTERACT|ON' - mask_regex = re.compile(r'^(%s)(\+(%s))*$' % (masks, masks), re.I) - sql_template = "%(function)s(%(geo_col)s, %(geometry)s, 'mask=%(mask)s') = 'TRUE'" - relate_func = 'SDO_RELATE' - - def __init__(self, mask): - if not self.mask_regex.match(mask): - raise ValueError('Invalid %s mask: "%s"' % (self.relate_func, mask)) - super(SDORelate, self).__init__(self.relate_func, mask=mask) - -# Valid distance types and substitutions -dtypes = (Decimal, Distance, float) + six.integer_types - -class OracleOperations(DatabaseOperations, BaseSpatialOperations): - compiler_module = "django.contrib.gis.db.backends.oracle.compiler" - - name = 'oracle' - oracle = True - valid_aggregates = dict([(a, None) for a in ('Union', 'Extent')]) - - Adapter = OracleSpatialAdapter - Adaptor = Adapter # Backwards-compatibility alias. - - area = 'SDO_GEOM.SDO_AREA' - gml = 'SDO_UTIL.TO_GMLGEOMETRY' - centroid = 'SDO_GEOM.SDO_CENTROID' - difference = 'SDO_GEOM.SDO_DIFFERENCE' - distance = 'SDO_GEOM.SDO_DISTANCE' - extent = 'SDO_AGGR_MBR' - intersection = 'SDO_GEOM.SDO_INTERSECTION' - length = 'SDO_GEOM.SDO_LENGTH' - num_geom = 'SDO_UTIL.GETNUMELEM' - num_points = 'SDO_UTIL.GETNUMVERTICES' - perimeter = length - point_on_surface = 'SDO_GEOM.SDO_POINTONSURFACE' - reverse = 'SDO_UTIL.REVERSE_LINESTRING' - sym_difference = 'SDO_GEOM.SDO_XOR' - transform = 'SDO_CS.TRANSFORM' - union = 'SDO_GEOM.SDO_UNION' - unionagg = 'SDO_AGGR_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_WKTGEOMETRY(%s)' - - distance_functions = { - 'distance_gt' : (SDODistance('>'), dtypes), - 'distance_gte' : (SDODistance('>='), dtypes), - 'distance_lt' : (SDODistance('<'), dtypes), - 'distance_lte' : (SDODistance('<='), dtypes), - 'dwithin' : (SDODWithin(), dtypes), - } - - geometry_functions = { - 'contains' : SDOOperation('SDO_CONTAINS'), - 'coveredby' : SDOOperation('SDO_COVEREDBY'), - 'covers' : SDOOperation('SDO_COVERS'), - 'disjoint' : SDOGeomRelate('DISJOINT'), - 'intersects' : SDOOperation('SDO_OVERLAPBDYINTERSECT'), # TODO: Is this really the same as ST_Intersects()? - 'equals' : SDOOperation('SDO_EQUAL'), - 'exact' : SDOOperation('SDO_EQUAL'), - 'overlaps' : SDOOperation('SDO_OVERLAPS'), - 'same_as' : SDOOperation('SDO_EQUAL'), - 'relate' : (SDORelate, six.string_types), # Oracle uses a different syntax, e.g., 'mask=inside+touch' - 'touches' : SDOOperation('SDO_TOUCH'), - 'within' : SDOOperation('SDO_INSIDE'), - } - geometry_functions.update(distance_functions) - - gis_terms = set(['isnull']) - gis_terms.update(geometry_functions) - - truncate_params = {'relate' : None} - - 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 = Geometry(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 convert_geom(self, clob, geo_field): - if clob: - return Geometry(clob.read(), geo_field.srid) - else: - return None - - def geo_db_type(self, f): - """ - Returns 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): - """ - Returns 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): - """ - Provides a proper substitution value for Geometries that are not in the - SRID of the field. Specifically, this routine will substitute in the - SDO_CS.TRANSFORM() function call. - """ - if value is None: - return 'NULL' - - def transform_value(val, srid): - return val.srid != srid - - if hasattr(value, 'expression'): - if transform_value(value, f.srid): - placeholder = '%s(%%s, %s)' % (self.transform, f.srid) - else: - placeholder = '%s' - # No geometry value used for F expression, substitue in - # the column name instead. - return placeholder % self.get_expression_column(value) - else: - if transform_value(value, f.srid): - return '%s(SDO_GEOMETRY(%%s, %s), %s)' % (self.transform, value.srid, f.srid) - else: - return 'SDO_GEOMETRY(%%s, %s)' % f.srid - - def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn): - "Returns the SQL WHERE clause for use in Oracle spatial SQL construction." - alias, col, db_type = lvalue - - # Getting the quoted table name as `geo_col`. - geo_col = '%s.%s' % (qn(alias), qn(col)) - - # See if a Oracle Geometry function matches the lookup type next - lookup_info = self.geometry_functions.get(lookup_type, False) - if lookup_info: - # Lookup types that are tuples take tuple arguments, e.g., 'relate' and - # 'dwithin' lookup types. - if isinstance(lookup_info, tuple): - # First element of tuple is lookup type, second element is the type - # of the expected argument (e.g., str, float) - sdo_op, arg_type = lookup_info - geom = value[0] - - # Ensuring that a tuple _value_ was passed in from the user - if not isinstance(value, tuple): - raise ValueError('Tuple required for `%s` lookup type.' % lookup_type) - if len(value) != 2: - raise ValueError('2-element tuple required for %s lookup type.' % lookup_type) - - # Ensuring the argument type matches what we expect. - if not isinstance(value[1], arg_type): - raise ValueError('Argument type should be %s, got %s instead.' % (arg_type, type(value[1]))) - - if lookup_type == 'relate': - # The SDORelate class handles construction for these queries, - # and verifies the mask argument. - return sdo_op(value[1]).as_sql(geo_col, self.get_geom_placeholder(field, geom)) - else: - # Otherwise, just call the `as_sql` method on the SDOOperation instance. - return sdo_op.as_sql(geo_col, self.get_geom_placeholder(field, geom)) - else: - # Lookup info is a SDOOperation instance, whose `as_sql` method returns - # the SQL necessary for the geometry function call. For example: - # SDO_CONTAINS("geoapp_country"."poly", SDO_GEOMTRY('POINT(5 23)', 4326)) = 'TRUE' - return lookup_info.as_sql(geo_col, self.get_geom_placeholder(field, value)) - elif lookup_type == 'isnull': - # Handling 'isnull' lookup type - return "%s IS %sNULL" % (geo_col, ('' if value else 'NOT ')), [] - - raise TypeError("Got invalid lookup_type: %s" % repr(lookup_type)) - - def spatial_aggregate_sql(self, agg): - """ - Returns the spatial aggregate SQL template and function for the - given Aggregate instance. - """ - agg_name = agg.__class__.__name__.lower() - if agg_name == 'union': - agg_name += 'agg' - if agg.is_extent: - sql_template = '%(function)s(%(field)s)' - else: - sql_template = '%(function)s(SDOAGGRTYPE(%(field)s,%(tolerance)s))' - sql_function = getattr(self, agg_name) - return self.select % sql_template, sql_function - - # Routines for getting the OGC-compliant models. - def geometry_columns(self): - from django.contrib.gis.db.backends.oracle.models import GeometryColumns - return GeometryColumns - - def spatial_ref_sys(self): - from django.contrib.gis.db.backends.oracle.models import SpatialRefSys - return SpatialRefSys - - def modify_insert_params(self, placeholders, params): - """Drop out insert parameters for NULL placeholder. Needed for Oracle Spatial - backend due to #10888 - """ - # This code doesn't work for bulk insert cases. - assert len(placeholders) == 1 - return [[param for pholder, param - in six.moves.zip(placeholders[0], params[0]) if pholder != 'NULL'], ] diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/adapter.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/adapter.py deleted file mode 100644 index 8bb514d..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/adapter.py +++ /dev/null @@ -1,46 +0,0 @@ -""" - This object provides quoting for GEOS geometries into PostgreSQL/PostGIS. -""" -from __future__ import unicode_literals - -from psycopg2 import Binary -from psycopg2.extensions import ISQLQuote - -class PostGISAdapter(object): - def __init__(self, geom): - "Initializes on the geometry." - # Getting the WKB (in string form, to allow easy pickling of - # the adaptor) and the SRID from the geometry. - self.ewkb = bytes(geom.ewkb) - self.srid = geom.srid - self._adapter = Binary(self.ewkb) - - 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): - if not isinstance(other, PostGISAdapter): - return False - return (self.ewkb == other.ewkb) and (self.srid == other.srid) - - 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. - """ - self._adapter.prepare(conn) - - def getquoted(self): - "Returns a properly quoted string for use in PostgreSQL/PostGIS." - # psycopg will figure out whether to use E'\\000' or '\000' - return str('ST_GeomFromEWKB(%s)' % self._adapter.getquoted().decode()) - - def prepare_database_save(self, unused): - return self diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/base.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/base.py deleted file mode 100644 index 634a7d5..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/base.py +++ /dev/null @@ -1,12 +0,0 @@ -from django.db.backends.postgresql_psycopg2.base import * -from django.db.backends.postgresql_psycopg2.base import DatabaseWrapper as Psycopg2DatabaseWrapper -from django.contrib.gis.db.backends.postgis.creation import PostGISCreation -from django.contrib.gis.db.backends.postgis.introspection import PostGISIntrospection -from django.contrib.gis.db.backends.postgis.operations import PostGISOperations - -class DatabaseWrapper(Psycopg2DatabaseWrapper): - def __init__(self, *args, **kwargs): - super(DatabaseWrapper, self).__init__(*args, **kwargs) - self.creation = PostGISCreation(self) - self.ops = PostGISOperations(self) - self.introspection = PostGISIntrospection(self) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/creation.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/creation.py deleted file mode 100644 index 4f64ecc..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/creation.py +++ /dev/null @@ -1,95 +0,0 @@ -from django.conf import settings -from django.db.backends.postgresql_psycopg2.creation import DatabaseCreation -from django.utils.functional import cached_property - - -class PostGISCreation(DatabaseCreation): - geom_index_type = 'GIST' - geom_index_ops = 'GIST_GEOMETRY_OPS' - geom_index_ops_nd = 'GIST_GEOMETRY_OPS_ND' - - @cached_property - def template_postgis(self): - template_postgis = getattr(settings, 'POSTGIS_TEMPLATE', 'template_postgis') - cursor = self.connection.cursor() - cursor.execute('SELECT 1 FROM pg_database WHERE datname = %s LIMIT 1;', (template_postgis,)) - if cursor.fetchone(): - return template_postgis - return None - - def sql_indexes_for_field(self, model, f, style): - "Return any spatial index creation SQL for the field." - from django.contrib.gis.db.models.fields import GeometryField - - output = super(PostGISCreation, self).sql_indexes_for_field(model, f, style) - - if isinstance(f, GeometryField): - gqn = self.connection.ops.geo_quote_name - qn = self.connection.ops.quote_name - db_table = model._meta.db_table - - if f.geography or self.connection.ops.geometry: - # Geography and Geometry (PostGIS 2.0+) columns are - # created normally. - pass - else: - # Geometry columns are created by `AddGeometryColumn` - # stored procedure. - output.append(style.SQL_KEYWORD('SELECT ') + - style.SQL_TABLE('AddGeometryColumn') + '(' + - style.SQL_TABLE(gqn(db_table)) + ', ' + - style.SQL_FIELD(gqn(f.column)) + ', ' + - style.SQL_FIELD(str(f.srid)) + ', ' + - style.SQL_COLTYPE(gqn(f.geom_type)) + ', ' + - style.SQL_KEYWORD(str(f.dim)) + ');') - - if not f.null: - # Add a NOT NULL constraint to the field - output.append(style.SQL_KEYWORD('ALTER TABLE ') + - style.SQL_TABLE(qn(db_table)) + - style.SQL_KEYWORD(' ALTER ') + - style.SQL_FIELD(qn(f.column)) + - style.SQL_KEYWORD(' SET NOT NULL') + ';') - - if f.spatial_index: - # Spatial indexes created the same way for both Geometry and - # Geography columns. - # PostGIS 2.0 does not support GIST_GEOMETRY_OPS. So, on 1.5 - # we use GIST_GEOMETRY_OPS, on 2.0 we use either "nd" ops - # which are fast on multidimensional cases, or just plain - # gist index for the 2d case. - if f.geography: - index_ops = '' - elif self.connection.ops.geometry: - if f.dim > 2: - index_ops = ' ' + style.SQL_KEYWORD(self.geom_index_ops_nd) - else: - index_ops = '' - else: - index_ops = ' ' + style.SQL_KEYWORD(self.geom_index_ops) - output.append(style.SQL_KEYWORD('CREATE INDEX ') + - style.SQL_TABLE(qn('%s_%s_id' % (db_table, f.column))) + - style.SQL_KEYWORD(' ON ') + - style.SQL_TABLE(qn(db_table)) + - style.SQL_KEYWORD(' USING ') + - style.SQL_COLTYPE(self.geom_index_type) + ' ( ' + - style.SQL_FIELD(qn(f.column)) + index_ops + ' );') - return output - - def sql_table_creation_suffix(self): - if self.template_postgis is not None: - return ' TEMPLATE %s' % ( - self.connection.ops.quote_name(self.template_postgis),) - return '' - - def _create_test_db(self, verbosity, autoclobber): - test_database_name = super(PostGISCreation, self)._create_test_db(verbosity, autoclobber) - if self.template_postgis is None: - # Connect to the test database in order to create the postgis extension - self.connection.close() - self.connection.settings_dict["NAME"] = test_database_name - cursor = self.connection.cursor() - cursor.execute("CREATE EXTENSION postgis") - cursor.connection.commit() - - return test_database_name diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/introspection.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/introspection.py deleted file mode 100644 index 7df09d0..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/introspection.py +++ /dev/null @@ -1,103 +0,0 @@ -from django.db.backends.postgresql_psycopg2.introspection import DatabaseIntrospection -from django.contrib.gis.gdal import OGRGeomType - -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): - """ - Returns a dictionary with keys that are the PostgreSQL object - identification integers for the PostGIS geometry and/or - geography types (if supported). - """ - cursor = self.connection.cursor() - # 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' - try: - cursor.execute(oid_sql, ('geometry',)) - GEOM_TYPE = cursor.fetchone()[0] - postgis_types = { GEOM_TYPE : 'GeometryField' } - if self.connection.ops.geography: - cursor.execute(oid_sql, ('geography',)) - GEOG_TYPE = cursor.fetchone()[0] - # The value for the geography type is actually a tuple - # to pass in the `geography=True` keyword to the field - # definition. - postgis_types[GEOG_TYPE] = ('GeometryField', {'geography' : True}) - finally: - cursor.close() - - 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 - # intialization, 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(PostGISIntrospection, self).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, - """ - cursor = self.connection.cursor() - try: - 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: - if self.connection.ops.geography: - 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 - finally: - cursor.close() - - return field_type, field_params diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/models.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/models.py deleted file mode 100644 index e805259..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/models.py +++ /dev/null @@ -1,68 +0,0 @@ -""" - The GeometryColumns and SpatialRefSys models for the PostGIS backend. -""" -from django.db import models -from django.contrib.gis.db.backends.base import SpatialRefSysMixin -from django.utils.encoding import python_2_unicode_compatible - -@python_2_unicode_compatible -class GeometryColumns(models.Model): - """ - The 'geometry_columns' table from the PostGIS. See the PostGIS - documentation at Ch. 4.2.2. - """ - f_table_catalog = models.CharField(max_length=256) - f_table_schema = models.CharField(max_length=256) - f_table_name = models.CharField(max_length=256) - f_geometry_column = models.CharField(max_length=256) - coord_dimension = models.IntegerField() - srid = models.IntegerField(primary_key=True) - type = models.CharField(max_length=30) - - class Meta: - db_table = 'geometry_columns' - managed = False - - @classmethod - def table_name_col(cls): - """ - Returns the name of the metadata column used to store the - the feature table name. - """ - return 'f_table_name' - - @classmethod - def geom_col_name(cls): - """ - Returns the name of the metadata column used to store the - the feature geometry column. - """ - return 'f_geometry_column' - - def __str__(self): - return "%s.%s - %dD %s field (SRID: %d)" % \ - (self.f_table_name, self.f_geometry_column, - self.coord_dimension, self.type, self.srid) - -class SpatialRefSys(models.Model, SpatialRefSysMixin): - """ - The 'spatial_ref_sys' table from PostGIS. See the PostGIS - documentaiton at Ch. 4.2.1. - """ - srid = models.IntegerField(primary_key=True) - auth_name = models.CharField(max_length=256) - auth_srid = models.IntegerField() - srtext = models.CharField(max_length=2048) - proj4text = models.CharField(max_length=2048) - - class Meta: - db_table = 'spatial_ref_sys' - managed = False - - @property - def wkt(self): - return self.srtext - - @classmethod - def wkt_col(cls): - return 'srtext' diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/operations.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/operations.py deleted file mode 100644 index 84dbda3..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/postgis/operations.py +++ /dev/null @@ -1,569 +0,0 @@ -import re -from decimal import Decimal - -from django.conf import settings -from django.contrib.gis.db.backends.base import BaseSpatialOperations -from django.contrib.gis.db.backends.util import SpatialOperation, SpatialFunction -from django.contrib.gis.db.backends.postgis.adapter import PostGISAdapter -from django.contrib.gis.geometry.backend import Geometry -from django.contrib.gis.measure import Distance -from django.core.exceptions import ImproperlyConfigured -from django.db.backends.postgresql_psycopg2.base import DatabaseOperations -from django.db.utils import DatabaseError -from django.utils import six -from django.utils.functional import cached_property - -from .models import GeometryColumns, SpatialRefSys - - -#### Classes used in constructing PostGIS spatial SQL #### -class PostGISOperator(SpatialOperation): - "For PostGIS operators (e.g. `&&`, `~`)." - def __init__(self, operator): - super(PostGISOperator, self).__init__(operator=operator) - -class PostGISFunction(SpatialFunction): - "For PostGIS function calls (e.g., `ST_Contains(table, geom)`)." - def __init__(self, prefix, function, **kwargs): - super(PostGISFunction, self).__init__(prefix + function, **kwargs) - -class PostGISFunctionParam(PostGISFunction): - "For PostGIS functions that take another parameter (e.g. DWithin, Relate)." - sql_template = '%(function)s(%(geo_col)s, %(geometry)s, %%s)' - -class PostGISDistance(PostGISFunction): - "For PostGIS distance operations." - dist_func = 'Distance' - sql_template = '%(function)s(%(geo_col)s, %(geometry)s) %(operator)s %%s' - - def __init__(self, prefix, operator): - super(PostGISDistance, self).__init__(prefix, self.dist_func, - operator=operator) - -class PostGISSpheroidDistance(PostGISFunction): - "For PostGIS spherical distance operations (using the spheroid)." - dist_func = 'distance_spheroid' - sql_template = '%(function)s(%(geo_col)s, %(geometry)s, %%s) %(operator)s %%s' - def __init__(self, prefix, operator): - # An extra parameter in `end_subst` is needed for the spheroid string. - super(PostGISSpheroidDistance, self).__init__(prefix, self.dist_func, - operator=operator) - -class PostGISSphereDistance(PostGISDistance): - "For PostGIS spherical distance operations." - dist_func = 'distance_sphere' - -class PostGISRelate(PostGISFunctionParam): - "For PostGIS Relate(<geom>, <pattern>) calls." - pattern_regex = re.compile(r'^[012TF\*]{9}$') - def __init__(self, prefix, pattern): - if not self.pattern_regex.match(pattern): - raise ValueError('Invalid intersection matrix pattern "%s".' % pattern) - super(PostGISRelate, self).__init__(prefix, 'Relate') - - -class PostGISOperations(DatabaseOperations, BaseSpatialOperations): - compiler_module = 'django.contrib.gis.db.models.sql.compiler' - name = 'postgis' - postgis = True - geom_func_prefix = 'ST_' - version_regex = re.compile(r'^(?P<major>\d)\.(?P<minor1>\d)\.(?P<minor2>\d+)') - valid_aggregates = dict([(k, None) for k in - ('Collect', 'Extent', 'Extent3D', 'MakeLine', 'Union')]) - - Adapter = PostGISAdapter - Adaptor = Adapter # Backwards-compatibility alias. - - def __init__(self, connection): - super(PostGISOperations, self).__init__(connection) - - prefix = self.geom_func_prefix - # PostGIS-specific operators. The commented descriptions of these - # operators come from Section 7.6 of the PostGIS 1.4 documentation. - self.geometry_operators = { - # The "&<" operator returns true if A's bounding box overlaps or - # is to the left of B's bounding box. - 'overlaps_left' : PostGISOperator('&<'), - # The "&>" operator returns true if A's bounding box overlaps or - # is to the right of B's bounding box. - 'overlaps_right' : PostGISOperator('&>'), - # The "<<" operator returns true if A's bounding box is strictly - # to the left of B's bounding box. - 'left' : PostGISOperator('<<'), - # The ">>" operator returns true if A's bounding box is strictly - # to the right of B's bounding box. - 'right' : PostGISOperator('>>'), - # The "&<|" operator returns true if A's bounding box overlaps or - # is below B's bounding box. - 'overlaps_below' : PostGISOperator('&<|'), - # The "|&>" operator returns true if A's bounding box overlaps or - # is above B's bounding box. - 'overlaps_above' : PostGISOperator('|&>'), - # The "<<|" operator returns true if A's bounding box is strictly - # below B's bounding box. - 'strictly_below' : PostGISOperator('<<|'), - # The "|>>" operator returns true if A's bounding box is strictly - # above B's bounding box. - 'strictly_above' : PostGISOperator('|>>'), - # The "~=" operator is the "same as" operator. It tests actual - # geometric equality of two features. So if A and B are the same feature, - # vertex-by-vertex, the operator returns true. - 'same_as' : PostGISOperator('~='), - 'exact' : PostGISOperator('~='), - # The "@" operator returns true if A's bounding box is completely contained - # by B's bounding box. - 'contained' : PostGISOperator('@'), - # The "~" operator returns true if A's bounding box completely contains - # by B's bounding box. - 'bbcontains' : PostGISOperator('~'), - # The "&&" operator returns true if A's bounding box overlaps - # B's bounding box. - 'bboverlaps' : PostGISOperator('&&'), - } - - self.geometry_functions = { - 'equals' : PostGISFunction(prefix, 'Equals'), - 'disjoint' : PostGISFunction(prefix, 'Disjoint'), - 'touches' : PostGISFunction(prefix, 'Touches'), - 'crosses' : PostGISFunction(prefix, 'Crosses'), - 'within' : PostGISFunction(prefix, 'Within'), - 'overlaps' : PostGISFunction(prefix, 'Overlaps'), - 'contains' : PostGISFunction(prefix, 'Contains'), - 'intersects' : PostGISFunction(prefix, 'Intersects'), - 'relate' : (PostGISRelate, six.string_types), - 'coveredby' : PostGISFunction(prefix, 'CoveredBy'), - 'covers' : PostGISFunction(prefix, 'Covers'), - } - - # Valid distance types and substitutions - dtypes = (Decimal, Distance, float) + six.integer_types - def get_dist_ops(operator): - "Returns operations for both regular and spherical distances." - return {'cartesian' : PostGISDistance(prefix, operator), - 'sphere' : PostGISSphereDistance(prefix, operator), - 'spheroid' : PostGISSpheroidDistance(prefix, operator), - } - self.distance_functions = { - 'distance_gt' : (get_dist_ops('>'), dtypes), - 'distance_gte' : (get_dist_ops('>='), dtypes), - 'distance_lt' : (get_dist_ops('<'), dtypes), - 'distance_lte' : (get_dist_ops('<='), dtypes), - 'dwithin' : (PostGISFunctionParam(prefix, 'DWithin'), dtypes) - } - - # Adding the distance functions to the geometries lookup. - self.geometry_functions.update(self.distance_functions) - - # Only PostGIS versions 1.3.4+ have GeoJSON serialization support. - if self.spatial_version < (1, 3, 4): - GEOJSON = False - else: - GEOJSON = prefix + 'AsGeoJson' - - # ST_ContainsProperly ST_MakeLine, and ST_GeoHash added in 1.4. - if self.spatial_version >= (1, 4, 0): - GEOHASH = 'ST_GeoHash' - BOUNDINGCIRCLE = 'ST_MinimumBoundingCircle' - self.geometry_functions['contains_properly'] = PostGISFunction(prefix, 'ContainsProperly') - else: - GEOHASH, BOUNDINGCIRCLE = False, False - - # Geography type support added in 1.5. - if self.spatial_version >= (1, 5, 0): - self.geography = True - # Only a subset of the operators and functions are available - # for the geography type. - self.geography_functions = self.distance_functions.copy() - self.geography_functions.update({ - 'coveredby': self.geometry_functions['coveredby'], - 'covers': self.geometry_functions['covers'], - 'intersects': self.geometry_functions['intersects'], - }) - self.geography_operators = { - 'bboverlaps': PostGISOperator('&&'), - } - - # Native geometry type support added in PostGIS 2.0. - if self.spatial_version >= (2, 0, 0): - self.geometry = True - - # Creating a dictionary lookup of all GIS terms for PostGIS. - self.gis_terms = set(['isnull']) - self.gis_terms.update(self.geometry_operators) - self.gis_terms.update(self.geometry_functions) - - self.area = prefix + 'Area' - self.bounding_circle = BOUNDINGCIRCLE - self.centroid = prefix + 'Centroid' - self.collect = prefix + 'Collect' - self.difference = prefix + 'Difference' - self.distance = prefix + 'Distance' - self.distance_sphere = prefix + 'distance_sphere' - self.distance_spheroid = prefix + 'distance_spheroid' - self.envelope = prefix + 'Envelope' - self.extent = prefix + 'Extent' - self.force_rhr = prefix + 'ForceRHR' - self.geohash = GEOHASH - self.geojson = GEOJSON - self.gml = prefix + 'AsGML' - self.intersection = prefix + 'Intersection' - self.kml = prefix + 'AsKML' - self.length = prefix + 'Length' - self.length_spheroid = prefix + 'length_spheroid' - self.makeline = prefix + 'MakeLine' - self.mem_size = prefix + 'mem_size' - self.num_geom = prefix + 'NumGeometries' - self.num_points = prefix + 'npoints' - self.perimeter = prefix + 'Perimeter' - self.point_on_surface = prefix + 'PointOnSurface' - self.polygonize = prefix + 'Polygonize' - self.reverse = prefix + 'Reverse' - self.scale = prefix + 'Scale' - self.snap_to_grid = prefix + 'SnapToGrid' - self.svg = prefix + 'AsSVG' - self.sym_difference = prefix + 'SymDifference' - self.transform = prefix + 'Transform' - self.translate = prefix + 'Translate' - self.union = prefix + 'Union' - self.unionagg = prefix + 'Union' - - if self.spatial_version >= (2, 0, 0): - self.extent3d = prefix + '3DExtent' - self.length3d = prefix + '3DLength' - self.perimeter3d = prefix + '3DPerimeter' - else: - self.extent3d = prefix + 'Extent3D' - self.length3d = prefix + 'Length3D' - self.perimeter3d = prefix + 'Perimeter3D' - - @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: - try: - vtup = self.postgis_version_tuple() - except DatabaseError: - raise ImproperlyConfigured( - 'Cannot determine PostGIS version for database "%s". ' - 'GeoDjango requires at least PostGIS version 1.3. ' - 'Was the database created from a spatial database ' - 'template?' % self.connection.settings_dict['NAME'] - ) - version = vtup[1:] - return version - - def check_aggregate_support(self, aggregate): - """ - Checks if the given aggregate name is supported (that is, if it's - in `self.valid_aggregates`). - """ - agg_name = aggregate.__class__.__name__ - return agg_name in self.valid_aggregates - - def convert_extent(self, box): - """ - Returns 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)". - """ - 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): - """ - Returns a 6-tuple extent for the `Extent3D` aggregate by converting - the 3d bounding-box text returnded by PostGIS (`box3d` argument), for - example: "BOX3D(-90.0 30.0 1, -85.0 40.0 2)". - """ - 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 convert_geom(self, hex, geo_field): - """ - Converts the geometry returned from PostGIS aggretates. - """ - if hex: - return Geometry(hex) - else: - return None - - def geo_db_type(self, f): - """ - Return the database field type for the given geometry field. - Typically this is `None` because geometry columns are added via - the `AddGeometryColumn` stored procedure, unless the field - has been specified to be of geography type instead. - """ - if f.geography: - if not self.geography: - raise NotImplementedError('PostGIS 1.5 required for geography column support.') - - if f.srid != 4326: - raise NotImplementedError('PostGIS 1.5 supports geography columns ' - 'only with an SRID of 4326.') - - return 'geography(%s,%d)' % (f.geom_type, f.srid) - elif self.geometry: - # Postgis 2.0 supports type-based geometries. - # TODO: Support 'M' extension. - if f.dim == 3: - geom_type = f.geom_type + 'Z' - else: - geom_type = f.geom_type - return 'geometry(%s,%d)' % (geom_type, f.srid) - else: - return None - - 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 newly introduced geography column type introudced in PostGIS 1.5. - """ - # Getting the distance parameter and any options. - if len(dist_val) == 1: - value, option = dist_val[0], None - else: - value, option = dist_val - - # Shorthand boolean flags. - geodetic = f.geodetic(self.connection) - geography = f.geography and self.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 - - if (not geography and geodetic and lookup_type != 'dwithin' - and option == 'spheroid'): - # using distance_spheroid requires the spheroid of the field as - # a parameter. - return [f._spheroid, dist_param] - else: - return [dist_param] - - def get_geom_placeholder(self, f, value): - """ - Provides a proper substitution value for Geometries that are not in the - SRID of the field. Specifically, this routine will substitute in the - ST_Transform() function call. - """ - if value is None or value.srid == f.srid: - placeholder = '%s' - else: - # Adding Transform() to the SQL placeholder. - placeholder = '%s(%%s, %s)' % (self.transform, f.srid) - - if hasattr(value, 'expression'): - # If this is an F expression, then we don't really want - # a placeholder and instead substitute in the column - # of the expression. - placeholder = placeholder % self.get_expression_column(value) - - 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): - "Returns the version of the GEOS library used with PostGIS." - return self._get_postgis_func('postgis_geos_version') - - def postgis_lib_version(self): - "Returns the version number of the PostGIS library used with PostgreSQL." - return self._get_postgis_func('postgis_lib_version') - - def postgis_proj_version(self): - "Returns the version of the PROJ.4 library used with PostGIS." - return self._get_postgis_func('postgis_proj_version') - - def postgis_version(self): - "Returns PostGIS version number and compile-time options." - return self._get_postgis_func('postgis_version') - - def postgis_full_version(self): - "Returns PostGIS version number and compile-time options." - return self._get_postgis_func('postgis_full_version') - - def postgis_version_tuple(self): - """ - Returns the PostGIS version as a tuple (version string, major, - minor, subminor). - """ - # Getting the PostGIS version - version = self.postgis_lib_version() - m = self.version_regex.match(version) - - if m: - major = int(m.group('major')) - minor1 = int(m.group('minor1')) - minor2 = int(m.group('minor2')) - else: - raise Exception('Could not parse PostGIS version string: %s' % version) - - return (version, major, minor1, minor2) - - 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 num_params(self, lookup_type, num_param): - """ - Helper routine that returns a boolean indicating whether the number of - parameters is correct for the lookup type. - """ - def exactly_two(np): return np == 2 - def two_to_three(np): return np >= 2 and np <=3 - if (lookup_type in self.distance_functions and - lookup_type != 'dwithin'): - return two_to_three(num_param) - else: - return exactly_two(num_param) - - def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn): - """ - Constructs spatial SQL from the given lookup value tuple a - (alias, col, db_type), the lookup type string, lookup value, and - the geometry field. - """ - alias, col, db_type = lvalue - - # Getting the quoted geometry column. - geo_col = '%s.%s' % (qn(alias), qn(col)) - - if lookup_type in self.geometry_operators: - if field.geography and not lookup_type in self.geography_operators: - raise ValueError('PostGIS geography does not support the ' - '"%s" lookup.' % lookup_type) - # Handling a PostGIS operator. - op = self.geometry_operators[lookup_type] - return op.as_sql(geo_col, self.get_geom_placeholder(field, value)) - elif lookup_type in self.geometry_functions: - if field.geography and not lookup_type in self.geography_functions: - raise ValueError('PostGIS geography type does not support the ' - '"%s" lookup.' % lookup_type) - - # See if a PostGIS geometry function matches the lookup type. - tmp = self.geometry_functions[lookup_type] - - # Lookup types that are tuples take tuple arguments, e.g., 'relate' and - # distance lookups. - if isinstance(tmp, tuple): - # First element of tuple is the PostGISOperation instance, and the - # second element is either the type or a tuple of acceptable types - # that may passed in as further parameters for the lookup type. - op, arg_type = tmp - - # Ensuring that a tuple _value_ was passed in from the user - if not isinstance(value, (tuple, list)): - raise ValueError('Tuple required for `%s` lookup type.' % lookup_type) - - # Geometry is first element of lookup tuple. - geom = value[0] - - # Number of valid tuple parameters depends on the lookup type. - nparams = len(value) - if not self.num_params(lookup_type, nparams): - raise ValueError('Incorrect number of parameters given for `%s` lookup type.' % lookup_type) - - # Ensuring the argument type matches what we expect. - if not isinstance(value[1], arg_type): - raise ValueError('Argument type should be %s, got %s instead.' % (arg_type, type(value[1]))) - - # For lookup type `relate`, the op instance is not yet created (has - # to be instantiated here to check the pattern parameter). - if lookup_type == 'relate': - op = op(self.geom_func_prefix, value[1]) - elif lookup_type in self.distance_functions and lookup_type != 'dwithin': - if not field.geography and field.geodetic(self.connection): - # Geodetic distances are only available from Points to - # PointFields on PostGIS 1.4 and below. - if not self.connection.ops.geography: - if field.geom_type != 'POINT': - raise ValueError('PostGIS spherical operations are only valid on PointFields.') - - if str(geom.geom_type) != 'Point': - raise ValueError('PostGIS geometry distance parameter is required to be of type Point.') - - # Setting up the geodetic operation appropriately. - if nparams == 3 and value[2] == 'spheroid': - op = op['spheroid'] - else: - op = op['sphere'] - else: - op = op['cartesian'] - else: - op = tmp - geom = value - - # Calling the `as_sql` function on the operation instance. - return op.as_sql(geo_col, self.get_geom_placeholder(field, geom)) - - elif lookup_type == 'isnull': - # Handling 'isnull' lookup type - return "%s IS %sNULL" % (geo_col, ('' if value else 'NOT ')), [] - - raise TypeError("Got invalid lookup_type: %s" % repr(lookup_type)) - - def spatial_aggregate_sql(self, agg): - """ - Returns the spatial aggregate SQL template and function for the - given Aggregate instance. - """ - agg_name = agg.__class__.__name__ - if not self.check_aggregate_support(agg): - raise NotImplementedError('%s spatial aggregate is not implmented for this backend.' % agg_name) - agg_name = agg_name.lower() - if agg_name == 'union': - agg_name += 'agg' - sql_template = '%(function)s(%(field)s)' - sql_function = getattr(self, agg_name) - return sql_template, sql_function - - # Routines for getting the OGC-compliant models. - def geometry_columns(self): - return GeometryColumns - - def spatial_ref_sys(self): - return SpatialRefSys diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/adapter.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/adapter.py deleted file mode 100644 index d8fefba..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/adapter.py +++ /dev/null @@ -1,8 +0,0 @@ -from django.db.backends.sqlite3.base import Database -from django.contrib.gis.db.backends.adapter import WKTAdapter - -class SpatiaLiteAdapter(WKTAdapter): - "SQLite adaptor for geometry objects." - def __conform__(self, protocol): - if protocol is Database.PrepareProtocol: - return str(self) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/base.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/base.py deleted file mode 100644 index 7b49d71..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/base.py +++ /dev/null @@ -1,60 +0,0 @@ -import sys -from ctypes.util import find_library -from django.conf import settings - -from django.core.exceptions import ImproperlyConfigured -from django.db.backends.sqlite3.base import (Database, - DatabaseWrapper as SQLiteDatabaseWrapper, SQLiteCursorWrapper) -from django.contrib.gis.db.backends.spatialite.client import SpatiaLiteClient -from django.contrib.gis.db.backends.spatialite.creation import SpatiaLiteCreation -from django.contrib.gis.db.backends.spatialite.introspection import SpatiaLiteIntrospection -from django.contrib.gis.db.backends.spatialite.operations import SpatiaLiteOperations -from django.utils import six - -class DatabaseWrapper(SQLiteDatabaseWrapper): - def __init__(self, *args, **kwargs): - # Before we get too far, make sure pysqlite 2.5+ is installed. - if Database.version_info < (2, 5, 0): - raise ImproperlyConfigured('Only versions of pysqlite 2.5+ are ' - 'compatible with SpatiaLite and GeoDjango.') - - # Trying to find the location of the SpatiaLite library. - # Here we are figuring out the path to the SpatiaLite library - # (`libspatialite`). If it's not in the system library path (e.g., it - # cannot be found by `ctypes.util.find_library`), then it may be set - # manually in the settings via the `SPATIALITE_LIBRARY_PATH` setting. - self.spatialite_lib = getattr(settings, 'SPATIALITE_LIBRARY_PATH', - find_library('spatialite')) - if not self.spatialite_lib: - raise ImproperlyConfigured('Unable to locate the SpatiaLite library. ' - 'Make sure it is in your library path, or set ' - 'SPATIALITE_LIBRARY_PATH in your settings.' - ) - super(DatabaseWrapper, self).__init__(*args, **kwargs) - self.ops = SpatiaLiteOperations(self) - self.client = SpatiaLiteClient(self) - self.creation = SpatiaLiteCreation(self) - self.introspection = SpatiaLiteIntrospection(self) - - def get_new_connection(self, conn_params): - conn = super(DatabaseWrapper, self).get_new_connection(conn_params) - # Enabling extension loading on the SQLite connection. - try: - conn.enable_load_extension(True) - except AttributeError: - raise ImproperlyConfigured( - 'The pysqlite library does not support C extension loading. ' - 'Both SQLite and pysqlite must be configured to allow ' - 'the loading of extensions to use SpatiaLite.') - # Loading the SpatiaLite library extension on the connection, and returning - # the created cursor. - cur = conn.cursor(factory=SQLiteCursorWrapper) - try: - cur.execute("SELECT load_extension(%s)", (self.spatialite_lib,)) - except Exception as msg: - new_msg = ( - 'Unable to load the SpatiaLite library extension ' - '"%s" because: %s') % (self.spatialite_lib, msg) - six.reraise(ImproperlyConfigured, ImproperlyConfigured(new_msg), sys.exc_info()[2]) - cur.close() - return conn diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/client.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/client.py deleted file mode 100644 index 536065a..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/client.py +++ /dev/null @@ -1,5 +0,0 @@ -from django.db.backends.sqlite3.client import DatabaseClient - -class SpatiaLiteClient(DatabaseClient): - executable_name = 'spatialite' - diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/creation.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/creation.py deleted file mode 100644 index d0a5f82..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/creation.py +++ /dev/null @@ -1,129 +0,0 @@ -import os -from django.conf import settings -from django.core.cache import get_cache -from django.core.cache.backends.db import BaseDatabaseCache -from django.core.exceptions import ImproperlyConfigured -from django.db.backends.sqlite3.creation import DatabaseCreation - -class SpatiaLiteCreation(DatabaseCreation): - - def create_test_db(self, verbosity=1, autoclobber=False): - """ - Creates a test database, prompting the user for confirmation if the - database already exists. Returns the name of the test database created. - - This method is overloaded to load up the SpatiaLite initialization - SQL prior to calling the `syncdb` command. - """ - # Don't import django.core.management if it isn't needed. - from django.core.management import call_command - - test_database_name = self._get_test_db_name() - - if verbosity >= 1: - test_db_repr = '' - if verbosity >= 2: - test_db_repr = " ('%s')" % test_database_name - print("Creating test database for alias '%s'%s..." % (self.connection.alias, test_db_repr)) - - self._create_test_db(verbosity, autoclobber) - - self.connection.close() - self.connection.settings_dict["NAME"] = test_database_name - - # Need to load the SpatiaLite initialization SQL before running `syncdb`. - self.load_spatialite_sql() - - # Report syncdb messages at one level lower than that requested. - # This ensures we don't get flooded with messages during testing - # (unless you really ask to be flooded) - call_command('syncdb', - verbosity=max(verbosity - 1, 0), - interactive=False, - database=self.connection.alias, - load_initial_data=False) - - # We need to then do a flush to ensure that any data installed by - # custom SQL has been removed. The only test data should come from - # test fixtures, or autogenerated from post_syncdb triggers. - # This has the side effect of loading initial data (which was - # intentionally skipped in the syncdb). - call_command('flush', - verbosity=max(verbosity - 1, 0), - interactive=False, - database=self.connection.alias) - - from django.core.cache import get_cache - from django.core.cache.backends.db import BaseDatabaseCache - for cache_alias in settings.CACHES: - cache = get_cache(cache_alias) - if isinstance(cache, BaseDatabaseCache): - call_command('createcachetable', cache._table, database=self.connection.alias) - - # Get a cursor (even though we don't need one yet). This has - # the side effect of initializing the test database. - cursor = self.connection.cursor() - - return test_database_name - - def sql_indexes_for_field(self, model, f, style): - "Return any spatial index creation SQL for the field." - from django.contrib.gis.db.models.fields import GeometryField - - output = super(SpatiaLiteCreation, self).sql_indexes_for_field(model, f, style) - - if isinstance(f, GeometryField): - gqn = self.connection.ops.geo_quote_name - qn = self.connection.ops.quote_name - db_table = model._meta.db_table - - output.append(style.SQL_KEYWORD('SELECT ') + - style.SQL_TABLE('AddGeometryColumn') + '(' + - style.SQL_TABLE(gqn(db_table)) + ', ' + - style.SQL_FIELD(gqn(f.column)) + ', ' + - style.SQL_FIELD(str(f.srid)) + ', ' + - style.SQL_COLTYPE(gqn(f.geom_type)) + ', ' + - style.SQL_KEYWORD(str(f.dim)) + ', ' + - style.SQL_KEYWORD(str(int(not f.null))) + - ');') - - if f.spatial_index: - output.append(style.SQL_KEYWORD('SELECT ') + - style.SQL_TABLE('CreateSpatialIndex') + '(' + - style.SQL_TABLE(gqn(db_table)) + ', ' + - style.SQL_FIELD(gqn(f.column)) + ');') - - return output - - def load_spatialite_sql(self): - """ - This routine loads up the SpatiaLite SQL file. - """ - if self.connection.ops.spatial_version[:2] >= (2, 4): - # Spatialite >= 2.4 -- No need to load any SQL file, calling - # InitSpatialMetaData() transparently creates the spatial metadata - # tables - cur = self.connection._cursor() - cur.execute("SELECT InitSpatialMetaData()") - else: - # Spatialite < 2.4 -- Load the initial SQL - - # Getting the location of the SpatiaLite SQL file, and confirming - # it exists. - spatialite_sql = self.spatialite_init_file() - if not os.path.isfile(spatialite_sql): - raise ImproperlyConfigured('Could not find the required SpatiaLite initialization ' - 'SQL file (necessary for testing): %s' % spatialite_sql) - - # Opening up the SpatiaLite SQL initialization file and executing - # as a script. - with open(spatialite_sql, 'r') as sql_fh: - cur = self.connection._cursor() - cur.executescript(sql_fh.read()) - - def spatialite_init_file(self): - # SPATIALITE_SQL may be placed in settings to tell GeoDjango - # to use a specific path to the SpatiaLite initilization SQL. - return getattr(settings, 'SPATIALITE_SQL', - 'init_spatialite-%s.%s.sql' % - self.connection.ops.spatial_version[:2]) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/introspection.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/introspection.py deleted file mode 100644 index 4f12ade..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/introspection.py +++ /dev/null @@ -1,52 +0,0 @@ -from django.contrib.gis.gdal import OGRGeomType -from django.db.backends.sqlite3.introspection import DatabaseIntrospection, FlexibleFieldLookupDict -from django.utils import six - -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.copy() - base_data_types_reverse.update( - {'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): - cursor = self.connection.cursor() - try: - # Querying the `geometry_columns` table to get additional metadata. - 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 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. - 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 isinstance(dim, six.string_types) and 'Z' in dim: - field_params['dim'] = 3 - finally: - cursor.close() - - return field_type, field_params diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/models.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/models.py deleted file mode 100644 index b281f0b..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/models.py +++ /dev/null @@ -1,62 +0,0 @@ -""" - The GeometryColumns and SpatialRefSys models for the SpatiaLite backend. -""" -from django.db import models -from django.contrib.gis.db.backends.base import SpatialRefSysMixin -from django.utils.encoding import python_2_unicode_compatible - -@python_2_unicode_compatible -class GeometryColumns(models.Model): - """ - The 'geometry_columns' table from SpatiaLite. - """ - f_table_name = models.CharField(max_length=256) - f_geometry_column = models.CharField(max_length=256) - type = models.CharField(max_length=30) - coord_dimension = models.IntegerField() - srid = models.IntegerField(primary_key=True) - spatial_index_enabled = models.IntegerField() - - class Meta: - db_table = 'geometry_columns' - managed = False - - @classmethod - def table_name_col(cls): - """ - Returns the name of the metadata column used to store the - the feature table name. - """ - return 'f_table_name' - - @classmethod - def geom_col_name(cls): - """ - Returns the name of the metadata column used to store the - the feature geometry column. - """ - return 'f_geometry_column' - - def __str__(self): - return "%s.%s - %dD %s field (SRID: %d)" % \ - (self.f_table_name, self.f_geometry_column, - self.coord_dimension, self.type, self.srid) - -class SpatialRefSys(models.Model, SpatialRefSysMixin): - """ - The 'spatial_ref_sys' table from SpatiaLite. - """ - srid = models.IntegerField(primary_key=True) - auth_name = models.CharField(max_length=256) - auth_srid = models.IntegerField() - ref_sys_name = models.CharField(max_length=256) - proj4text = models.CharField(max_length=2048) - - @property - def wkt(self): - from django.contrib.gis.gdal import SpatialReference - return SpatialReference(self.proj4text).wkt - - class Meta: - db_table = 'spatial_ref_sys' - managed = False diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/operations.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/operations.py deleted file mode 100644 index 4281caf..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/spatialite/operations.py +++ /dev/null @@ -1,373 +0,0 @@ -import re -import sys -from decimal import Decimal - -from django.contrib.gis.db.backends.base import BaseSpatialOperations -from django.contrib.gis.db.backends.util import SpatialOperation, SpatialFunction -from django.contrib.gis.db.backends.spatialite.adapter import SpatiaLiteAdapter -from django.contrib.gis.geometry.backend import Geometry -from django.contrib.gis.measure import Distance -from django.core.exceptions import ImproperlyConfigured -from django.db.backends.sqlite3.base import DatabaseOperations -from django.db.utils import DatabaseError -from django.utils import six -from django.utils.functional import cached_property - - -class SpatiaLiteOperator(SpatialOperation): - "For SpatiaLite operators (e.g. `&&`, `~`)." - def __init__(self, operator): - super(SpatiaLiteOperator, self).__init__(operator=operator) - -class SpatiaLiteFunction(SpatialFunction): - "For SpatiaLite function calls." - def __init__(self, function, **kwargs): - super(SpatiaLiteFunction, self).__init__(function, **kwargs) - -class SpatiaLiteFunctionParam(SpatiaLiteFunction): - "For SpatiaLite functions that take another parameter." - sql_template = '%(function)s(%(geo_col)s, %(geometry)s, %%s)' - -class SpatiaLiteDistance(SpatiaLiteFunction): - "For SpatiaLite distance operations." - dist_func = 'Distance' - sql_template = '%(function)s(%(geo_col)s, %(geometry)s) %(operator)s %%s' - - def __init__(self, operator): - super(SpatiaLiteDistance, self).__init__(self.dist_func, - operator=operator) - -class SpatiaLiteRelate(SpatiaLiteFunctionParam): - "For SpatiaLite Relate(<geom>, <pattern>) calls." - pattern_regex = re.compile(r'^[012TF\*]{9}$') - def __init__(self, pattern): - if not self.pattern_regex.match(pattern): - raise ValueError('Invalid intersection matrix pattern "%s".' % pattern) - super(SpatiaLiteRelate, self).__init__('Relate') - -# Valid distance types and substitutions -dtypes = (Decimal, Distance, float) + six.integer_types -def get_dist_ops(operator): - "Returns operations for regular distances; spherical distances are not currently supported." - return (SpatiaLiteDistance(operator),) - -class SpatiaLiteOperations(DatabaseOperations, BaseSpatialOperations): - compiler_module = 'django.contrib.gis.db.models.sql.compiler' - name = 'spatialite' - spatialite = True - version_regex = re.compile(r'^(?P<major>\d)\.(?P<minor1>\d)\.(?P<minor2>\d+)') - valid_aggregates = dict([(k, None) for k in ('Extent', 'Union')]) - - Adapter = SpatiaLiteAdapter - Adaptor = Adapter # Backwards-compatibility alias. - - area = 'Area' - centroid = 'Centroid' - contained = 'MbrWithin' - difference = 'Difference' - distance = 'Distance' - envelope = 'Envelope' - intersection = 'Intersection' - length = 'GLength' # OpenGis defines Length, but this conflicts with an SQLite reserved keyword - num_geom = 'NumGeometries' - num_points = 'NumPoints' - point_on_surface = 'PointOnSurface' - scale = 'ScaleCoords' - svg = 'AsSVG' - sym_difference = 'SymDifference' - transform = 'Transform' - translate = 'ShiftCoords' - union = 'GUnion' # OpenGis defines Union, but this conflicts with an SQLite reserved keyword - unionagg = 'GUnion' - - from_text = 'GeomFromText' - from_wkb = 'GeomFromWKB' - select = 'AsText(%s)' - - geometry_functions = { - 'equals' : SpatiaLiteFunction('Equals'), - 'disjoint' : SpatiaLiteFunction('Disjoint'), - 'touches' : SpatiaLiteFunction('Touches'), - 'crosses' : SpatiaLiteFunction('Crosses'), - 'within' : SpatiaLiteFunction('Within'), - 'overlaps' : SpatiaLiteFunction('Overlaps'), - 'contains' : SpatiaLiteFunction('Contains'), - 'intersects' : SpatiaLiteFunction('Intersects'), - 'relate' : (SpatiaLiteRelate, six.string_types), - # Returns true if B's bounding box completely contains A's bounding box. - 'contained' : SpatiaLiteFunction('MbrWithin'), - # Returns true if A's bounding box completely contains B's bounding box. - 'bbcontains' : SpatiaLiteFunction('MbrContains'), - # Returns true if A's bounding box overlaps B's bounding box. - 'bboverlaps' : SpatiaLiteFunction('MbrOverlaps'), - # These are implemented here as synonyms for Equals - 'same_as' : SpatiaLiteFunction('Equals'), - 'exact' : SpatiaLiteFunction('Equals'), - } - - distance_functions = { - 'distance_gt' : (get_dist_ops('>'), dtypes), - 'distance_gte' : (get_dist_ops('>='), dtypes), - 'distance_lt' : (get_dist_ops('<'), dtypes), - 'distance_lte' : (get_dist_ops('<='), dtypes), - } - geometry_functions.update(distance_functions) - - def __init__(self, connection): - super(DatabaseOperations, self).__init__(connection) - - # Creating the GIS terms dictionary. - self.gis_terms = set(['isnull']) - self.gis_terms.update(self.geometry_functions) - - @cached_property - def spatial_version(self): - """Determine the version of the SpatiaLite library.""" - try: - version = self.spatialite_version_tuple()[1:] - except Exception as msg: - new_msg = ( - 'Cannot determine the SpatiaLite version for the "%s" ' - 'database (error was "%s"). Was the SpatiaLite initialization ' - 'SQL loaded on this database?') % (self.connection.settings_dict['NAME'], msg) - six.reraise(ImproperlyConfigured, ImproperlyConfigured(new_msg), sys.exc_info()[2]) - if version < (2, 3, 0): - raise ImproperlyConfigured('GeoDjango only supports SpatiaLite versions ' - '2.3.0 and above') - return version - - @property - def _version_greater_2_4_0_rc4(self): - if self.spatial_version >= (2, 4, 1): - return True - elif self.spatial_version < (2, 4, 0): - return False - else: - # Spatialite 2.4.0-RC4 added AsGML and AsKML, however both - # RC2 (shipped in popular Debian/Ubuntu packages) and RC4 - # report version as '2.4.0', so we fall back to feature detection - try: - self._get_spatialite_func("AsGML(GeomFromText('POINT(1 1)'))") - except DatabaseError: - return False - return True - - @cached_property - def gml(self): - return 'AsGML' if self._version_greater_2_4_0_rc4 else None - - @cached_property - def kml(self): - return 'AsKML' if self._version_greater_2_4_0_rc4 else None - - @cached_property - def geojson(self): - return 'AsGeoJSON' if self.spatial_version >= (3, 0, 0) else None - - def check_aggregate_support(self, aggregate): - """ - Checks if the given aggregate name is supported (that is, if it's - in `self.valid_aggregates`). - """ - agg_name = aggregate.__class__.__name__ - return agg_name in self.valid_aggregates - - def convert_geom(self, wkt, geo_field): - """ - Converts geometry WKT returned from a SpatiaLite aggregate. - """ - if wkt: - return Geometry(wkt, geo_field.srid) - else: - return None - - def geo_db_type(self, f): - """ - Returns None because geometry columnas are added via the - `AddGeometryColumn` stored procedure on SpatiaLite. - """ - return None - - def get_distance(self, f, value, lookup_type): - """ - Returns the distance parameters for the given geometry field, - lookup value, and lookup type. SpatiaLite only supports regular - cartesian-based queries (no spheroid/sphere calculations for point - geometries like PostGIS). - """ - if not value: - return [] - value = value[0] - if isinstance(value, Distance): - if f.geodetic(self.connection): - raise ValueError('SpatiaLite does not support distance queries on ' - 'geometry fields with a geodetic coordinate system. ' - 'Distance objects; use a numeric value of your ' - 'distance in degrees instead.') - else: - dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection))) - else: - dist_param = value - return [dist_param] - - def get_geom_placeholder(self, f, value): - """ - Provides a proper substitution value for Geometries that are not in the - SRID of the field. Specifically, this routine will substitute in the - Transform() and GeomFromText() function call(s). - """ - def transform_value(value, srid): - return not (value is None or value.srid == srid) - if hasattr(value, 'expression'): - if transform_value(value, f.srid): - placeholder = '%s(%%s, %s)' % (self.transform, f.srid) - else: - placeholder = '%s' - # No geometry value used for F expression, substitue in - # the column name instead. - return placeholder % self.get_expression_column(value) - else: - if transform_value(value, f.srid): - # Adding Transform() to the SQL placeholder. - return '%s(%s(%%s,%s), %s)' % (self.transform, self.from_text, value.srid, f.srid) - else: - return '%s(%%s,%s)' % (self.from_text, f.srid) - - def _get_spatialite_func(self, func): - """ - Helper routine for calling SpatiaLite functions and returning - their result. - """ - cursor = self.connection._cursor() - try: - try: - cursor.execute('SELECT %s' % func) - row = cursor.fetchone() - except: - # Responsibility of caller to perform error handling. - raise - finally: - cursor.close() - return row[0] - - def geos_version(self): - "Returns the version of GEOS used by SpatiaLite as a string." - return self._get_spatialite_func('geos_version()') - - def proj4_version(self): - "Returns the version of the PROJ.4 library used by SpatiaLite." - return self._get_spatialite_func('proj4_version()') - - def spatialite_version(self): - "Returns the SpatiaLite library version as a string." - return self._get_spatialite_func('spatialite_version()') - - def spatialite_version_tuple(self): - """ - Returns the SpatiaLite version as a tuple (version string, major, - minor, subminor). - """ - # Getting the SpatiaLite version. - try: - version = self.spatialite_version() - except DatabaseError: - # The `spatialite_version` function first appeared in version 2.3.1 - # of SpatiaLite, so doing a fallback test for 2.3.0 (which is - # used by popular Debian/Ubuntu packages). - version = None - try: - tmp = self._get_spatialite_func("X(GeomFromText('POINT(1 1)'))") - if tmp == 1.0: version = '2.3.0' - except DatabaseError: - pass - # If no version string defined, then just re-raise the original - # exception. - if version is None: raise - - m = self.version_regex.match(version) - if m: - major = int(m.group('major')) - minor1 = int(m.group('minor1')) - minor2 = int(m.group('minor2')) - else: - raise Exception('Could not parse SpatiaLite version string: %s' % version) - - return (version, major, minor1, minor2) - - def spatial_aggregate_sql(self, agg): - """ - Returns the spatial aggregate SQL template and function for the - given Aggregate instance. - """ - agg_name = agg.__class__.__name__ - if not self.check_aggregate_support(agg): - raise NotImplementedError('%s spatial aggregate is not implmented for this backend.' % agg_name) - agg_name = agg_name.lower() - if agg_name == 'union': agg_name += 'agg' - sql_template = self.select % '%(function)s(%(field)s)' - sql_function = getattr(self, agg_name) - return sql_template, sql_function - - def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn): - """ - Returns the SpatiaLite-specific SQL for the given lookup value - [a tuple of (alias, column, db_type)], lookup type, lookup - value, the model field, and the quoting function. - """ - alias, col, db_type = lvalue - - # Getting the quoted field as `geo_col`. - geo_col = '%s.%s' % (qn(alias), qn(col)) - - if lookup_type in self.geometry_functions: - # See if a SpatiaLite geometry function matches the lookup type. - tmp = self.geometry_functions[lookup_type] - - # Lookup types that are tuples take tuple arguments, e.g., 'relate' and - # distance lookups. - if isinstance(tmp, tuple): - # First element of tuple is the SpatiaLiteOperation instance, and the - # second element is either the type or a tuple of acceptable types - # that may passed in as further parameters for the lookup type. - op, arg_type = tmp - - # Ensuring that a tuple _value_ was passed in from the user - if not isinstance(value, (tuple, list)): - raise ValueError('Tuple required for `%s` lookup type.' % lookup_type) - - # Geometry is first element of lookup tuple. - geom = value[0] - - # Number of valid tuple parameters depends on the lookup type. - if len(value) != 2: - raise ValueError('Incorrect number of parameters given for `%s` lookup type.' % lookup_type) - - # Ensuring the argument type matches what we expect. - if not isinstance(value[1], arg_type): - raise ValueError('Argument type should be %s, got %s instead.' % (arg_type, type(value[1]))) - - # For lookup type `relate`, the op instance is not yet created (has - # to be instantiated here to check the pattern parameter). - if lookup_type == 'relate': - op = op(value[1]) - elif lookup_type in self.distance_functions: - op = op[0] - else: - op = tmp - geom = value - # Calling the `as_sql` function on the operation instance. - return op.as_sql(geo_col, self.get_geom_placeholder(field, geom)) - elif lookup_type == 'isnull': - # Handling 'isnull' lookup type - return "%s IS %sNULL" % (geo_col, ('' if value else 'NOT ')), [] - - raise TypeError("Got invalid lookup_type: %s" % repr(lookup_type)) - - # Routines for getting the OGC-compliant models. - def geometry_columns(self): - from django.contrib.gis.db.backends.spatialite.models import GeometryColumns - return GeometryColumns - - def spatial_ref_sys(self): - from django.contrib.gis.db.backends.spatialite.models import SpatialRefSys - return SpatialRefSys diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/backends/util.py b/lib/python2.7/site-packages/django/contrib/gis/db/backends/util.py deleted file mode 100644 index 2612810..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/backends/util.py +++ /dev/null @@ -1,44 +0,0 @@ -""" -A collection of utility routines and classes used by the spatial -backends. -""" - -class SpatialOperation(object): - """ - Base class for generating spatial SQL. - """ - sql_template = '%(geo_col)s %(operator)s %(geometry)s' - - def __init__(self, function='', operator='', result='', **kwargs): - self.function = function - self.operator = operator - self.result = result - self.extra = kwargs - - def as_sql(self, geo_col, geometry='%s'): - return self.sql_template % self.params(geo_col, geometry), [] - - def params(self, geo_col, geometry): - params = {'function' : self.function, - 'geo_col' : geo_col, - 'geometry' : geometry, - 'operator' : self.operator, - 'result' : self.result, - } - params.update(self.extra) - return params - -class SpatialFunction(SpatialOperation): - """ - Base class for generating spatial SQL related to a function. - """ - sql_template = '%(function)s(%(geo_col)s, %(geometry)s)' - - def __init__(self, func, result='', operator='', **kwargs): - # Getting the function prefix. - default = {'function' : func, - 'operator' : operator, - 'result' : result - } - kwargs.update(default) - super(SpatialFunction, self).__init__(**kwargs) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/__init__.py deleted file mode 100644 index e36aa36..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -# Want to get everything from the 'normal' models package. -from django.db.models import * - -# Geographic aggregate functions -from django.contrib.gis.db.models.aggregates import * - -# The GeoManager -from django.contrib.gis.db.models.manager import GeoManager - -# The geographic-enabled fields. -from django.contrib.gis.db.models.fields import ( - GeometryField, PointField, LineStringField, PolygonField, - MultiPointField, MultiLineStringField, MultiPolygonField, - GeometryCollectionField) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/aggregates.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/aggregates.py deleted file mode 100644 index d0fc6d3..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/aggregates.py +++ /dev/null @@ -1,16 +0,0 @@ -from django.db.models import Aggregate - -class Collect(Aggregate): - name = 'Collect' - -class Extent(Aggregate): - name = 'Extent' - -class Extent3D(Aggregate): - name = 'Extent3D' - -class MakeLine(Aggregate): - name = 'MakeLine' - -class Union(Aggregate): - name = 'Union' diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/fields.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/fields.py deleted file mode 100644 index 2e221b7..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/fields.py +++ /dev/null @@ -1,305 +0,0 @@ -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.utils import six - -# 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 for the given database connection. These results are cached. - """ - global _srid_cache - - 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 - - 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[connection.alias][srid] = (units, units_name, spheroid) - - return _srid_cache[connection.alias][srid] - -class GeometryField(Field): - "The base GIS field -- maps to the OpenGIS Specification Geometry type." - - # The OpenGIS Geometry name. - geom_type = 'GEOMETRY' - form_class = forms.GeometryField - - # Geodetic units. - geodetic_units = ('Decimal Degree', 'degree') - - description = _("The base GIS field -- maps to the OpenGIS Specification Geometry type.") - - def __init__(self, verbose_name=None, srid=4326, spatial_index=True, dim=2, - geography=False, **kwargs): - """ - The initialization function for geometry fields. Takes the following - as keyword arguments: - - srid: - The spatial reference system identifier, an OGC standard. - Defaults to 4326 (WGS84). - - spatial_index: - Indicates whether to create a spatial index. Defaults to True. - Set this instead of 'db_index' for geographic fields since index - creation is different for geometry columns. - - dim: - The number of dimensions for this geometry. Defaults to 2. - - extent: - Customize the extent, in a 4-tuple of WGS 84 coordinates, for the - geometry field entry in the `USER_SDO_GEOM_METADATA` table. Defaults - to (-180.0, -90.0, 180.0, 90.0). - - tolerance: - Define the tolerance, in meters, to use for the geometry field - entry in the `USER_SDO_GEOM_METADATA` table. Defaults to 0.05. - """ - - # Setting the index flag with the value of the `spatial_index` keyword. - self.spatial_index = spatial_index - - # Setting the SRID and getting the units. Unit information must be - # easily available in the field instance for distance queries. - self.srid = srid - - # Setting the dimension of the geometry field. - self.dim = dim - - # Setting the verbose_name keyword argument with the positional - # first parameter, so this works like normal fields. - kwargs['verbose_name'] = verbose_name - - # Is this a geography rather than a geometry column? - self.geography = geography - - # Oracle-specific private attributes for creating the entry in - # `USER_SDO_GEOM_METADATA` - self._extent = kwargs.pop('extent', (-180.0, -90.0, 180.0, 90.0)) - self._tolerance = kwargs.pop('tolerance', 0.05) - - super(GeometryField, self).__init__(**kwargs) - - # The following functions are used to get the units, their name, and - # the spheroid corresponding to the SRID of the GeometryField. - def _get_srid_info(self, connection): - # Get attributes from `get_srid_info`. - self._units, self._units_name, self._spheroid = get_srid_info(self.srid, connection) - - def spheroid(self, connection): - if not hasattr(self, '_spheroid'): - self._get_srid_info(connection) - return self._spheroid - - def units(self, connection): - if not hasattr(self, '_units'): - self._get_srid_info(connection) - return self._units - - def units_name(self, connection): - if not hasattr(self, '_units_name'): - self._get_srid_info(connection) - return self._units_name - - ### Routines specific to GeometryField ### - def geodetic(self, connection): - """ - Returns true if this field's SRID corresponds with a coordinate - system that uses non-projected units (e.g., latitude/longitude). - """ - return self.units_name(connection) in self.geodetic_units - - def get_distance(self, value, lookup_type, connection): - """ - Returns a distance number in units of the field. For example, if - `D(km=1)` was passed in and the units of the field were in meters, - then 1000 would be returned. - """ - return connection.ops.get_distance(self, value, lookup_type) - - def get_prep_value(self, value): - """ - Spatial lookup values are either a parameter that is (or may be - converted to) a geometry, or a sequence of lookup values that - begins with a geometry. This routine will setup the geometry - value properly, and preserve any other lookup parameters before - returning to the caller. - """ - if isinstance(value, SQLEvaluator): - return value - elif isinstance(value, (tuple, list)): - geom = value[0] - seq_value = True - else: - geom = value - seq_value = False - - # When the input is not a GEOS geometry, attempt to construct one - # from the given string input. - if isinstance(geom, Geometry): - pass - elif isinstance(geom, (bytes, six.string_types)) or hasattr(geom, '__geo_interface__'): - try: - geom = Geometry(geom) - except GeometryException: - raise ValueError('Could not create geometry from lookup value.') - else: - raise ValueError('Cannot use object with type %s for a geometry lookup parameter.' % type(geom).__name__) - - # Assigning the SRID value. - geom.srid = self.get_srid(geom) - - if seq_value: - lookup_val = [geom] - lookup_val.extend(value[1:]) - return tuple(lookup_val) - else: - return geom - - def get_srid(self, geom): - """ - Returns the default SRID for the given geometry, taking into account - the SRID set for the field. For example, if the input geometry - has no SRID, then that of the field will be returned. - """ - gsrid = geom.srid # SRID of given geometry. - if gsrid is None or self.srid == -1 or (gsrid == -1 and self.srid != -1): - return self.srid - else: - return gsrid - - ### Routines overloaded from Field ### - def contribute_to_class(self, cls, name): - super(GeometryField, self).contribute_to_class(cls, name) - - # Setup for lazy-instantiated Geometry object. - setattr(cls, self.attname, GeometryProxy(Geometry, self)) - - def db_type(self, connection): - return connection.ops.geo_db_type(self) - - def formfield(self, **kwargs): - defaults = {'form_class' : self.form_class, - 'geom_type' : self.geom_type, - 'srid' : self.srid, - } - defaults.update(kwargs) - if (self.dim > 2 and not 'widget' in kwargs and - not getattr(defaults['form_class'].widget, 'supports_3d', False)): - defaults['widget'] = forms.Textarea - return super(GeometryField, self).formfield(**defaults) - - def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False): - """ - Prepare for the database lookup, and return any spatial parameters - necessary for the query. This includes wrapping any geometry - parameters with a backend-specific adapter and formatting any distance - parameters into the correct units for the coordinate system of the - field. - """ - if lookup_type in connection.ops.gis_terms: - # special case for isnull lookup - if lookup_type == 'isnull': - return [] - - # Populating the parameters list, and wrapping the Geometry - # with the Adapter of the spatial backend. - if isinstance(value, (tuple, list)): - params = [connection.ops.Adapter(value[0])] - if lookup_type in connection.ops.distance_functions: - # Getting the distance parameter in the units of the field. - params += self.get_distance(value[1:], lookup_type, connection) - elif lookup_type in connection.ops.truncate_params: - # Lookup is one where SQL parameters aren't needed from the - # given lookup value. - pass - else: - params += value[1:] - elif isinstance(value, SQLEvaluator): - params = [] - else: - params = [connection.ops.Adapter(value)] - - return params - else: - raise ValueError('%s is not a valid spatial lookup for %s.' % - (lookup_type, self.__class__.__name__)) - - def get_prep_lookup(self, lookup_type, value): - if lookup_type == 'isnull': - return bool(value) - else: - return self.get_prep_value(value) - - def get_db_prep_save(self, value, connection): - "Prepares the value for saving in the database." - if value is None: - return None - else: - return connection.ops.Adapter(self.get_prep_value(value)) - - def get_placeholder(self, value, connection): - """ - Returns the placeholder for the geometry column for the - given value. - """ - return connection.ops.get_geom_placeholder(self, value) - -# The OpenGIS Geometry Type Fields -class PointField(GeometryField): - geom_type = 'POINT' - form_class = forms.PointField - description = _("Point") - -class LineStringField(GeometryField): - geom_type = 'LINESTRING' - form_class = forms.LineStringField - description = _("Line string") - -class PolygonField(GeometryField): - geom_type = 'POLYGON' - form_class = forms.PolygonField - description = _("Polygon") - -class MultiPointField(GeometryField): - geom_type = 'MULTIPOINT' - form_class = forms.MultiPointField - description = _("Multi-point") - -class MultiLineStringField(GeometryField): - geom_type = 'MULTILINESTRING' - form_class = forms.MultiLineStringField - description = _("Multi-line string") - -class MultiPolygonField(GeometryField): - geom_type = 'MULTIPOLYGON' - form_class = forms.MultiPolygonField - description = _("Multi polygon") - -class GeometryCollectionField(GeometryField): - geom_type = 'GEOMETRYCOLLECTION' - form_class = forms.GeometryCollectionField - description = _("Geometry collection") diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/manager.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/manager.py deleted file mode 100644 index aa57e3a..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/manager.py +++ /dev/null @@ -1,103 +0,0 @@ -from django.db.models.manager import Manager -from django.contrib.gis.db.models.query import GeoQuerySet - -class GeoManager(Manager): - "Overrides Manager to return Geographic QuerySets." - - # This manager should be used for queries on related fields - # so that geometry columns on Oracle and MySQL are selected - # properly. - use_for_related_fields = True - - def get_queryset(self): - return GeoQuerySet(self.model, using=self._db) - - def area(self, *args, **kwargs): - return self.get_queryset().area(*args, **kwargs) - - def centroid(self, *args, **kwargs): - return self.get_queryset().centroid(*args, **kwargs) - - def collect(self, *args, **kwargs): - return self.get_queryset().collect(*args, **kwargs) - - def difference(self, *args, **kwargs): - return self.get_queryset().difference(*args, **kwargs) - - def distance(self, *args, **kwargs): - return self.get_queryset().distance(*args, **kwargs) - - def envelope(self, *args, **kwargs): - return self.get_queryset().envelope(*args, **kwargs) - - def extent(self, *args, **kwargs): - return self.get_queryset().extent(*args, **kwargs) - - def extent3d(self, *args, **kwargs): - return self.get_queryset().extent3d(*args, **kwargs) - - def force_rhr(self, *args, **kwargs): - return self.get_queryset().force_rhr(*args, **kwargs) - - def geohash(self, *args, **kwargs): - return self.get_queryset().geohash(*args, **kwargs) - - def geojson(self, *args, **kwargs): - return self.get_queryset().geojson(*args, **kwargs) - - def gml(self, *args, **kwargs): - return self.get_queryset().gml(*args, **kwargs) - - def intersection(self, *args, **kwargs): - return self.get_queryset().intersection(*args, **kwargs) - - def kml(self, *args, **kwargs): - return self.get_queryset().kml(*args, **kwargs) - - def length(self, *args, **kwargs): - return self.get_queryset().length(*args, **kwargs) - - def make_line(self, *args, **kwargs): - return self.get_queryset().make_line(*args, **kwargs) - - def mem_size(self, *args, **kwargs): - return self.get_queryset().mem_size(*args, **kwargs) - - def num_geom(self, *args, **kwargs): - return self.get_queryset().num_geom(*args, **kwargs) - - def num_points(self, *args, **kwargs): - return self.get_queryset().num_points(*args, **kwargs) - - def perimeter(self, *args, **kwargs): - return self.get_queryset().perimeter(*args, **kwargs) - - def point_on_surface(self, *args, **kwargs): - return self.get_queryset().point_on_surface(*args, **kwargs) - - def reverse_geom(self, *args, **kwargs): - return self.get_queryset().reverse_geom(*args, **kwargs) - - def scale(self, *args, **kwargs): - return self.get_queryset().scale(*args, **kwargs) - - def snap_to_grid(self, *args, **kwargs): - return self.get_queryset().snap_to_grid(*args, **kwargs) - - def svg(self, *args, **kwargs): - return self.get_queryset().svg(*args, **kwargs) - - def sym_difference(self, *args, **kwargs): - return self.get_queryset().sym_difference(*args, **kwargs) - - def transform(self, *args, **kwargs): - return self.get_queryset().transform(*args, **kwargs) - - def translate(self, *args, **kwargs): - return self.get_queryset().translate(*args, **kwargs) - - def union(self, *args, **kwargs): - return self.get_queryset().union(*args, **kwargs) - - def unionagg(self, *args, **kwargs): - return self.get_queryset().unionagg(*args, **kwargs) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/proxy.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/proxy.py deleted file mode 100644 index 1fdc503..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/proxy.py +++ /dev/null @@ -1,66 +0,0 @@ -""" -The GeometryProxy object, allows for lazy-geometries. The proxy uses -Python descriptors for instantiating and setting Geometry objects -corresponding to geographic model fields. - -Thanks to Robert Coup for providing this functionality (see #4322). -""" -from django.contrib.gis import memoryview -from django.utils import six - -class GeometryProxy(object): - def __init__(self, klass, field): - """ - Proxy initializes on the given Geometry class (not an instance) and - the GeometryField. - """ - self._field = field - self._klass = klass - - def __get__(self, obj, type=None): - """ - This accessor retrieves the geometry, initializing it using the geometry - class specified during initialization and the HEXEWKB value of the field. - Currently, only GEOS or OGR geometries are supported. - """ - if obj is None: - # Accessed on a class, not an instance - return self - - # Getting the value of the field. - geom_value = obj.__dict__[self._field.attname] - - if isinstance(geom_value, self._klass): - geom = geom_value - elif (geom_value is None) or (geom_value==''): - geom = None - else: - # Otherwise, a Geometry object is built using the field's contents, - # and the model's corresponding attribute is set. - geom = self._klass(geom_value) - setattr(obj, self._field.attname, geom) - return geom - - def __set__(self, obj, value): - """ - This accessor sets the proxied geometry with the geometry class - specified during initialization. Values of None, HEXEWKB, or WKT may - be used to set the geometry as well. - """ - # The OGC Geometry type of the field. - gtype = self._field.geom_type - - # The geometry type must match that of the field -- unless the - # general GeometryField is used. - if isinstance(value, self._klass) and (str(value.geom_type).upper() == gtype or gtype == 'GEOMETRY'): - # Assigning the SRID to the geometry. - if value.srid is None: value.srid = self._field.srid - elif value is None or isinstance(value, six.string_types + (memoryview,)): - # Set with None, WKT, HEX, or WKB - pass - else: - raise TypeError('cannot set %s GeometryProxy with value of type: %s' % (obj.__class__.__name__, type(value))) - - # Setting the objects dictionary with the value, and returning. - obj.__dict__[self._field.attname] = value - return value diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/query.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/query.py deleted file mode 100644 index c89912b..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/query.py +++ /dev/null @@ -1,784 +0,0 @@ -from django.db import connections -from django.db.models.query import QuerySet, ValuesQuerySet, ValuesListQuerySet - -from django.contrib.gis import memoryview -from django.contrib.gis.db.models import aggregates -from django.contrib.gis.db.models.fields import get_srid_info, PointField, LineStringField -from django.contrib.gis.db.models.sql import AreaField, DistanceField, GeomField, GeoQuery -from django.contrib.gis.geometry.backend import Geometry -from django.contrib.gis.measure import Area, Distance - -from django.utils import six - - -class GeoQuerySet(QuerySet): - "The Geographic QuerySet." - - ### Methods overloaded from QuerySet ### - def __init__(self, model=None, query=None, using=None): - super(GeoQuerySet, self).__init__(model=model, query=query, using=using) - self.query = query or GeoQuery(self.model) - - def values(self, *fields): - return self._clone(klass=GeoValuesQuerySet, setup=True, _fields=fields) - - def values_list(self, *fields, **kwargs): - flat = kwargs.pop('flat', False) - if kwargs: - raise TypeError('Unexpected keyword arguments to values_list: %s' - % (list(kwargs),)) - if flat and len(fields) > 1: - raise TypeError("'flat' is not valid when values_list is called with more than one field.") - return self._clone(klass=GeoValuesListQuerySet, setup=True, flat=flat, - _fields=fields) - - ### GeoQuerySet Methods ### - def area(self, tolerance=0.05, **kwargs): - """ - Returns the area of the geographic field in an `area` attribute on - each element of this GeoQuerySet. - """ - # Peforming setup here rather than in `_spatial_attribute` so that - # we can get the units for `AreaField`. - procedure_args, geo_field = self._spatial_setup('area', field_name=kwargs.get('field_name', None)) - s = {'procedure_args' : procedure_args, - 'geo_field' : geo_field, - 'setup' : False, - } - connection = connections[self.db] - backend = connection.ops - if backend.oracle: - s['procedure_fmt'] = '%(geo_col)s,%(tolerance)s' - s['procedure_args']['tolerance'] = tolerance - s['select_field'] = AreaField('sq_m') # Oracle returns area in units of meters. - elif backend.postgis or backend.spatialite: - if backend.geography: - # Geography fields support area calculation, returns square meters. - s['select_field'] = AreaField('sq_m') - elif not geo_field.geodetic(connection): - # Getting the area units of the geographic field. - s['select_field'] = AreaField(Area.unit_attname(geo_field.units_name(connection))) - else: - # TODO: Do we want to support raw number areas for geodetic fields? - raise Exception('Area on geodetic coordinate systems not supported.') - return self._spatial_attribute('area', s, **kwargs) - - def centroid(self, **kwargs): - """ - Returns the centroid of the geographic field in a `centroid` - attribute on each element of this GeoQuerySet. - """ - return self._geom_attribute('centroid', **kwargs) - - def collect(self, **kwargs): - """ - Performs an aggregate collect operation on the given geometry field. - This is analagous to a union operation, but much faster because - boundaries are not dissolved. - """ - return self._spatial_aggregate(aggregates.Collect, **kwargs) - - def difference(self, geom, **kwargs): - """ - Returns the spatial difference of the geographic field in a `difference` - attribute on each element of this GeoQuerySet. - """ - return self._geomset_attribute('difference', geom, **kwargs) - - def distance(self, geom, **kwargs): - """ - Returns the distance from the given geographic field name to the - given geometry in a `distance` attribute on each element of the - GeoQuerySet. - - Keyword Arguments: - `spheroid` => If the geometry field is geodetic and PostGIS is - the spatial database, then the more accurate - spheroid calculation will be used instead of the - quicker sphere calculation. - - `tolerance` => Used only for Oracle. The tolerance is - in meters -- a default of 5 centimeters (0.05) - is used. - """ - return self._distance_attribute('distance', geom, **kwargs) - - def envelope(self, **kwargs): - """ - Returns a Geometry representing the bounding box of the - Geometry field in an `envelope` attribute on each element of - the GeoQuerySet. - """ - return self._geom_attribute('envelope', **kwargs) - - def extent(self, **kwargs): - """ - Returns the extent (aggregate) of the features in the GeoQuerySet. The - extent will be returned as a 4-tuple, consisting of (xmin, ymin, xmax, ymax). - """ - return self._spatial_aggregate(aggregates.Extent, **kwargs) - - def extent3d(self, **kwargs): - """ - Returns the aggregate extent, in 3D, of the features in the - GeoQuerySet. It is returned as a 6-tuple, comprising: - (xmin, ymin, zmin, xmax, ymax, zmax). - """ - return self._spatial_aggregate(aggregates.Extent3D, **kwargs) - - def force_rhr(self, **kwargs): - """ - Returns a modified version of the Polygon/MultiPolygon in which - all of the vertices follow the Right-Hand-Rule. By default, - this is attached as the `force_rhr` attribute on each element - of the GeoQuerySet. - """ - return self._geom_attribute('force_rhr', **kwargs) - - def geojson(self, precision=8, crs=False, bbox=False, **kwargs): - """ - Returns a GeoJSON representation of the geomtry field in a `geojson` - attribute on each element of the GeoQuerySet. - - The `crs` and `bbox` keywords may be set to True if the users wants - the coordinate reference system and the bounding box to be included - in the GeoJSON representation of the geometry. - """ - backend = connections[self.db].ops - if not backend.geojson: - raise NotImplementedError('Only PostGIS 1.3.4+ and SpatiaLite 3.0+ ' - 'support GeoJSON serialization.') - - if not isinstance(precision, six.integer_types): - raise TypeError('Precision keyword must be set with an integer.') - - # Setting the options flag -- which depends on which version of - # PostGIS we're using. SpatiaLite only uses the first group of options. - if backend.spatial_version >= (1, 4, 0): - options = 0 - if crs and bbox: options = 3 - elif bbox: options = 1 - elif crs: options = 2 - else: - options = 0 - if crs and bbox: options = 3 - elif crs: options = 1 - elif bbox: options = 2 - s = {'desc' : 'GeoJSON', - 'procedure_args' : {'precision' : precision, 'options' : options}, - 'procedure_fmt' : '%(geo_col)s,%(precision)s,%(options)s', - } - return self._spatial_attribute('geojson', s, **kwargs) - - def geohash(self, precision=20, **kwargs): - """ - Returns a GeoHash representation of the given field in a `geohash` - attribute on each element of the GeoQuerySet. - - The `precision` keyword may be used to custom the number of - _characters_ used in the output GeoHash, the default is 20. - """ - s = {'desc' : 'GeoHash', - 'procedure_args': {'precision': precision}, - 'procedure_fmt': '%(geo_col)s,%(precision)s', - } - return self._spatial_attribute('geohash', s, **kwargs) - - def gml(self, precision=8, version=2, **kwargs): - """ - Returns GML representation of the given field in a `gml` attribute - on each element of the GeoQuerySet. - """ - backend = connections[self.db].ops - s = {'desc' : 'GML', 'procedure_args' : {'precision' : precision}} - if backend.postgis: - # PostGIS AsGML() aggregate function parameter order depends on the - # version -- uggh. - if backend.spatial_version > (1, 3, 1): - s['procedure_fmt'] = '%(version)s,%(geo_col)s,%(precision)s' - else: - s['procedure_fmt'] = '%(geo_col)s,%(precision)s,%(version)s' - s['procedure_args'] = {'precision' : precision, 'version' : version} - - return self._spatial_attribute('gml', s, **kwargs) - - def intersection(self, geom, **kwargs): - """ - Returns the spatial intersection of the Geometry field in - an `intersection` attribute on each element of this - GeoQuerySet. - """ - return self._geomset_attribute('intersection', geom, **kwargs) - - def kml(self, **kwargs): - """ - Returns KML representation of the geometry field in a `kml` - attribute on each element of this GeoQuerySet. - """ - s = {'desc' : 'KML', - 'procedure_fmt' : '%(geo_col)s,%(precision)s', - 'procedure_args' : {'precision' : kwargs.pop('precision', 8)}, - } - return self._spatial_attribute('kml', s, **kwargs) - - def length(self, **kwargs): - """ - Returns the length of the geometry field as a `Distance` object - stored in a `length` attribute on each element of this GeoQuerySet. - """ - return self._distance_attribute('length', None, **kwargs) - - def make_line(self, **kwargs): - """ - Creates a linestring from all of the PointField geometries in the - this GeoQuerySet and returns it. This is a spatial aggregate - method, and thus returns a geometry rather than a GeoQuerySet. - """ - return self._spatial_aggregate(aggregates.MakeLine, geo_field_type=PointField, **kwargs) - - def mem_size(self, **kwargs): - """ - Returns the memory size (number of bytes) that the geometry field takes - in a `mem_size` attribute on each element of this GeoQuerySet. - """ - return self._spatial_attribute('mem_size', {}, **kwargs) - - def num_geom(self, **kwargs): - """ - Returns the number of geometries if the field is a - GeometryCollection or Multi* Field in a `num_geom` - attribute on each element of this GeoQuerySet; otherwise - the sets with None. - """ - return self._spatial_attribute('num_geom', {}, **kwargs) - - def num_points(self, **kwargs): - """ - Returns the number of points in the first linestring in the - Geometry field in a `num_points` attribute on each element of - this GeoQuerySet; otherwise sets with None. - """ - return self._spatial_attribute('num_points', {}, **kwargs) - - def perimeter(self, **kwargs): - """ - Returns the perimeter of the geometry field as a `Distance` object - stored in a `perimeter` attribute on each element of this GeoQuerySet. - """ - return self._distance_attribute('perimeter', None, **kwargs) - - def point_on_surface(self, **kwargs): - """ - Returns a Point geometry guaranteed to lie on the surface of the - Geometry field in a `point_on_surface` attribute on each element - of this GeoQuerySet; otherwise sets with None. - """ - return self._geom_attribute('point_on_surface', **kwargs) - - def reverse_geom(self, **kwargs): - """ - Reverses the coordinate order of the geometry, and attaches as a - `reverse` attribute on each element of this GeoQuerySet. - """ - s = {'select_field' : GeomField(),} - kwargs.setdefault('model_att', 'reverse_geom') - if connections[self.db].ops.oracle: - s['geo_field_type'] = LineStringField - return self._spatial_attribute('reverse', s, **kwargs) - - def scale(self, x, y, z=0.0, **kwargs): - """ - Scales the geometry to a new size by multiplying the ordinates - with the given x,y,z scale factors. - """ - if connections[self.db].ops.spatialite: - if z != 0.0: - raise NotImplementedError('SpatiaLite does not support 3D scaling.') - s = {'procedure_fmt' : '%(geo_col)s,%(x)s,%(y)s', - 'procedure_args' : {'x' : x, 'y' : y}, - 'select_field' : GeomField(), - } - else: - s = {'procedure_fmt' : '%(geo_col)s,%(x)s,%(y)s,%(z)s', - 'procedure_args' : {'x' : x, 'y' : y, 'z' : z}, - 'select_field' : GeomField(), - } - return self._spatial_attribute('scale', s, **kwargs) - - def snap_to_grid(self, *args, **kwargs): - """ - Snap all points of the input geometry to the grid. How the - geometry is snapped to the grid depends on how many arguments - were given: - - 1 argument : A single size to snap both the X and Y grids to. - - 2 arguments: X and Y sizes to snap the grid to. - - 4 arguments: X, Y sizes and the X, Y origins. - """ - if False in [isinstance(arg, (float,) + six.integer_types) for arg in args]: - raise TypeError('Size argument(s) for the grid must be a float or integer values.') - - nargs = len(args) - if nargs == 1: - size = args[0] - procedure_fmt = '%(geo_col)s,%(size)s' - procedure_args = {'size' : size} - elif nargs == 2: - xsize, ysize = args - procedure_fmt = '%(geo_col)s,%(xsize)s,%(ysize)s' - procedure_args = {'xsize' : xsize, 'ysize' : ysize} - elif nargs == 4: - xsize, ysize, xorigin, yorigin = args - procedure_fmt = '%(geo_col)s,%(xorigin)s,%(yorigin)s,%(xsize)s,%(ysize)s' - procedure_args = {'xsize' : xsize, 'ysize' : ysize, - 'xorigin' : xorigin, 'yorigin' : yorigin} - else: - raise ValueError('Must provide 1, 2, or 4 arguments to `snap_to_grid`.') - - s = {'procedure_fmt' : procedure_fmt, - 'procedure_args' : procedure_args, - 'select_field' : GeomField(), - } - - return self._spatial_attribute('snap_to_grid', s, **kwargs) - - def svg(self, relative=False, precision=8, **kwargs): - """ - Returns SVG representation of the geographic field in a `svg` - attribute on each element of this GeoQuerySet. - - Keyword Arguments: - `relative` => If set to True, this will evaluate the path in - terms of relative moves (rather than absolute). - - `precision` => May be used to set the maximum number of decimal - digits used in output (defaults to 8). - """ - relative = int(bool(relative)) - if not isinstance(precision, six.integer_types): - raise TypeError('SVG precision keyword argument must be an integer.') - s = {'desc' : 'SVG', - 'procedure_fmt' : '%(geo_col)s,%(rel)s,%(precision)s', - 'procedure_args' : {'rel' : relative, - 'precision' : precision, - } - } - return self._spatial_attribute('svg', s, **kwargs) - - def sym_difference(self, geom, **kwargs): - """ - Returns the symmetric difference of the geographic field in a - `sym_difference` attribute on each element of this GeoQuerySet. - """ - return self._geomset_attribute('sym_difference', geom, **kwargs) - - def translate(self, x, y, z=0.0, **kwargs): - """ - Translates the geometry to a new location using the given numeric - parameters as offsets. - """ - if connections[self.db].ops.spatialite: - if z != 0.0: - raise NotImplementedError('SpatiaLite does not support 3D translation.') - s = {'procedure_fmt' : '%(geo_col)s,%(x)s,%(y)s', - 'procedure_args' : {'x' : x, 'y' : y}, - 'select_field' : GeomField(), - } - else: - s = {'procedure_fmt' : '%(geo_col)s,%(x)s,%(y)s,%(z)s', - 'procedure_args' : {'x' : x, 'y' : y, 'z' : z}, - 'select_field' : GeomField(), - } - return self._spatial_attribute('translate', s, **kwargs) - - def transform(self, srid=4326, **kwargs): - """ - Transforms the given geometry field to the given SRID. If no SRID is - provided, the transformation will default to using 4326 (WGS84). - """ - if not isinstance(srid, six.integer_types): - raise TypeError('An integer SRID must be provided.') - field_name = kwargs.get('field_name', None) - tmp, geo_field = self._spatial_setup('transform', field_name=field_name) - - # Getting the selection SQL for the given geographic field. - field_col = self._geocol_select(geo_field, field_name) - - # Why cascading substitutions? Because spatial backends like - # Oracle and MySQL already require a function call to convert to text, thus - # when there's also a transformation we need to cascade the substitutions. - # For example, 'SDO_UTIL.TO_WKTGEOMETRY(SDO_CS.TRANSFORM( ... )' - geo_col = self.query.custom_select.get(geo_field, field_col) - - # Setting the key for the field's column with the custom SELECT SQL to - # override the geometry column returned from the database. - custom_sel = '%s(%s, %s)' % (connections[self.db].ops.transform, geo_col, srid) - # TODO: Should we have this as an alias? - # custom_sel = '(%s(%s, %s)) AS %s' % (SpatialBackend.transform, geo_col, srid, qn(geo_field.name)) - self.query.transformed_srid = srid # So other GeoQuerySet methods - self.query.custom_select[geo_field] = custom_sel - return self._clone() - - def union(self, geom, **kwargs): - """ - Returns the union of the geographic field with the given - Geometry in a `union` attribute on each element of this GeoQuerySet. - """ - return self._geomset_attribute('union', geom, **kwargs) - - def unionagg(self, **kwargs): - """ - Performs an aggregate union on the given geometry field. Returns - None if the GeoQuerySet is empty. The `tolerance` keyword is for - Oracle backends only. - """ - return self._spatial_aggregate(aggregates.Union, **kwargs) - - ### Private API -- Abstracted DRY routines. ### - def _spatial_setup(self, att, desc=None, field_name=None, geo_field_type=None): - """ - Performs set up for executing the spatial function. - """ - # Does the spatial backend support this? - connection = connections[self.db] - func = getattr(connection.ops, att, False) - if desc is None: desc = att - if not func: - raise NotImplementedError('%s stored procedure not available on ' - 'the %s backend.' % - (desc, connection.ops.name)) - - # Initializing the procedure arguments. - procedure_args = {'function' : func} - - # Is there a geographic field in the model to perform this - # operation on? - geo_field = self.query._geo_field(field_name) - if not geo_field: - raise TypeError('%s output only available on GeometryFields.' % func) - - # If the `geo_field_type` keyword was used, then enforce that - # type limitation. - if not geo_field_type is None and not isinstance(geo_field, geo_field_type): - raise TypeError('"%s" stored procedures may only be called on %ss.' % (func, geo_field_type.__name__)) - - # Setting the procedure args. - procedure_args['geo_col'] = self._geocol_select(geo_field, field_name) - - return procedure_args, geo_field - - def _spatial_aggregate(self, aggregate, field_name=None, - geo_field_type=None, tolerance=0.05): - """ - DRY routine for calling aggregate spatial stored procedures and - returning their result to the caller of the function. - """ - # Getting the field the geographic aggregate will be called on. - geo_field = self.query._geo_field(field_name) - if not geo_field: - raise TypeError('%s aggregate only available on GeometryFields.' % aggregate.name) - - # Checking if there are any geo field type limitations on this - # aggregate (e.g. ST_Makeline only operates on PointFields). - if not geo_field_type is None and not isinstance(geo_field, geo_field_type): - raise TypeError('%s aggregate may only be called on %ss.' % (aggregate.name, geo_field_type.__name__)) - - # Getting the string expression of the field name, as this is the - # argument taken by `Aggregate` objects. - agg_col = field_name or geo_field.name - - # Adding any keyword parameters for the Aggregate object. Oracle backends - # in particular need an additional `tolerance` parameter. - agg_kwargs = {} - if connections[self.db].ops.oracle: agg_kwargs['tolerance'] = tolerance - - # Calling the QuerySet.aggregate, and returning only the value of the aggregate. - return self.aggregate(geoagg=aggregate(agg_col, **agg_kwargs))['geoagg'] - - def _spatial_attribute(self, att, settings, field_name=None, model_att=None): - """ - DRY routine for calling a spatial stored procedure on a geometry column - and attaching its output as an attribute of the model. - - Arguments: - att: - The name of the spatial attribute that holds the spatial - SQL function to call. - - settings: - Dictonary of internal settings to customize for the spatial procedure. - - Public Keyword Arguments: - - field_name: - The name of the geographic field to call the spatial - function on. May also be a lookup to a geometry field - as part of a foreign key relation. - - model_att: - The name of the model attribute to attach the output of - the spatial function to. - """ - # Default settings. - settings.setdefault('desc', None) - settings.setdefault('geom_args', ()) - settings.setdefault('geom_field', None) - settings.setdefault('procedure_args', {}) - settings.setdefault('procedure_fmt', '%(geo_col)s') - settings.setdefault('select_params', []) - - connection = connections[self.db] - backend = connection.ops - - # Performing setup for the spatial column, unless told not to. - if settings.get('setup', True): - default_args, geo_field = self._spatial_setup(att, desc=settings['desc'], field_name=field_name, - geo_field_type=settings.get('geo_field_type', None)) - for k, v in six.iteritems(default_args): settings['procedure_args'].setdefault(k, v) - else: - geo_field = settings['geo_field'] - - # The attribute to attach to the model. - if not isinstance(model_att, six.string_types): model_att = att - - # Special handling for any argument that is a geometry. - for name in settings['geom_args']: - # Using the field's get_placeholder() routine to get any needed - # transformation SQL. - geom = geo_field.get_prep_value(settings['procedure_args'][name]) - params = geo_field.get_db_prep_lookup('contains', geom, connection=connection) - geom_placeholder = geo_field.get_placeholder(geom, connection) - - # Replacing the procedure format with that of any needed - # transformation SQL. - old_fmt = '%%(%s)s' % name - new_fmt = geom_placeholder % '%%s' - settings['procedure_fmt'] = settings['procedure_fmt'].replace(old_fmt, new_fmt) - settings['select_params'].extend(params) - - # Getting the format for the stored procedure. - fmt = '%%(function)s(%s)' % settings['procedure_fmt'] - - # If the result of this function needs to be converted. - if settings.get('select_field', False): - sel_fld = settings['select_field'] - if isinstance(sel_fld, GeomField) and backend.select: - self.query.custom_select[model_att] = backend.select - if connection.ops.oracle: - sel_fld.empty_strings_allowed = False - self.query.extra_select_fields[model_att] = sel_fld - - # Finally, setting the extra selection attribute with - # the format string expanded with the stored procedure - # arguments. - return self.extra(select={model_att : fmt % settings['procedure_args']}, - select_params=settings['select_params']) - - def _distance_attribute(self, func, geom=None, tolerance=0.05, spheroid=False, **kwargs): - """ - DRY routine for GeoQuerySet distance attribute routines. - """ - # Setting up the distance procedure arguments. - procedure_args, geo_field = self._spatial_setup(func, field_name=kwargs.get('field_name', None)) - - # If geodetic defaulting distance attribute to meters (Oracle and - # PostGIS spherical distances return meters). Otherwise, use the - # units of the geometry field. - connection = connections[self.db] - geodetic = geo_field.geodetic(connection) - geography = geo_field.geography - - if geodetic: - dist_att = 'm' - else: - dist_att = Distance.unit_attname(geo_field.units_name(connection)) - - # Shortcut booleans for what distance function we're using and - # whether the geometry field is 3D. - distance = func == 'distance' - length = func == 'length' - perimeter = func == 'perimeter' - if not (distance or length or perimeter): - raise ValueError('Unknown distance function: %s' % func) - geom_3d = geo_field.dim == 3 - - # The field's get_db_prep_lookup() is used to get any - # extra distance parameters. Here we set up the - # parameters that will be passed in to field's function. - lookup_params = [geom or 'POINT (0 0)', 0] - - # Getting the spatial backend operations. - backend = connection.ops - - # If the spheroid calculation is desired, either by the `spheroid` - # keyword or when calculating the length of geodetic field, make - # sure the 'spheroid' distance setting string is passed in so we - # get the correct spatial stored procedure. - if spheroid or (backend.postgis and geodetic and - (not geography) and length): - lookup_params.append('spheroid') - lookup_params = geo_field.get_prep_value(lookup_params) - params = geo_field.get_db_prep_lookup('distance_lte', lookup_params, connection=connection) - - # The `geom_args` flag is set to true if a geometry parameter was - # passed in. - geom_args = bool(geom) - - if backend.oracle: - if distance: - procedure_fmt = '%(geo_col)s,%(geom)s,%(tolerance)s' - elif length or perimeter: - procedure_fmt = '%(geo_col)s,%(tolerance)s' - procedure_args['tolerance'] = tolerance - else: - # Getting whether this field is in units of degrees since the field may have - # been transformed via the `transform` GeoQuerySet method. - if self.query.transformed_srid: - u, unit_name, s = get_srid_info(self.query.transformed_srid, connection) - geodetic = unit_name in geo_field.geodetic_units - - if backend.spatialite and geodetic: - raise ValueError('SQLite does not support linear distance calculations on geodetic coordinate systems.') - - if distance: - if self.query.transformed_srid: - # Setting the `geom_args` flag to false because we want to handle - # transformation SQL here, rather than the way done by default - # (which will transform to the original SRID of the field rather - # than to what was transformed to). - geom_args = False - procedure_fmt = '%s(%%(geo_col)s, %s)' % (backend.transform, self.query.transformed_srid) - if geom.srid is None or geom.srid == self.query.transformed_srid: - # If the geom parameter srid is None, it is assumed the coordinates - # are in the transformed units. A placeholder is used for the - # geometry parameter. `GeomFromText` constructor is also needed - # to wrap geom placeholder for SpatiaLite. - if backend.spatialite: - procedure_fmt += ', %s(%%%%s, %s)' % (backend.from_text, self.query.transformed_srid) - else: - procedure_fmt += ', %%s' - else: - # We need to transform the geom to the srid specified in `transform()`, - # so wrapping the geometry placeholder in transformation SQL. - # SpatiaLite also needs geometry placeholder wrapped in `GeomFromText` - # constructor. - if backend.spatialite: - procedure_fmt += ', %s(%s(%%%%s, %s), %s)' % (backend.transform, backend.from_text, - geom.srid, self.query.transformed_srid) - else: - procedure_fmt += ', %s(%%%%s, %s)' % (backend.transform, self.query.transformed_srid) - else: - # `transform()` was not used on this GeoQuerySet. - procedure_fmt = '%(geo_col)s,%(geom)s' - - if not geography and geodetic: - # Spherical distance calculation is needed (because the geographic - # field is geodetic). However, the PostGIS ST_distance_sphere/spheroid() - # procedures may only do queries from point columns to point geometries - # some error checking is required. - if not backend.geography: - if not isinstance(geo_field, PointField): - raise ValueError('Spherical distance calculation only supported on PointFields.') - if not str(Geometry(memoryview(params[0].ewkb)).geom_type) == 'Point': - raise ValueError('Spherical distance calculation only supported with Point Geometry parameters') - # The `function` procedure argument needs to be set differently for - # geodetic distance calculations. - if spheroid: - # Call to distance_spheroid() requires spheroid param as well. - procedure_fmt += ",'%(spheroid)s'" - procedure_args.update({'function' : backend.distance_spheroid, 'spheroid' : params[1]}) - else: - procedure_args.update({'function' : backend.distance_sphere}) - elif length or perimeter: - procedure_fmt = '%(geo_col)s' - if not geography and geodetic and length: - # There's no `length_sphere`, and `length_spheroid` also - # works on 3D geometries. - procedure_fmt += ",'%(spheroid)s'" - procedure_args.update({'function' : backend.length_spheroid, 'spheroid' : params[1]}) - elif geom_3d and backend.postgis: - # Use 3D variants of perimeter and length routines on PostGIS. - if perimeter: - procedure_args.update({'function' : backend.perimeter3d}) - elif length: - procedure_args.update({'function' : backend.length3d}) - - # Setting up the settings for `_spatial_attribute`. - s = {'select_field' : DistanceField(dist_att), - 'setup' : False, - 'geo_field' : geo_field, - 'procedure_args' : procedure_args, - 'procedure_fmt' : procedure_fmt, - } - if geom_args: - s['geom_args'] = ('geom',) - s['procedure_args']['geom'] = geom - elif geom: - # The geometry is passed in as a parameter because we handled - # transformation conditions in this routine. - s['select_params'] = [backend.Adapter(geom)] - return self._spatial_attribute(func, s, **kwargs) - - def _geom_attribute(self, func, tolerance=0.05, **kwargs): - """ - DRY routine for setting up a GeoQuerySet method that attaches a - Geometry attribute (e.g., `centroid`, `point_on_surface`). - """ - s = {'select_field' : GeomField(),} - if connections[self.db].ops.oracle: - s['procedure_fmt'] = '%(geo_col)s,%(tolerance)s' - s['procedure_args'] = {'tolerance' : tolerance} - return self._spatial_attribute(func, s, **kwargs) - - def _geomset_attribute(self, func, geom, tolerance=0.05, **kwargs): - """ - DRY routine for setting up a GeoQuerySet method that attaches a - Geometry attribute and takes a Geoemtry parameter. This is used - for geometry set-like operations (e.g., intersection, difference, - union, sym_difference). - """ - s = {'geom_args' : ('geom',), - 'select_field' : GeomField(), - 'procedure_fmt' : '%(geo_col)s,%(geom)s', - 'procedure_args' : {'geom' : geom}, - } - if connections[self.db].ops.oracle: - s['procedure_fmt'] += ',%(tolerance)s' - s['procedure_args']['tolerance'] = tolerance - return self._spatial_attribute(func, s, **kwargs) - - def _geocol_select(self, geo_field, field_name): - """ - Helper routine for constructing the SQL to select the geographic - column. Takes into account if the geographic field is in a - ForeignKey relation to the current model. - """ - opts = self.model._meta - if not geo_field in opts.fields: - # Is this operation going to be on a related geographic field? - # If so, it'll have to be added to the select related information - # (e.g., if 'location__point' was given as the field name). - self.query.add_select_related([field_name]) - compiler = self.query.get_compiler(self.db) - compiler.pre_sql_setup() - for (rel_table, rel_col), field in self.query.related_select_cols: - if field == geo_field: - return compiler._field_column(geo_field, rel_table) - raise ValueError("%r not in self.query.related_select_cols" % geo_field) - elif not geo_field in opts.local_fields: - # This geographic field is inherited from another model, so we have to - # use the db table for the _parent_ model instead. - tmp_fld, parent_model, direct, m2m = opts.get_field_by_name(geo_field.name) - return self.query.get_compiler(self.db)._field_column(geo_field, parent_model._meta.db_table) - else: - return self.query.get_compiler(self.db)._field_column(geo_field) - -class GeoValuesQuerySet(ValuesQuerySet): - def __init__(self, *args, **kwargs): - super(GeoValuesQuerySet, self).__init__(*args, **kwargs) - # This flag tells `resolve_columns` to run the values through - # `convert_values`. This ensures that Geometry objects instead - # of string values are returned with `values()` or `values_list()`. - self.query.geo_values = True - -class GeoValuesListQuerySet(GeoValuesQuerySet, ValuesListQuerySet): - pass diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/__init__.py deleted file mode 100644 index 38d9507..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from django.contrib.gis.db.models.sql.conversion import AreaField, DistanceField, GeomField -from django.contrib.gis.db.models.sql.query import GeoQuery -from django.contrib.gis.db.models.sql.where import GeoWhereNode diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/aggregates.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/aggregates.py deleted file mode 100644 index ae848c0..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/aggregates.py +++ /dev/null @@ -1,62 +0,0 @@ -from django.db.models.sql.aggregates import * -from django.contrib.gis.db.models.fields import GeometryField - -class GeoAggregate(Aggregate): - # Default SQL template for spatial aggregates. - sql_template = '%(function)s(%(field)s)' - - # Conversion class, if necessary. - conversion_class = None - - # Flags for indicating the type of the aggregate. - is_extent = False - - def __init__(self, col, source=None, is_summary=False, tolerance=0.05, **extra): - super(GeoAggregate, self).__init__(col, source, is_summary, **extra) - - # Required by some Oracle aggregates. - self.tolerance = tolerance - - # Can't use geographic aggregates on non-geometry fields. - if not isinstance(self.source, GeometryField): - raise ValueError('Geospatial aggregates only allowed on geometry fields.') - - def as_sql(self, qn, connection): - "Return the aggregate, rendered as SQL with parameters." - - if connection.ops.oracle: - self.extra['tolerance'] = self.tolerance - - params = [] - - if hasattr(self.col, 'as_sql'): - field_name, params = self.col.as_sql(qn, connection) - elif isinstance(self.col, (list, tuple)): - field_name = '.'.join([qn(c) for c in self.col]) - else: - field_name = self.col - - sql_template, sql_function = connection.ops.spatial_aggregate_sql(self) - - substitutions = { - 'function': sql_function, - 'field': field_name - } - substitutions.update(self.extra) - - return sql_template % substitutions, params - -class Collect(GeoAggregate): - pass - -class Extent(GeoAggregate): - is_extent = '2D' - -class Extent3D(GeoAggregate): - is_extent = '3D' - -class MakeLine(GeoAggregate): - pass - -class Union(GeoAggregate): - pass diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/compiler.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/compiler.py deleted file mode 100644 index 3fc9c17..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/compiler.py +++ /dev/null @@ -1,313 +0,0 @@ -import datetime - -from django.conf import settings -from django.db.backends.util import truncate_name, typecast_date, typecast_timestamp -from django.db.models.sql import compiler -from django.db.models.sql.constants import MULTI -from django.utils import six -from django.utils.six.moves import zip, zip_longest -from django.utils import timezone - -SQLCompiler = compiler.SQLCompiler - -class GeoSQLCompiler(compiler.SQLCompiler): - - def get_columns(self, with_aliases=False): - """ - Return the list of columns to use in the select statement. If no - columns have been specified, returns all columns relating to fields in - the model. - - If 'with_aliases' is true, any column names that are duplicated - (without the table names) are given unique aliases. This is needed in - some cases to avoid ambiguitity with nested queries. - - This routine is overridden from Query to handle customized selection of - geometry columns. - """ - qn = self.quote_name_unless_alias - qn2 = self.connection.ops.quote_name - result = ['(%s) AS %s' % (self.get_extra_select_format(alias) % col[0], qn2(alias)) - for alias, col in six.iteritems(self.query.extra_select)] - params = [] - aliases = set(self.query.extra_select.keys()) - if with_aliases: - col_aliases = aliases.copy() - else: - col_aliases = set() - if self.query.select: - only_load = self.deferred_to_columns() - # This loop customized for GeoQuery. - for col, field in self.query.select: - if isinstance(col, (list, tuple)): - alias, column = col - table = self.query.alias_map[alias].table_name - if table in only_load and column not in only_load[table]: - continue - r = self.get_field_select(field, alias, column) - if with_aliases: - if col[1] in col_aliases: - c_alias = 'Col%d' % len(col_aliases) - result.append('%s AS %s' % (r, c_alias)) - aliases.add(c_alias) - col_aliases.add(c_alias) - else: - result.append('%s AS %s' % (r, qn2(col[1]))) - aliases.add(r) - col_aliases.add(col[1]) - else: - result.append(r) - aliases.add(r) - col_aliases.add(col[1]) - else: - col_sql, col_params = col.as_sql(qn, self.connection) - result.append(col_sql) - params.extend(col_params) - - if hasattr(col, 'alias'): - aliases.add(col.alias) - col_aliases.add(col.alias) - - elif self.query.default_cols: - cols, new_aliases = self.get_default_columns(with_aliases, - col_aliases) - result.extend(cols) - aliases.update(new_aliases) - - max_name_length = self.connection.ops.max_name_length() - for alias, aggregate in self.query.aggregate_select.items(): - agg_sql, agg_params = aggregate.as_sql(qn, self.connection) - if alias is None: - result.append(agg_sql) - else: - result.append('%s AS %s' % (agg_sql, qn(truncate_name(alias, max_name_length)))) - params.extend(agg_params) - - # This loop customized for GeoQuery. - for (table, col), field in self.query.related_select_cols: - r = self.get_field_select(field, table, col) - if with_aliases and col in col_aliases: - c_alias = 'Col%d' % len(col_aliases) - result.append('%s AS %s' % (r, c_alias)) - aliases.add(c_alias) - col_aliases.add(c_alias) - else: - result.append(r) - aliases.add(r) - col_aliases.add(col) - - self._select_aliases = aliases - return result, params - - def get_default_columns(self, with_aliases=False, col_aliases=None, - start_alias=None, opts=None, as_pairs=False, from_parent=None): - """ - Computes the default columns for selecting every field in the base - model. Will sometimes be called to pull in related models (e.g. via - select_related), in which case "opts" and "start_alias" will be given - to provide a starting point for the traversal. - - Returns a list of strings, quoted appropriately for use in SQL - directly, as well as a set of aliases used in the select statement (if - 'as_pairs' is True, returns a list of (alias, col_name) pairs instead - of strings as the first component and None as the second component). - - This routine is overridden from Query to handle customized selection of - geometry columns. - """ - result = [] - if opts is None: - opts = self.query.get_meta() - aliases = set() - only_load = self.deferred_to_columns() - seen = self.query.included_inherited_models.copy() - if start_alias: - seen[None] = start_alias - for field, model in opts.get_concrete_fields_with_model(): - if from_parent and model is not None and issubclass(from_parent, model): - # Avoid loading data for already loaded parents. - continue - alias = self.query.join_parent_model(opts, model, start_alias, seen) - table = self.query.alias_map[alias].table_name - if table in only_load and field.column not in only_load[table]: - continue - if as_pairs: - result.append((alias, field)) - aliases.add(alias) - continue - # This part of the function is customized for GeoQuery. We - # see if there was any custom selection specified in the - # dictionary, and set up the selection format appropriately. - field_sel = self.get_field_select(field, alias) - if with_aliases and field.column in col_aliases: - c_alias = 'Col%d' % len(col_aliases) - result.append('%s AS %s' % (field_sel, c_alias)) - col_aliases.add(c_alias) - aliases.add(c_alias) - else: - r = field_sel - result.append(r) - aliases.add(r) - if with_aliases: - col_aliases.add(field.column) - return result, aliases - - def resolve_columns(self, row, fields=()): - """ - This routine is necessary so that distances and geometries returned - from extra selection SQL get resolved appropriately into Python - objects. - """ - values = [] - aliases = list(self.query.extra_select) - - # Have to set a starting row number offset that is used for - # determining the correct starting row index -- needed for - # doing pagination with Oracle. - rn_offset = 0 - if self.connection.ops.oracle: - if self.query.high_mark is not None or self.query.low_mark: rn_offset = 1 - index_start = rn_offset + len(aliases) - - # Converting any extra selection values (e.g., geometries and - # distance objects added by GeoQuerySet methods). - values = [self.query.convert_values(v, - self.query.extra_select_fields.get(a, None), - self.connection) - for v, a in zip(row[rn_offset:index_start], aliases)] - if self.connection.ops.oracle or getattr(self.query, 'geo_values', False): - # We resolve the rest of the columns if we're on Oracle or if - # the `geo_values` attribute is defined. - for value, field in zip_longest(row[index_start:], fields): - values.append(self.query.convert_values(value, field, self.connection)) - else: - values.extend(row[index_start:]) - return tuple(values) - - #### Routines unique to GeoQuery #### - def get_extra_select_format(self, alias): - sel_fmt = '%s' - if hasattr(self.query, 'custom_select') and alias in self.query.custom_select: - sel_fmt = sel_fmt % self.query.custom_select[alias] - return sel_fmt - - def get_field_select(self, field, alias=None, column=None): - """ - Returns the SELECT SQL string for the given field. Figures out - if any custom selection SQL is needed for the column The `alias` - keyword may be used to manually specify the database table where - the column exists, if not in the model associated with this - `GeoQuery`. Similarly, `column` may be used to specify the exact - column name, rather than using the `column` attribute on `field`. - """ - sel_fmt = self.get_select_format(field) - if field in self.query.custom_select: - field_sel = sel_fmt % self.query.custom_select[field] - else: - field_sel = sel_fmt % self._field_column(field, alias, column) - return field_sel - - def get_select_format(self, fld): - """ - Returns the selection format string, depending on the requirements - of the spatial backend. For example, Oracle and MySQL require custom - selection formats in order to retrieve geometries in OGC WKT. For all - other fields a simple '%s' format string is returned. - """ - if self.connection.ops.select and hasattr(fld, 'geom_type'): - # This allows operations to be done on fields in the SELECT, - # overriding their values -- used by the Oracle and MySQL - # spatial backends to get database values as WKT, and by the - # `transform` method. - sel_fmt = self.connection.ops.select - - # Because WKT doesn't contain spatial reference information, - # the SRID is prefixed to the returned WKT to ensure that the - # transformed geometries have an SRID different than that of the - # field -- this is only used by `transform` for Oracle and - # SpatiaLite backends. - if self.query.transformed_srid and ( self.connection.ops.oracle or - self.connection.ops.spatialite ): - sel_fmt = "'SRID=%d;'||%s" % (self.query.transformed_srid, sel_fmt) - else: - sel_fmt = '%s' - return sel_fmt - - # Private API utilities, subject to change. - def _field_column(self, field, table_alias=None, column=None): - """ - Helper function that returns the database column for the given field. - The table and column are returned (quoted) in the proper format, e.g., - `"geoapp_city"."point"`. If `table_alias` is not specified, the - database table associated with the model of this `GeoQuery` will be - used. If `column` is specified, it will be used instead of the value - in `field.column`. - """ - if table_alias is None: table_alias = self.query.get_meta().db_table - return "%s.%s" % (self.quote_name_unless_alias(table_alias), - self.connection.ops.quote_name(column or field.column)) - -class SQLInsertCompiler(compiler.SQLInsertCompiler, GeoSQLCompiler): - pass - -class SQLDeleteCompiler(compiler.SQLDeleteCompiler, GeoSQLCompiler): - pass - -class SQLUpdateCompiler(compiler.SQLUpdateCompiler, GeoSQLCompiler): - pass - -class SQLAggregateCompiler(compiler.SQLAggregateCompiler, GeoSQLCompiler): - pass - -class SQLDateCompiler(compiler.SQLDateCompiler, GeoSQLCompiler): - """ - This is overridden for GeoDjango to properly cast date columns, since - `GeoQuery.resolve_columns` is used for spatial values. - See #14648, #16757. - """ - def results_iter(self): - if self.connection.ops.oracle: - from django.db.models.fields import DateTimeField - fields = [DateTimeField()] - else: - needs_string_cast = self.connection.features.needs_datetime_string_cast - - offset = len(self.query.extra_select) - for rows in self.execute_sql(MULTI): - for row in rows: - date = row[offset] - if self.connection.ops.oracle: - date = self.resolve_columns(row, fields)[offset] - elif needs_string_cast: - date = typecast_date(str(date)) - if isinstance(date, datetime.datetime): - date = date.date() - yield date - -class SQLDateTimeCompiler(compiler.SQLDateTimeCompiler, GeoSQLCompiler): - """ - This is overridden for GeoDjango to properly cast date columns, since - `GeoQuery.resolve_columns` is used for spatial values. - See #14648, #16757. - """ - def results_iter(self): - if self.connection.ops.oracle: - from django.db.models.fields import DateTimeField - fields = [DateTimeField()] - else: - needs_string_cast = self.connection.features.needs_datetime_string_cast - - offset = len(self.query.extra_select) - for rows in self.execute_sql(MULTI): - for row in rows: - datetime = row[offset] - if self.connection.ops.oracle: - datetime = self.resolve_columns(row, fields)[offset] - elif needs_string_cast: - datetime = typecast_timestamp(str(datetime)) - # Datetimes are artifically returned in UTC on databases that - # don't support time zone. Restore the zone used in the query. - if settings.USE_TZ: - datetime = datetime.replace(tzinfo=None) - datetime = timezone.make_aware(datetime, self.query.tzinfo) - yield datetime diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/conversion.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/conversion.py deleted file mode 100644 index 160b623..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/conversion.py +++ /dev/null @@ -1,27 +0,0 @@ -""" -This module holds simple classes used by GeoQuery.convert_values -to convert geospatial values from the database. -""" - -class BaseField(object): - empty_strings_allowed = True - def get_internal_type(self): - "Overloaded method so OracleQuery.convert_values doesn't balk." - return None - -class AreaField(BaseField): - "Wrapper for Area values." - def __init__(self, area_att): - self.area_att = area_att - -class DistanceField(BaseField): - "Wrapper for Distance values." - def __init__(self, distance_att): - self.distance_att = distance_att - -class GeomField(BaseField): - """ - Wrapper for Geometry values. It is a lightweight alternative to - using GeometryField (which requires an SQL query upon instantiation). - """ - pass diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/query.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/query.py deleted file mode 100644 index 5877f29..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/query.py +++ /dev/null @@ -1,121 +0,0 @@ -from django.db import connections -from django.db.models.query import sql - -from django.contrib.gis.db.models.fields import GeometryField -from django.contrib.gis.db.models.sql import aggregates as gis_aggregates -from django.contrib.gis.db.models.sql.conversion import AreaField, DistanceField, GeomField -from django.contrib.gis.db.models.sql.where import GeoWhereNode -from django.contrib.gis.geometry.backend import Geometry -from django.contrib.gis.measure import Area, Distance - - -ALL_TERMS = set([ - 'bbcontains', 'bboverlaps', 'contained', 'contains', - 'contains_properly', 'coveredby', 'covers', 'crosses', 'disjoint', - 'distance_gt', 'distance_gte', 'distance_lt', 'distance_lte', - 'dwithin', 'equals', 'exact', - 'intersects', 'overlaps', 'relate', 'same_as', 'touches', 'within', - 'left', 'right', 'overlaps_left', 'overlaps_right', - 'overlaps_above', 'overlaps_below', - 'strictly_above', 'strictly_below' - ]) -ALL_TERMS.update(sql.constants.QUERY_TERMS) - -class GeoQuery(sql.Query): - """ - A single spatial SQL query. - """ - # Overridding the valid query terms. - query_terms = ALL_TERMS - aggregates_module = gis_aggregates - - compiler = 'GeoSQLCompiler' - - #### Methods overridden from the base Query class #### - def __init__(self, model, where=GeoWhereNode): - super(GeoQuery, self).__init__(model, where) - # The following attributes are customized for the GeoQuerySet. - # The GeoWhereNode and SpatialBackend classes contain backend-specific - # routines and functions. - self.custom_select = {} - self.transformed_srid = None - self.extra_select_fields = {} - - def clone(self, *args, **kwargs): - obj = super(GeoQuery, self).clone(*args, **kwargs) - # Customized selection dictionary and transformed srid flag have - # to also be added to obj. - obj.custom_select = self.custom_select.copy() - obj.transformed_srid = self.transformed_srid - obj.extra_select_fields = self.extra_select_fields.copy() - return obj - - def convert_values(self, value, field, connection): - """ - Using the same routines that Oracle does we can convert our - extra selection objects into Geometry and Distance objects. - TODO: Make converted objects 'lazy' for less overhead. - """ - if connection.ops.oracle: - # Running through Oracle's first. - value = super(GeoQuery, self).convert_values(value, field or GeomField(), connection) - - if value is None: - # Output from spatial function is NULL (e.g., called - # function on a geometry field with NULL value). - pass - elif isinstance(field, DistanceField): - # Using the field's distance attribute, can instantiate - # `Distance` with the right context. - value = Distance(**{field.distance_att : value}) - elif isinstance(field, AreaField): - value = Area(**{field.area_att : value}) - elif isinstance(field, (GeomField, GeometryField)) and value: - value = Geometry(value) - elif field is not None: - return super(GeoQuery, self).convert_values(value, field, connection) - return value - - def get_aggregation(self, using): - # Remove any aggregates marked for reduction from the subquery - # and move them to the outer AggregateQuery. - connection = connections[using] - for alias, aggregate in self.aggregate_select.items(): - if isinstance(aggregate, gis_aggregates.GeoAggregate): - if not getattr(aggregate, 'is_extent', False) or connection.ops.oracle: - self.extra_select_fields[alias] = GeomField() - return super(GeoQuery, self).get_aggregation(using) - - def resolve_aggregate(self, value, aggregate, connection): - """ - Overridden from GeoQuery's normalize to handle the conversion of - GeoAggregate objects. - """ - if isinstance(aggregate, self.aggregates_module.GeoAggregate): - if aggregate.is_extent: - if aggregate.is_extent == '3D': - return connection.ops.convert_extent3d(value) - else: - return connection.ops.convert_extent(value) - else: - return connection.ops.convert_geom(value, aggregate.source) - else: - return super(GeoQuery, self).resolve_aggregate(value, aggregate, connection) - - # Private API utilities, subject to change. - def _geo_field(self, field_name=None): - """ - Returns the first Geometry field encountered; or specified via the - `field_name` keyword. The `field_name` may be a string specifying - the geometry field on this GeoQuery's model, or a lookup string - to a geometry field via a ForeignKey relation. - """ - if field_name is None: - # Incrementing until the first geographic field is found. - for fld in self.model._meta.fields: - if isinstance(fld, GeometryField): return fld - return False - else: - # Otherwise, check by the given field name -- which may be - # a lookup to a _related_ geographic field. - return GeoWhereNode._check_geo_field(self.model._meta, field_name) diff --git a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/where.py b/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/where.py deleted file mode 100644 index c29533b..0000000 --- a/lib/python2.7/site-packages/django/contrib/gis/db/models/sql/where.py +++ /dev/null @@ -1,91 +0,0 @@ -from django.db.models.constants import LOOKUP_SEP -from django.db.models.fields import FieldDoesNotExist -from django.db.models.sql.expressions import SQLEvaluator -from django.db.models.sql.where import Constraint, WhereNode -from django.contrib.gis.db.models.fields import GeometryField - -class GeoConstraint(Constraint): - """ - This subclass overrides `process` to better handle geographic SQL - construction. - """ - def __init__(self, init_constraint): - self.alias = init_constraint.alias - self.col = init_constraint.col - self.field = init_constraint.field - - def process(self, lookup_type, value, connection): - if isinstance(value, SQLEvaluator): - # Make sure the F Expression destination field exists, and - # set an `srid` attribute with the same as that of the - # destination. - geo_fld = GeoWhereNode._check_geo_field(value.opts, value.expression.name) - if not geo_fld: - raise ValueError('No geographic field found in expression.') - value.srid = geo_fld.srid - db_type = self.field.db_type(connection=connection) - params = self.field.get_db_prep_lookup(lookup_type, value, connection=connection) - return (self.alias, self.col, db_type), params - -class GeoWhereNode(WhereNode): - """ - Used to represent the SQL where-clause for spatial databases -- - these are tied to the GeoQuery class that created it. - """ - - def _prepare_data(self, data): - if isinstance(data, (list, tuple)): - obj, lookup_type, value = data - if ( isinstance(obj, Constraint) and - isinstance(obj.field, GeometryField) ): - data = (GeoConstraint(obj), lookup_type, value) - return super(GeoWhereNode, self)._prepare_data(data) - - def make_atom(self, child, qn, connection): - lvalue, lookup_type, value_annot, params_or_value = child - if isinstance(lvalue, GeoConstraint): - data, params = lvalue.process(lookup_type, params_or_value, connection) - spatial_sql, spatial_params = connection.ops.spatial_lookup_sql( - data, lookup_type, params_or_value, lvalue.field, qn) - return spatial_sql, spatial_params + params - else: - return super(GeoWhereNode, self).make_atom(child, qn, connection) - - @classmethod - def _check_geo_field(cls, opts, lookup): - """ - Utility for checking the given lookup with the given model options. - The lookup is a string either specifying the geographic field, e.g. - 'point, 'the_geom', or a related lookup on a geographic field like - 'address__point'. - - If a GeometryField exists according to the given lookup on the model - options, it will be returned. Otherwise returns None. - """ - # This takes into account the situation where the lookup is a - # lookup to a related geographic field, e.g., 'address__point'. - field_list = lookup.split(LOOKUP_SEP) - - # Reversing so list operates like a queue of related lookups, - # and popping the top lookup. - field_list.reverse() - fld_name = field_list.pop() - - try: - geo_fld = opts.get_field(fld_name) - # If the field list is still around, then it means that the - # lookup was for a geometry field across a relationship -- - # thus we keep on getting the related model options and the - # model field associated with the next field in the list - # until there's no more left. - while len(field_list): - opts = geo_fld.rel.to._meta - geo_fld = opts.get_field(field_list.pop()) - except (FieldDoesNotExist, AttributeError): - return False - - # Finally, make sure we got a Geographic field and return. - if isinstance(geo_fld, GeometryField): - return geo_fld - else: - return False |