def test_intersects_token1(): ds = mapnik.SQLite(file='../data/sqlite/empty.db', table='(select * from empty where "a"!="b" and !intersects!)', ) fs = ds.featureset() feature = fs.next() eq_(feature,None)
def test_attachdb_with_sql_join_count2(): ''' sqlite3 world.sqlite attach database 'business.sqlite' as business; select count(*) from world_merc INNER JOIN business on world_merc.iso3 = business.ISO3; ''' ds = mapnik.SQLite( file='../data/sqlite/world.sqlite', table= '(select * from world_merc INNER JOIN business on world_merc.iso3 = business.ISO3)', attachdb='*****@*****.**') eq_(len(ds.fields()), 29) eq_(ds.fields(), [ 'OGC_FID', 'fips', 'iso2', 'iso3', 'un', 'name', 'area', 'pop2005', 'region', 'subregion', 'lon', 'lat', 'ISO3:1', '1995', '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006', '2007', '2008', '2009', '2010' ]) eq_(ds.field_types(), [ 'int', 'str', 'str', 'str', 'int', 'str', 'int', 'int', 'int', 'int', 'float', 'float', 'str', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int' ]) eq_(len(ds.all_features()), 192)
def test_empty_db(): ds = mapnik.SQLite(file='../data/sqlite/empty.db', table='empty', ) fs = ds.featureset() feature = fs.next() eq_(feature,None)
def test_null_id_field(): # silence null key warning: https://github.com/mapnik/mapnik/issues/1889 default_logging_severity = mapnik.logger.get_severity() mapnik.logger.set_severity(mapnik.severity_type.None) # form up an in-memory test db wkb = '010100000000000000000000000000000000000000' # note: the osm_id should be declared INTEGER PRIMARY KEY # but in this case we intentionally do not make this a valid pkey # otherwise sqlite would turn the null into a valid, serial id ds = mapnik.SQLite(file=':memory:', table='test1', initdb=''' create table test1 (osm_id INTEGER,geometry BLOB); insert into test1 values (null,x'%s'); ''' % wkb, extent='-180,-60,180,60', use_spatial_index=False, key_field='osm_id' ) fs = ds.featureset() feature = None try : feature = fs.next() except StopIteration: pass eq_(feature,None) mapnik.logger.set_severity(default_logging_severity)
def test_rtree_creation(): index = DB + '.index' if os.path.exists(index): os.unlink(index) threads = [] for i in range(NUM_THREADS): t = threading.Thread(target=create_ds) t.start() threads.append(t) for i in threads: i.join() eq_(os.path.exists(index), True) conn = sqlite3.connect(index) cur = conn.cursor() try: cur.execute("Select count(*) from idx_%s_GEOMETRY" % TABLE.replace("'", "")) conn.commit() eq_(cur.fetchone()[0], TOTAL) except sqlite3.OperationalError: # don't worry about testing # of index records if # python's sqlite module does not support rtree pass cur.close() ds = mapnik.SQLite(file=DB, table=TABLE) fs = ds.all_features() eq_(len(fs), TOTAL) os.unlink(index) ds = mapnik.SQLite(file=DB, table=TABLE, use_spatial_index=False) fs = ds.all_features() eq_(len(fs), TOTAL) eq_(os.path.exists(index), False) ds = mapnik.SQLite(file=DB, table=TABLE, use_spatial_index=True) fs = ds.all_features() for feat in fs: query = mapnik.Query(feat.envelope()) selected = ds.features(query) eq_(len(selected.features) >= 1, True) eq_(os.path.exists(index), True) os.unlink(index)
def test_attachdb_with_absolute_file(): # The point table and index is in the qgis_spatiallite.sqlite # database. If either is not found, then this fails ds = mapnik.SQLite(file=os.getcwd() + '/../data/sqlite/world.sqlite', table='point', attachdb='scratch@qgis_spatiallite.sqlite') fs = ds.featureset() feature = fs.next() eq_(feature['pkuid'], 1)
def test_intersects_token3(): ds = mapnik.SQLite(file='../data/sqlite/empty.db', table='(select * from empty where "a"!="b" and !intersects!)', ) fs = ds.featureset() feature = None try : feature = fs.next() except StopIteration: pass eq_(feature,None)
def test_sqlite_reading(): if 'sqlite' in mapnik.DatasourceCache.instance().plugin_names(): ds = mapnik.SQLite(file='../data/sqlite/world.sqlite',table_by_index=0) desc = ds.describe() eq_(desc['geometry_type'],mapnik.DataGeometryType.Polygon) eq_(desc['name'],'sqlite') eq_(desc['type'],mapnik.DataType.Vector) eq_(desc['encoding'],'utf-8') features = ds.all_features() num_feats = len(features) eq_(num_feats, 245)
def test_empty_db(): ds = mapnik.SQLite(file='../data/sqlite/empty.db', table='empty', ) fs = ds.featureset() feature = None try: feature = fs.next() except StopIteration: pass eq_(feature,None)
def test_attachdb_with_index(): ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='attachedtest', attachdb='scratch@:memory:', initdb=''' create table scratch.attachedtest (the_geom); create virtual table scratch.idx_attachedtest_the_geom using rtree(pkid,xmin,xmax,ymin,ymax); insert into scratch.idx_attachedtest_the_geom values (1,-7799225.5,-7778571.0,1393264.125,1417719.375); ''') fs = ds.featureset() feature = fs.next() eq_(feature, None)
def test_attachdb_with_sql_join_count5(): ''' select count(*) from (select * from world_merc where 1=1) as world_merc INNER JOIN business on world_merc.iso3 = business.ISO3; ''' ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select * from (select * from world_merc where !intersects! and 1=2) as world_merc INNER JOIN business on world_merc.iso3 = business.ISO3)', attachdb='*****@*****.**' ) # nothing is able to join to business so we don't pick up business schema eq_(len(ds.fields()),12) eq_(ds.fields(),['OGC_FID', 'fips', 'iso2', 'iso3', 'un', 'name', 'area', 'pop2005', 'region', 'subregion', 'lon', 'lat']) eq_(ds.field_types(),['int', 'str', 'str', 'str', 'int', 'str', 'int', 'int', 'int', 'int', 'float', 'float']) eq_(len(ds.all_features()),0)
def test_attachdb_with_multiple_files(): ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='attachedtest', attachdb='scratch1@:memory:,scratch2@:memory:', initdb=''' create table scratch1.attachedtest (the_geom); create virtual table scratch2.idx_attachedtest_the_geom using rtree(pkid,xmin,xmax,ymin,ymax); insert into scratch2.idx_attachedtest_the_geom values (1,-7799225.5,-7778571.0,1393264.125,1417719.375); ''') fs = ds.featureset() feature = fs.next() # the above should not throw but will result in no features eq_(feature, None)
def test_that_nonexistant_query_field_throws(**kwargs): ds = mapnik.SQLite(file='../data/sqlite/empty.db', table='empty', ) eq_(len(ds.fields()),25) eq_(ds.fields(),['OGC_FID', 'scalerank', 'labelrank', 'featurecla', 'sovereignt', 'sov_a3', 'adm0_dif', 'level', 'type', 'admin', 'adm0_a3', 'geou_dif', 'name', 'abbrev', 'postal', 'name_forma', 'terr_', 'name_sort', 'map_color', 'pop_est', 'gdp_md_est', 'fips_10_', 'iso_a2', 'iso_a3', 'iso_n3']) eq_(ds.field_types(),['int', 'int', 'int', 'str', 'str', 'str', 'float', 'float', 'str', 'str', 'str', 'float', 'str', 'str', 'str', 'str', 'str', 'str', 'float', 'float', 'float', 'float', 'str', 'str', 'float']) query = mapnik.Query(ds.envelope()) for fld in ds.fields(): query.add_property_name(fld) # also add an invalid one, triggering throw query.add_property_name('bogus') fs = ds.features(query)
def test_attachdb_with_sql_join(): ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select * from world_merc INNER JOIN business on world_merc.iso3 = business.ISO3 limit 100)', attachdb='*****@*****.**' ) eq_(len(ds.fields()),29) eq_(ds.fields(),['OGC_FID', 'fips', 'iso2', 'iso3', 'un', 'name', 'area', 'pop2005', 'region', 'subregion', 'lon', 'lat', 'ISO3:1', '1995', '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006', '2007', '2008', '2009', '2010']) eq_(ds.field_types(),['int', 'str', 'str', 'str', 'int', 'str', 'int', 'int', 'int', 'int', 'float', 'float', 'str', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int']) fs = ds.featureset() feature = fs.next() eq_(feature.id(),1) expected = { 1995:0, 1996:0, 1997:0, 1998:0, 1999:0, 2000:0, 2001:0, 2002:0, 2003:0, 2004:0, 2005:0, 2006:0, 2007:0, 2008:0, 2009:0, 2010:0, # this appears to be sqlites way of # automatically handling clashing column names 'ISO3:1':'ATG', 'OGC_FID':1, 'area':44, 'fips':u'AC', 'iso2':u'AG', 'iso3':u'ATG', 'lat':17.078, 'lon':-61.783, 'name':u'Antigua and Barbuda', 'pop2005':83039, 'region':19, 'subregion':29, 'un':28 } for k,v in expected.items(): try: eq_(feature[str(k)],v) except: #import pdb;pdb.set_trace() print 'invalid key/v %s/%s for: %s' % (k,v,feature)
def test_that_64bit_int_fields_work(): ds = mapnik.SQLite(file='../data/sqlite/64bit_int.sqlite', table='int_table', use_spatial_index=False) eq_(len(ds.fields()), 3) eq_(ds.fields(), ['OGC_FID', 'id', 'bigint']) eq_(ds.field_types(), ['int', 'int', 'int']) fs = ds.featureset() feat = fs.next() eq_(feat.id(), 1) eq_(feat['OGC_FID'], 1) eq_(feat['bigint'], 2147483648) feat = fs.next() eq_(feat.id(), 2) eq_(feat['OGC_FID'], 2) eq_(feat['bigint'], 922337203685477580)
def test_db_with_one_untyped_column(): # form up an in-memory test db wkb = '010100000000000000000000000000000000000000' ds = mapnik.SQLite(file=':memory:', table='test1', initdb=''' create table test1 (geometry BLOB, untyped); insert into test1 values (x'%s', 'untyped'); ''' % wkb, extent='-180,-60,180,60', use_spatial_index=False, key_field='rowid') # ensure the untyped column is found eq_(len(ds.fields()), 2) eq_(ds.fields(), ['rowid', 'untyped']) eq_(ds.field_types(), ['int', 'str'])
def test_null_id_field(): # form up an in-memory test db wkb = '010100000000000000000000000000000000000000' # note: the osm_id should be declared INTEGER PRIMARY KEY # but in this case we intentionally do not make this a valid pkey # otherwise sqlite would turn the null into a valid, serial id ds = mapnik.SQLite(file=':memory:', table='test1', initdb=''' create table test1 (osm_id INTEGER,geometry BLOB); insert into test1 values (null,x'%s'); ''' % wkb, extent='-180,-60,180,60', use_spatial_index=False, key_field='osm_id') fs = ds.featureset() feat = fs.next( ) ## should throw since key_field is null: StopIteration: No more features.
def test_db_with_one_text_column(): # form up an in-memory test db wkb = '010100000000000000000000000000000000000000' ds = mapnik.SQLite(file=':memory:', table='test1', initdb=''' create table test1 (alias TEXT,geometry BLOB); insert into test1 values ("test",x'%s'); ''' % wkb, extent='-180,-60,180,60', use_spatial_index=False, key_field='alias') eq_(len(ds.fields()), 1) eq_(ds.fields(), ['alias']) eq_(ds.field_types(), ['str']) fs = ds.all_features() eq_(len(fs), 1) feat = fs[0] eq_(feat.id(), 0) # should be 1? eq_(feat['alias'], 'test') eq_(feat.geometry.to_wkt(), 'POINT(0 0)')
style = mapnik.Style() style.rules.append(rule) # Loop through countries in xml countryList = ET.parse(countryListXml).getroot() for country in countryList.findall("country"): name = country.find("name").text iso3 = country.find("iso3").text logging.info("Processing %s" % name) # Create Datasource query = '(SELECT * FROM GAUL_2010_2 WHERE ISO3 = "%s")' % iso3 datasource = mapnik.SQLite(file=dbPath, table=query, geometry_field="Geometry", key_field="PK_UID", use_spatial_index=False) # Create layer layer = mapnik.Layer("boundaries") layer.datasource = datasource layer.styles.append("boundariesStyle") # Calculate image output size envelope = datasource.envelope() dLong = envelope.maxx - envelope.minx dLat = envelope.maxy - envelope.miny aspectRatio = dLong / dLat if dLong > dLat:
def tile(request, version, shapefile_id, zoom, x, y): shapefile = None try: if version != "1.0": raise Http404 try: shapefile = Shapefile.objects.get(id=shapefile_id) except Shapefile.DoesNotExist: raise Http404 zoom = int(zoom) x = int(x) y = int(y) # min(x) = 0, max (x) = if zoom < 0 or zoom > MAX_ZOOM_LEVEL: raise Http404 # for TILE_WIDTH/HEIGHT==256 # at zoom = 0 extents will be 180 units/degrees xExtent = _unitsPerPixel(zoom) * TILE_WIDTH yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT minLong = xExtent * x - 180.0 minLat = yExtent * y - 90.0 maxLong = minLong + xExtent maxLat = minLat + xExtent if (minLong < -180 or maxLong > 180 or minLat < -90 or maxLat > 90): print "bound error raised" raise Http404 dbFile = "/home/john360/computing/geospatial_dev/geodjango_shapefile_app/DB/geodjango.db" extentStr = "%s,%s,%s,%s" % (minLong, minLat, maxLong, maxLat) map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT, '+proj=longlat +datum=WGS84 +no_defs') map.background = mapnik.Color("#7391ad") # time.sleep (0.3) # Set up the base layer datasource = \ mapnik.SQLite(file=dbFile, table="shapeEditor_baseMap", key_field="id", # srid=4326, geometry_field="geometry", extent=extentStr, wkb_format="spatialite") baseLayer = mapnik.Layer("baseLayer") baseLayer.datasource = datasource baseLayer.styles.append("baseLayerStyle") rule = mapnik.Rule() rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c"))) rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color("#404040"), 0.2)) style = mapnik.Style() style.rules.append(rule) map.append_style("baseLayerStyle", style) map.layers.append(baseLayer) # Define the feature layer geometryField = utils.calcGeometryField(shapefile.geom_type) query = '( select ' + geometryField + \ ' from "shapeEditor_feature" where ' + \ 'shapefile_id = ' + str(shapefile.id) + ' ) as geom' dbSettings = settings.DATABASES['default'] datasource = \ mapnik.PostGIS(user=dbSettings['USER'], password=dbSettings['PASSWORD'], dbname=dbSettings['NAME'], table=query, srid=4326, geometry_field=geometryField, geometry_table='"shapeEditor_feature"') featureLayer = mapnik.Layer("featureLayer") featureLayer.datasource = datasource featureLayer.styles.append("featureLayerStyle") rule = mapnik.Rule() if shapefile.geom_type in ["Point", "MultiPoint"]: rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) elif shapefile.geom_type in ["Polygon", "Multipolygon"]: rule.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c"))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 1)) style = mapnik.Style() style.rules.append(rule) map.append_style("featureLayerStyle", style) map.layers.append(featureLayer) map.zoom_to_box(mapnik.Envelope(minLong, minLat, maxLong, maxLat)) image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT) mapnik.render(map, image) imageData = image.tostring('png') return HttpResponse(imageData, mimetype="image/png") except: traceback.print_exc() return HttpResponse(" ")
def create_ds(test_db,table): ds = mapnik.SQLite(file=test_db,table=table) ds.all_features() del ds
def test_subqueries(): ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='world_merc', ) fs = ds.featureset() feature = fs.next() eq_(feature['OGC_FID'],1) eq_(feature['fips'],u'AC') eq_(feature['iso2'],u'AG') eq_(feature['iso3'],u'ATG') eq_(feature['un'],28) eq_(feature['name'],u'Antigua and Barbuda') eq_(feature['area'],44) eq_(feature['pop2005'],83039) eq_(feature['region'],19) eq_(feature['subregion'],29) eq_(feature['lon'],-61.783) eq_(feature['lat'],17.078) ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select * from world_merc)', ) fs = ds.featureset() feature = fs.next() eq_(feature['OGC_FID'],1) eq_(feature['fips'],u'AC') eq_(feature['iso2'],u'AG') eq_(feature['iso3'],u'ATG') eq_(feature['un'],28) eq_(feature['name'],u'Antigua and Barbuda') eq_(feature['area'],44) eq_(feature['pop2005'],83039) eq_(feature['region'],19) eq_(feature['subregion'],29) eq_(feature['lon'],-61.783) eq_(feature['lat'],17.078) ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select OGC_FID,GEOMETRY from world_merc)', ) fs = ds.featureset() feature = fs.next() eq_(feature['OGC_FID'],1) eq_(len(feature),1) ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select GEOMETRY,OGC_FID,fips from world_merc)', ) fs = ds.featureset() feature = fs.next() eq_(feature['OGC_FID'],1) eq_(feature['fips'],u'AC') # same as above, except with alias like postgres requires # TODO - should we try to make this work? #ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', # table='(select GEOMETRY,rowid as aliased_id,fips from world_merc) as table', # key_field='aliased_id' # ) #fs = ds.featureset() #feature = fs.next() #eq_(feature['aliased_id'],1) #eq_(feature['fips'],u'AC') ds = mapnik.SQLite(file='../data/sqlite/world.sqlite', table='(select GEOMETRY,OGC_FID,OGC_FID as rowid,fips from world_merc)', ) fs = ds.featureset() feature = fs.next() eq_(feature['rowid'],1) eq_(feature['fips'],u'AC')
def create_ds(): ds = mapnik.SQLite(file=DB, table=TABLE) fs = ds.all_features()
# -*- coding: utf-8 -*- print('=' * 40) print(__file__) from helper.textool import get_tmp_file ################################################################################ import mapnik datasource = mapnik.Shapefile(file="/gdata/GSHHS_c.shp") ################################################################################ datasource = mapnik.Shapefile(file="/gdata/GSHHS_c.shp", encoding="latin1") ################################################################################ datasource = mapnik.SQLite(file="spalite.db", table="pcapital", geometry_field="geom", key_field="name")