Changeset 5776

Timestamp:

07/29/07 14:58:24 (1 year ago)

Author:

jbronn

Message:

gis: created backend module, that will (in the future) allow for support of different spatial databases; improved postgis-specific code in preparation for PostGIS 1.2.2 (and beyond).

Files:

• django/branches/gis/django/contrib/gis/db/backend (added)
• django/branches/gis/django/contrib/gis/db/backend/__init__.py (added)
• django/branches/gis/django/contrib/gis/db/backend/postgis (added)
• django/branches/gis/django/contrib/gis/db/backend/postgis/creation.py (moved) (moved from django/branches/gis/django/contrib/gis/utils/spatial_db.py)
• django/branches/gis/django/contrib/gis/db/backend/postgis/field.py (added)
• django/branches/gis/django/contrib/gis/db/backend/postgis/__init__.py (added)
• django/branches/gis/django/contrib/gis/db/backend/postgis/management.py (added)
• django/branches/gis/django/contrib/gis/db/backend/postgis/query.py (moved) (moved from django/branches/gis/django/contrib/gis/db/models/postgis.py) (6 diffs)
• django/branches/gis/django/contrib/gis/db/models/fields/__init__.py (modified) (3 diffs)
• django/branches/gis/django/contrib/gis/db/models/query.py (modified) (1 diff)
• django/branches/gis/django/contrib/gis/tests/geoapp/tests.py (modified) (1 diff)
• django/branches/gis/django/contrib/gis/tests/__init__.py (modified) (1 diff)

django/branches/gis/django/contrib/gis/db/backend/postgis/query.py

@@ -1 @@
-
-
+
+
+
+
-from django.db import backend
-
-
+
+
+
+
+
+
+
+
+
+
-
-# PostGIS-specific operators. The commented descriptions of these
@@ -9 +19 @@
-POSTGIS_OPERATORS = {
-    # The "&<" operator returns true if A's bounding box overlaps or is to the left of B's bounding box.
- %s
+
-    # The "&>" operator returns true if A's bounding box overlaps or is to the right of B's bounding box.
- %s
+
-    # The "<<" operator returns true if A's bounding box is strictly to the left of B's bounding box.
- %s
+
-    # The ">>" operator returns true if A's bounding box is strictly to the right of B's bounding box.
- %s
+
-    # The "&<|" operator returns true if A's bounding box overlaps or is below B's bounding box.
- %s
+
-    # The "|&>" operator returns true if A's bounding box overlaps or is above B's bounding box.
- %s
+
-    # The "<<|" operator returns true if A's bounding box is strictly below B's bounding box.
- %s
+
-    # The "|>>" operator returns true if A's bounding box is strictly above B's bounding box.
- %s
+
-    # 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.
- %s
- %s
+
+
-    # The "@" operator returns true if A's bounding box is completely contained by B's bounding box.
- %s
+
-    # The "~" operator returns true if A's bounding box completely contains B's bounding box.
- %s
+
-    # The "&&" operator is the "overlaps" operator. If A's bounding boux overlaps B's bounding box the
-    # operator returns true.
- %s
+
-    }
-
-
+
+
+
+
+
-POSTGIS_GEOMETRY_FUNCTIONS = {
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    }
+
+# Versions of PostGIS >= 1.2.2 changed their naming convention to be 'SQL-MM-centric'.
+#  Practically, this means that 'ST_' is appended to geometry function names.
+if MINOR_VERSION1 >= 2 and MINOR_VERSION2 >= 2:
+    # The ST_DWithin, ST_CoveredBy, and ST_Covers routines become available in 1.2.2.
+    POSTGIS_GEOMETRY_FUNCTIONS.update(
+        {'dwithin' : ('%sDWithin', float),
+         'coveredby' : '%sCoveredBy',
+         'covers' : '%sCovers',
+         }
+        )
+    GEOM_FUNC_PREFIX = 'ST_'
+else:
+    GEOM_FUNC_PREFIX = ''
+
+# Updating with the geometry function prefix.
+for k, v in POSTGIS_GEOMETRY_FUNCTIONS.items():
+    if isinstance(v, tuple):
+        v = list(v)
+        v[0] = v[0] % GEOM_FUNC_PREFIX
+        v = tuple(v)
+    else:
+        v = v % GEOM_FUNC_PREFIX
+    POSTGIS_GEOMETRY_FUNCTIONS[k] = v
-
-# Any other lookup types that do not require a mapping.
@@ -59 +96 @@
-    else: return "'%s'" % value
-
-, combines both the operator
-and the geometry function
+ -- a list of the lookup type
+ allowed for geographic querie
-POSTGIS_TERMS = list(POSTGIS_OPERATORS.keys()) # Getting the operators first
-POSTGIS_TERMS += list(POSTGIS_GEOMETRY_FUNCTIONS.keys()) # Adding on the Geometry Functions
@@ -67 +104 @@
-
-def get_geo_where_clause(lookup_type, table_prefix, field_name, value):
+    "Returns the SQL WHERE clause for use in PostGIS SQL construction."
-    if table_prefix.endswith('.'):
-        table_prefix = backend.quote_name(table_prefix[:-1])+'.'
@@ -73 +111 @@
-    # See if a PostGIS operator matches the lookup type first
-    try:
-' % (table_prefix, field_name, (POSTGIS_OPERATORS[lookup_type] % '%s')
+ %%s' % (table_prefix, field_name, POSTGIS_OPERATORS[lookup_type]
-    except KeyError:
-        pass
@@ -83 +121 @@
-        pass
-    
-For any other
+Handling 'isnull'
-    if lookup_type == 'isnull':
-        return "%s%s IS %sNULL" % (table_prefix, field_name, (not value and 'NOT ' or ''))
-
-    raise TypeError, "Got invalid lookup_type: %s" % repr(lookup_type)
-
-####    query.py overloaded functions    ####
-# parse_lookup() and lookup_inner() are modified from their django/db/models/query.py
-#  counterparts to support constructing SQL for geographic queries.
-#
-# Status: Synced with r5609.
-#
-def parse_lookup(kwarg_items, opts):
-    # Helper function that handles converting API kwargs
-    # (e.g. "name__exact": "tom") to SQL.
-    # Returns a tuple of (joins, where, params).
-
-    # 'joins' is a sorted dictionary describing the tables that must be joined
-    # to complete the query. The dictionary is sorted because creation order
-    # is significant; it is a dictionary to ensure uniqueness of alias names.
-    #
-    # Each key-value pair follows the form
-    #   alias: (table, join_type, condition)
-    # where
-    #   alias is the AS alias for the joined table
-    #   table is the actual table name to be joined
-    #   join_type is the type of join (INNER JOIN, LEFT OUTER JOIN, etc)
-    #   condition is the where-like statement over which narrows the join.
-    #   alias will be derived from the lookup list name.
-    #
-    # At present, this method only every returns INNER JOINs; the option is
-    # there for others to implement custom Q()s, etc that return other join
-    # types.
-    joins, where, params = SortedDict(), [], []
-
-    for kwarg, value in kwarg_items:
-        path = kwarg.split(LOOKUP_SEPARATOR)
-        # Extract the last elements of the kwarg.
-        # The very-last is the lookup_type (equals, like, etc).
-        # The second-last is the table column on which the lookup_type is
-        # to be performed. If this name is 'pk', it will be substituted with
-        # the name of the primary key.
-        # If there is only one part, or the last part is not a query
-        # term, assume that the query is an __exact
-        lookup_type = path.pop()
-        if lookup_type == 'pk':
-            lookup_type = 'exact'
-            path.append(None)
-        elif len(path) == 0 or not ((lookup_type in QUERY_TERMS) or (lookup_type in POSTGIS_TERMS)):
-            path.append(lookup_type)
-            lookup_type = 'exact'
-
-        if len(path) < 1:
-            raise TypeError, "Cannot parse keyword query %r" % kwarg
-
-        if value is None:
-            # Interpret '__exact=None' as the sql '= NULL'; otherwise, reject
-            # all uses of None as a query value.
-            if lookup_type != 'exact':
-                raise ValueError, "Cannot use None as a query value"
-        elif callable(value):
-            value = value()
-
-        joins2, where2, params2 = lookup_inner(path, lookup_type, value, opts, opts.db_table, None)
-        joins.update(joins2)
-        where.extend(where2)
-        params.extend(params2)
-    return joins, where, params
-
-def lookup_inner(path, lookup_type, value, opts, table, column):
-    qn = backend.quote_name
-    joins, where, params = SortedDict(), [], []
-    current_opts = opts
-    current_table = table
-    current_column = column
-    intermediate_table = None
-    join_required = False
-
-    name = path.pop(0)
-    # Has the primary key been requested? If so, expand it out
-    # to be the name of the current class' primary key
-    if name is None or name == 'pk':
-        name = current_opts.pk.name
-
-    # Try to find the name in the fields associated with the current class
-    try:
-        # Does the name belong to a defined many-to-many field?
-        field = find_field(name, current_opts.many_to_many, False)
-        if field:
-            new_table = current_table + '__' + name
-            new_opts = field.rel.to._meta
-            new_column = new_opts.pk.column
-
-            # Need to create an intermediate table join over the m2m table
-            # This process hijacks current_table/column to point to the
-            # intermediate table.
-            current_table = "m2m_" + new_table
-            intermediate_table = field.m2m_db_table()
-            join_column = field.m2m_reverse_name()
-            intermediate_column = field.m2m_column_name()
-
-            raise FieldFound
-
-        # Does the name belong to a reverse defined many-to-many field?
-        field = find_field(name, current_opts.get_all_related_many_to_many_objects(), True)
-        if field:
-            new_table = current_table + '__' + name
-            new_opts = field.opts
-            new_column = new_opts.pk.column
-
-            # Need to create an intermediate table join over the m2m table.
-            # This process hijacks current_table/column to point to the
-            # intermediate table.
-            current_table = "m2m_" + new_table
-            intermediate_table = field.field.m2m_db_table()
-            join_column = field.field.m2m_column_name()
-            intermediate_column = field.field.m2m_reverse_name()
-
-            raise FieldFound
-
-        # Does the name belong to a one-to-many field?
-        field = find_field(name, current_opts.get_all_related_objects(), True)
-        if field:
-            new_table = table + '__' + name
-            new_opts = field.opts
-            new_column = field.field.column
-            join_column = opts.pk.column
-
-            # 1-N fields MUST be joined, regardless of any other conditions.
-            join_required = True
-
-            raise FieldFound
-
-        # Does the name belong to a one-to-one, many-to-one, or regular field?
-        field = find_field(name, current_opts.fields, False)
-        if field:
-            if field.rel: # One-to-One/Many-to-one field
-                new_table = current_table + '__' + name
-                new_opts = field.rel.to._meta
-                new_column = new_opts.pk.column
-                join_column = field.column
-                raise FieldFound
-            elif path:
-                # For regular fields, if there are still items on the path,
-                # an error has been made. We munge "name" so that the error
-                # properly identifies the cause of the problem.
-                name += LOOKUP_SEPARATOR + path[0]
-            else:
-                raise FieldFound
-
-    except FieldFound: # Match found, loop has been shortcut.
-        pass
-    else: # No match found.
-        choices = field_choices(current_opts.many_to_many, False) + \
-            field_choices(current_opts.get_all_related_many_to_many_objects(), True) + \
-            field_choices(current_opts.get_all_related_objects(), True) + \
-            field_choices(current_opts.fields, False)
-        raise TypeError, "Cannot resolve keyword '%s' into field. Choices are: %s" % (name, ", ".join(choices))
-
-    # Check whether an intermediate join is required between current_table
-    # and new_table.
-    if intermediate_table:
-        joins[qn(current_table)] = (
-            qn(intermediate_table), "LEFT OUTER JOIN",
-            "%s.%s = %s.%s" % (qn(table), qn(current_opts.pk.column), qn(current_table), qn(intermediate_column))
-        )
-
-    if path:
-        # There are elements left in the path. More joins are required.
-        if len(path) == 1 and path[0] in (new_opts.pk.name, None) \
-            and lookup_type in ('exact', 'isnull') and not join_required:
-            # If the next and final name query is for a primary key,
-            # and the search is for isnull/exact, then the current
-            # (for N-1) or intermediate (for N-N) table can be used
-            # for the search. No need to join an extra table just
-            # to check the primary key.
-            new_table = current_table
-        else:
-            # There are 1 or more name queries pending, and we have ruled out
-            # any shortcuts; therefore, a join is required.
-            joins[qn(new_table)] = (
-                qn(new_opts.db_table), "INNER JOIN",
-                "%s.%s = %s.%s" % (qn(current_table), qn(join_column), qn(new_table), qn(new_column))
-            )
-            # If we have made the join, we don't need to tell subsequent
-            # recursive calls about the column name we joined on.
-            join_column = None
-
-        # There are name queries remaining. Recurse deeper.
-        joins2, where2, params2 = lookup_inner(path, lookup_type, value, new_opts, new_table, join_column)
-
-        joins.update(joins2)
-        where.extend(where2)
-        params.extend(params2)
-    else:
-        # No elements left in path. Current element is the element on which
-        # the search is being performed.
-
-        if join_required:
-            # Last query term is a RelatedObject
-            if field.field.rel.multiple:
-                # RelatedObject is from a 1-N relation.
-                # Join is required; query operates on joined table.
-                column = new_opts.pk.name
-                joins[qn(new_table)] = (
-                    qn(new_opts.db_table), "INNER JOIN",
-                    "%s.%s = %s.%s" % (qn(current_table), qn(join_column), qn(new_table), qn(new_column))
-                )
-                current_table = new_table
-            else:
-                # RelatedObject is from a 1-1 relation,
-                # No need to join; get the pk value from the related object,
-                # and compare using that.
-                column = current_opts.pk.name
-        elif intermediate_table:
-            # Last query term is a related object from an N-N relation.
-            # Join from intermediate table is sufficient.
-            column = join_column
-        elif name == current_opts.pk.name and lookup_type in ('exact', 'isnull') and current_column:
-            # Last query term is for a primary key. If previous iterations
-            # introduced a current/intermediate table that can be used to
-            # optimize the query, then use that table and column name.
-            column = current_column
-        else:
-            # Last query term was a normal field.
-            column = field.column
-
-        # If the field is a geometry field, then the WHERE clause will need to be obtained
-        # with the get_geo_where_clause()
-        if hasattr(field, '_geom'):
-            # Getting the geographic where clause.
-            gwc = get_geo_where_clause(lookup_type, current_table + '.', column, value)
-
-            # Getting the geographic parameters from the field.
-            geo_params = field.get_db_prep_lookup(lookup_type, value)
-     
-            # If a dictionary was passed back from the field modify the where clause.
-            if isinstance(geo_params, dict):
-                gwc = gwc % geo_params['where']
-                geo_params = geo_params['params']
-            where.append(gwc)
-            params.extend(geo_params)
-        else:
-            where.append(get_where_clause(lookup_type, current_table + '.', column, value))
-            params.extend(field.get_db_prep_lookup(lookup_type, value))
-
-    return joins, where, params

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

@@ -1 @@
-
-
+
-from django.contrib.gis.db.models.proxy import GeometryProxy
-from django.contrib.gis.db.models.postgis import POSTGIS_TERMS, quotename
-from django.contrib.gis.oldforms import WKTField
-from django.utils.functional import curry
-from django.contrib.gis.geos import GEOSGeometry, GEOSException
-from types import StringType
-
-#TODO: Flesh out widgets.
-
-
+
-    "The base GIS field -- maps to the OpenGIS Specification Geometry type."
-
@@ -34 +29 @@
-        super(GeometryField, self).__init__(**kwargs) # Calling the parent initializtion function
-
-    def _add_geom(self, style, db_table):
-        """Constructs the addition of the geometry to the table using the
-        AddGeometryColumn(...) PostGIS (and OGC standard) stored procedure.
-
-        Takes the style object (provides syntax highlighting) and the
-         database table as parameters.
-        """
-        sql = style.SQL_KEYWORD('SELECT ') + \
-              style.SQL_TABLE('AddGeometryColumn') + '(' + \
-              style.SQL_TABLE(quotename(db_table)) + ', ' + \
-              style.SQL_FIELD(quotename(self.column)) + ', ' + \
-              style.SQL_FIELD(str(self._srid)) + ', ' + \
-              style.SQL_COLTYPE(quotename(self._geom)) + ', ' + \
-              style.SQL_KEYWORD(str(self._dim)) + ');'
-
-        if not self.null:
-            # Add a NOT NULL constraint to the field
-            sql += '\n' + \
-                   style.SQL_KEYWORD('ALTER TABLE ') + \
-                   style.SQL_TABLE(quotename(db_table, dbl=True)) + \
-                   style.SQL_KEYWORD(' ALTER ') + \
-                   style.SQL_FIELD(quotename(self.column, dbl=True)) + \
-                   style.SQL_KEYWORD(' SET NOT NULL') + ';' 
-        return sql
-
-    def _geom_index(self, style, db_table,
-                    index_type='GIST', index_opts='GIST_GEOMETRY_OPS'):
-        "Creates a GiST index for this geometry field."
-        sql = style.SQL_KEYWORD('CREATE INDEX ') + \
-              style.SQL_TABLE(quotename('%s_%s_id' % (db_table, self.column), dbl=True)) + \
-              style.SQL_KEYWORD(' ON ') + \
-              style.SQL_TABLE(quotename(db_table, dbl=True)) + \
-              style.SQL_KEYWORD(' USING ') + \
-              style.SQL_COLTYPE(index_type) + ' ( ' + \
-              style.SQL_FIELD(quotename(self.column, dbl=True)) + ' ' + \
-              style.SQL_KEYWORD(index_opts) + ' );'
-        return sql
-
-    def _post_create_sql(self, style, db_table):
-        """Returns SQL that will be executed after the model has been
-        created. Geometry columns must be added after creation with the
-        PostGIS AddGeometryColumn() function."""
-
-        # Getting the AddGeometryColumn() SQL necessary to create a PostGIS
-        # geometry field.
-        post_sql = self._add_geom(style, db_table)
-
-        # If the user wants to index this data, then get the indexing SQL as well.
-        if self._index:
-            return '%s\n%s' % (post_sql, self._geom_index(style, db_table))
-        else:
-            return post_sql
-
-    def _post_delete_sql(self, style, db_table):
-        "Drops the geometry column."
-        sql = style.SQL_KEYWORD('SELECT ') + \
-            style.SQL_KEYWORD('DropGeometryColumn') + '(' + \
-            style.SQL_TABLE(quotename(db_table)) + ', ' + \
-            style.SQL_FIELD(quotename(self.column)) +  ');'
-        return sql
-
-    def contribute_to_class(self, cls, name):
-        super(GeometryField, self).contribute_to_class(cls, name)
@@ -113 +47 @@
-        return "NoField"
-                                                                
-    def get_db_prep_lookup(self, lookup_type, value):
-        "Returns field's value prepared for database lookup, accepts WKT and GEOS Geometries for the value."
-        if lookup_type in POSTGIS_TERMS:
-            if lookup_type == 'isnull': return [value] # special case for NULL geometries.
-            if not bool(value): return [None] # If invalid value passed in.
-            if isinstance(value, GEOSGeometry):
-                # GEOSGeometry instance passed in.
-                if value.srid != self._srid:
-                    # Returning a dictionary instructs the parse_lookup() to add what's in the 'where' key
-                    #  to the where parameters, since we need to transform the geometry in the query.
-                    return {'where' : "Transform(%s,%s)",
-                            'params' : [value, self._srid]
-                            }
-                else:
-                    # Just return the GEOSGeometry, it has its own psycopg2 adaptor.
-                    return [value]
-            elif isinstance(value, StringType):
-                # String instance passed in, assuming WKT.
-                # TODO: Any validation needed here to prevent SQL injection?
-                return ["SRID=%d;%s" % (self._srid, value)]
-            else:
-                raise TypeError("Invalid type (%s) used for field lookup value." % str(type(value)))
-        else:
-            raise TypeError("Field has invalid lookup: %s" % lookup_type)
-
-    def get_db_prep_save(self, value):
-        "Prepares the value for saving in the database."
-        if not bool(value): return None
-        if isinstance(value, GEOSGeometry):
-            return value
-        else:
-            return ("SRID=%d;%s" % (self._srid, wkt))
-
-    def get_placeholder(self, value):
-        "Provides a proper substitution value for "
-        if isinstance(value, GEOSGeometry) and value.srid != self._srid:
-            # Adding Transform() to the SQL placeholder.
-            return 'Transform(%%s, %s)' % self._srid
-        else:
-            return '%s'
-
-    def get_manipulator_field_objs(self):
-        "Using the WKTField (defined above) to be our manipulator."

django/branches/gis/django/contrib/gis/db/models/query.py

@@ -2 +2 @@
-from django.db import backend
-from django.contrib.gis.db.models.fields import GeometryField
-models.postgis import parse_lookup
+backend import parse_lookup # parse_lookup depends on the spatial database backend.
-from django.db.models.fields import FieldDoesNotExist
-import operator

django/branches/gis/django/contrib/gis/tests/geoapp/tests.py

@@ -92 +92 @@
-    
-    def test005_left_right(self):
-left ('<<') right ('>>') operator
+'left' and 'right' lookup type
-        
-        # Left: A << B => true if xmax(A) < xmin(B)

django/branches/gis/django/contrib/gis/tests/__init__.py

@@ -1 +1 @@
-from copy import copy
-from unittest import TestSuite, TextTestRunner
-utils
+db.backend
-from django.db import connection
-from django.test.utils import destroy_test_db