Changeset 3757 for framework

Timestamp:

03/28/11 21:00:24 (14 months ago)

Author:

elemoine

Message:

rely on Geo Alchemy? functions._within_distance, r=bbinet (closes #613)

Location:

framework/server/trunk

Files:

• mapfish/protocol.py (modified) (2 diffs)
• mapfish/sqlalchemygeom.py (modified) (1 diff)
• mapfish/tests/test_mysql.py (modified) (1 diff)
• mapfish/tests/test_oracle.py (modified) (1 diff)
• mapfish/tests/test_postgis.py (modified) (1 diff)
• mapfish/tests/test_spatialite.py (modified) (1 diff)
• setup.py (modified) (1 diff)

framework/server/trunk/mapfish/protocol.py

@@ -43 +43 @@
 from geojson import Feature, FeatureCollection, loads, GeoJSON
 
-from mapfish.sqlalchemygeom import within_distance
-
 
 def create_geom_filter(request, mapped_class, **kwargs):
@@ -90 +88 @@
 
     if 'additional_params' in kwargs:
-        return within_distance(geom_column, wkb_geometry, tolerance,
-                               kwargs['additional_params'])
+        return functions._within_distance(geom_column, wkb_geometry, tolerance,
+                                          kwargs['additional_params'])
     else:
-        return within_distance(geom_column, wkb_geometry, tolerance)
- 
+        return functions._within_distance(geom_column, wkb_geometry, tolerance)
+
 def create_attr_filter(request, mapped_class):
     """Create an ``and_`` SQLAlchemy filter (a ClauseList object) based

framework/server/trunk/mapfish/sqlalchemygeom.py

@@ -222 +222 @@
                        properties=attributes,
                        bbox=None if geometry is None else geometry.bounds)
-
-
-class within_distance(BaseFunction):
-    """This class is used as SQLAlchemy function to query features that are 
-    within a certain distance of a geometry. 
-    When it is used inside a query, the SQLAlchemy compiler calls the 
-    method __compile_within_distance.
-    """
-    pass
-
-@compiles(within_distance)
-def __compile_within_distance(element, compiler, **kw):
-    if isinstance(compiler.dialect, PGDialect):
-        function = __within_distance_pg
-    elif isinstance(compiler.dialect, MySQLDialect):
-        function = __within_distance_mysql
-    elif isinstance(compiler.dialect, SQLiteDialect):
-        function = __within_distance_spatialite
-    elif isinstance(compiler.dialect, OracleDialect):
-        function = __within_distance_oracle
-    else:
-        raise NotImplementedError("Operation 'within_distance' is not supported by '%s'" % (compiler.dialect))
-    
-    arguments = list(element.arguments)
-    return compiler.process(function(compiler, parse_clause(arguments.pop(0), compiler), 
-                                     parse_clause(arguments.pop(0), compiler), arguments.pop(0), *arguments))
-    
-def __within_distance_pg(compiler, geom1, geom2, distance):
-    """Implementation of within_distance for PostGIS
-    
-    ST_DWithin in early versions of PostGIS 1.3 does not work when
-    distance = 0. So we are directly using the (correct) internal definition.
-    Note that the definition changed in version 1.3.4, see also:
-    http://postgis.refractions.net/docs/ST_DWithin.html
-    """
-    return and_(func.ST_Expand(geom2, distance).op('&&')(geom1),
-                    func.ST_Expand(geom1, distance).op('&&')(geom2),
-                    func.ST_Distance(geom1, geom2) <= distance)
-
-def __within_distance_mysql(compiler, geom1, geom2, distance):
-    """Implementation of within_distance for MySQL
-    
-    MySQL does not support the function distance, so we are doing
-    a kind of "mbr_within_distance".
-    The MBR of 'geom2' is expanded with the amount of 'distance' by
-    manually changing the coordinates. Then we test if 'geom1' intersects
-    this expanded MBR.
-    """
-    mbr = func.ExteriorRing(func.Envelope(geom2))
-    
-    lower_left = func.StartPoint(mbr)
-    upper_right = func.PointN(mbr, 3)
-    
-    xmin = func.X(lower_left)
-    ymin = func.Y(lower_left)
-    xmax = func.X(upper_right)
-    ymax = func.Y(upper_right)
-    
-    return func.Intersects(
-            geom1,
-            func.GeomFromText(
-                func.Concat('Polygon((',
-                       xmin - distance, ' ', ymin - distance, ',',
-                       xmax + distance, ' ', ymin - distance, ',',
-                       xmax + distance, ' ', ymax + distance, ',',
-                       xmin - distance, ' ', ymax + distance, ',',
-                       xmin - distance, ' ', ymin - distance, '))'), func.srid(geom2)
-                )                                              
-            )
-
-def __within_distance_spatialite(compiler, geom1, geom2, distance):
-    """Implementation of within_distance for Spatialite
-    """
-    if isinstance(geom1, GeometryExtensionColumn) and geom1.type.spatial_index and SQLiteSpatialDialect.supports_rtree(compiler.dialect):
-        """If querying on a geometry column that also has a spatial index,
-        then make use of this index.
-        
-        see: http://www.gaia-gis.it/spatialite/spatialite-tutorial-2.3.1.html#t8 and
-        http://groups.google.com/group/spatialite-users/browse_thread/thread/34609c7a711ac92d/7688ced3f909039c?lnk=gst&q=index#f6dbc235471574db
-        """
-        return and_(
-                    func.Distance(geom1, geom2) <= distance,
-                    table(geom1.table.fullname, column("rowid")).c.rowid.in_(
-                        select([table("idx_%s_%s" % (geom1.table.fullname, geom1.key), column("pkid")).c.pkid]).where(
-                            and_(text('xmin') >= func.MbrMinX(geom2) - distance,
-                            and_(text('xmax') <= func.MbrMaxX(geom2) + distance,
-                            and_(text('ymin') >= func.MbrMinY(geom2) - distance,
-                                 text('ymax') <= func.MbrMaxY(geom2) + distance)))
-                            )
-                        )
-                    )
-        
-    else:
-        return func.Distance(geom1, geom2) <= distance
-    
-
-
-def __within_distance_oracle(compiler, geom1, geom2, distance, additional_params={}):
-    """Implementation of within_distance for Oracle
-    
-    If the first parameter is a geometry column, then the Oracle operator SDO_WITHIN_DISTANCE
-    is called and Oracle makes use of the spatial index of this column.
-    
-    If the first parameter is not a geometry column but a function, which is the case when a coordinate 
-    transformation had to be added by the spatial filter, then the function SDO_GEOM.WITHIN_DISTANCE
-    is called. SDO_GEOM.WITHIN_DISTANCE does not make use of a spatial index and requires
-    additional parameters: either a tolerance value or a dimension information array (DIMINFO)
-    for both geometries. These parameters can be specified when defining the spatial filter, e.g.::
-    
-        additional_params={'tol': '0.005'}
-        
-        or
-        
-        from sqlalchemy.sql.expression import text
-        diminfo = text("MDSYS.SDO_DIM_ARRAY("\
-            "MDSYS.SDO_DIM_ELEMENT('LONGITUDE', -180, 180, 0.000000005),"\
-            "MDSYS.SDO_DIM_ELEMENT('LATITUDE', -90, 90, 0.000000005)"\
-            ")")
-        additional_params={'dim1': diminfo, 'dim2': diminfo}
-        
-        filter = create_default_filter(request, Spot, additional_params=additional_params)
-        proto.count(request, filter=filter)
-        
-    For its distance calculation Oracle by default uses meter as unit for geodetic data (like EPSG:4326) 
-    and otherwise the 'unit of measurement associated with the data'. The unit used for the 'distance' value
-    can be changed by adding an entry to 'additional_params'. Valid units are defined in the 
-    view 'sdo_dist_units'::
-    
-        additional_params={'params': 'unit=km'}
-        
-    SDO_WITHIN_DISTANCE accepts further parameters, which can also be set using the name 'params'
-    together with the unit::
-    
-        additional_params={'params': 'unit=km max_resolution=10'}
-        
-    
-    Valid options for 'additional_params' are:
-    
-        params
-            A String containing additional parameters, for example the unit.
-            
-        tol
-            The tolerance value used for the SDO_GEOM.WITHIN_DISTANCE function call.
-            
-        dim1 and dim2
-            If the parameter 'tol' is not set, these two parameters have to be set. 'dim1' is the DIMINFO
-            for the first geometry (the reprojected geometry column) and 'dim2' is the DIMINFO for
-            the second geometry (the input geometry from the request). Values for 'dim1' and 'dim2'
-            have to be SQLAlchemy expressions, either literal text (text(..)) or a select query.
-            
-    Note that 'tol' or 'dim1'/'dim2' only have to be set when the input geometry from the request 
-    uses a different CRS than the geometry column!
-    
-    
-    SDO_WITHIN_DISTANCE: http://download.oracle.com/docs/cd/E11882_01/appdev.112/e11830/sdo_operat.htm#i77653
-    SDO_GEOM.WITHIN_DISTANCE: http://download.oracle.com/docs/cd/E11882_01/appdev.112/e11830/sdo_objgeom.htm#i856373
-    DIMINFO: http://download.oracle.com/docs/cd/E11882_01/appdev.112/e11830/sdo_objrelschema.htm#i1010905
-    TOLERANCE: http://download.oracle.com/docs/cd/E11882_01/appdev.112/e11830/sdo_intro.htm#i884589
-    
-    """
-    params = additional_params.get('params', '')
-    
-    if isinstance(geom1, Column):
-        return (func.SDO_WITHIN_DISTANCE(geom1, geom2, 
-                                     'distance=%s %s' % (distance, params)) == 'TRUE')
-    else:
-        dim1 = additional_params.get('dim1', None)
-        dim2 = additional_params.get('dim2', None)
-        
-        if dim1 is not None and dim2 is not None:
-            return (func.SDO_GEOM.WITHIN_DISTANCE(geom1, dim1, 
-                                             distance, 
-                                             geom2, dim2, 
-                                             params) == 'TRUE')
-        else:
-            tol = additional_params.get('tol', None)
-            
-            if tol is not None:
-                return (func.SDO_GEOM.WITHIN_DISTANCE(geom1, 
-                                             distance, 
-                                             geom2,
-                                             tol, 
-                                             params) == 'TRUE')
-            else:
-                raise Exception('No dimension information ("dim1" and "dim2") or '\
-                                'tolerance value ("tol") specified for calling '\
-                                'SDO_GEOM.WITHIN_DISTANCE on Oracle, which is '\
-                                'required when reprojecting.')

framework/server/trunk/mapfish/tests/test_mysql.py

@@ -359 +359 @@
 
         proto.read(FakeRequest({}), id=-1)
-
-
-    def test_within_distance(self):
-        """Test the MySQL implementation for within_distance"""
-        from mapfish.sqlalchemygeom import within_distance
-        
-        eq_(session.scalar(within_distance('POINT(-88.9139332929936 42.5082802993631)', 
-                                                               'POINT(-88.9139332929936 35.5082802993631)', 10)), True)
-        ok_(session.scalar(within_distance('Point(0 0)', 'Point(0 0)', 0)))
-        ok_(session.scalar(within_distance('Point(0 0)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(5 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(6 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 1)))
-        ok_(session.scalar(within_distance('Polygon((0 0, 1 0, 1 8, 0 8, 0 0))', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))

framework/server/trunk/mapfish/tests/test_oracle.py

@@ -388 +388 @@
         
         proto.read(FakeRequest({}), id=-1)
-
-
-    def test_within_distance(self):
-        """Test the Oracle implementation for within_distance
-        
-        Because SDO_WITHIN_DISTANCE requires a spatial index for the geometry used
-        as first parameter, we have to insert out test geometries into tables,
-        unlike to the other databases.
-        
-        Note that Oracle uses meter as unit for the tolerance value for geodetic coordinate
-        systems (like 4326)!
-        """
-        from mapfish.sqlalchemygeom import within_distance
-        
-        # test if SDO_WITHIN_DISTANCE is called correctly
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 'POINT(0 0)', 0)).count(), 1)
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 'POINT(0 0)', 0.1)).count(), 1)
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 'POINT(9 9)', 100000)).count(), 0)
-        
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 
-                                                       'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)).count(), 3)
-        
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 
-                                                       'Polygon((-10 -10, 10 -10, 10 10, -10 10, -10 -10))', 0)).count(), 4)
-        
-        eq_(session.query(Spot).filter(within_distance(Spot.spot_location, 
-                                                       'Polygon((-10 -10, 10 -10, 10 10, -10 10, -10 -10))', 200000)).count(), 5)
-
-        # test if SDO_GEOM.WITHIN_DISTANCE is called correctly
-        eq_(session.scalar(select([text('1')], from_obj=['dual']).where(
-                                                    within_distance('POINT(0 0)', 'POINT(0 0)', 0, 
-                                                                    {'tol' : 0.00000005}))), 1)
-        eq_(session.scalar(select([text('1')], from_obj=['dual']).where(
-                                                    within_distance('POINT(0 0)', 'POINT(0 0)', 0, 
-                                                                    {'dim1' : text(diminfo),
-                                                                     'dim2' : text(diminfo)}))), 1)

framework/server/trunk/mapfish/tests/test_postgis.py

@@ -355 +355 @@
         
         proto.read(FakeRequest({}), id=-1)
-
-
-    def test_within_distance(self):
-        """Test the PostGIS implementation for within_distance"""
-        from mapfish.sqlalchemygeom import within_distance
-        
-        eq_(session.scalar(within_distance('POINT(-88.9139332929936 42.5082802993631)', 
-                                                               'POINT(-88.9139332929936 35.5082802993631)', 10)), True)
-        ok_(session.scalar(within_distance('Point(0 0)', 'Point(0 0)', 0)))
-        ok_(session.scalar(within_distance('Point(0 0)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(5 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(6 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 1)))
-        ok_(session.scalar(within_distance('Polygon((0 0, 1 0, 1 8, 0 8, 0 0))', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))

framework/server/trunk/mapfish/tests/test_spatialite.py

@@ -371 +371 @@
         
         proto.read(FakeRequest({}), id=-1)
-
-
-    def test_within_distance(self):
-        """Test the Spatialite implementation for within_distance"""
-        from mapfish.sqlalchemygeom import within_distance
-        
-        eq_(session.scalar(within_distance('POINT(-88.9139332929936 42.5082802993631)', 
-                                                               'POINT(-88.9139332929936 35.5082802993631)', 10)), True)
-        ok_(session.scalar(within_distance('Point(0 0)', 'Point(0 0)', 0)))
-        ok_(session.scalar(within_distance('Point(0 0)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(5 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))
-        ok_(session.scalar(within_distance('Point(6 5)', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 1)))
-        ok_(session.scalar(within_distance('Polygon((0 0, 1 0, 1 8, 0 8, 0 0))', 
-                                           'Polygon((-5 -5, 5 -5, 5 5, -5 5, -5 -5))', 0)))

framework/server/trunk/setup.py

@@ -39 +39 @@
                 'Pylons>=1.0,<=1.0.99',
                 'geojson>=1.0,<=1.0.99',
-                'GeoAlchemy>=0.4,<=0.4.99']
+                'GeoAlchemy>=0.5,<=0.5.99']
 
 # Shapely and Psychopg2 cannot be installed on Windows via python eggs