/** * Parse a geometry starting at offset. * * @param data ValueGetter with the data to be parsed * @return the parsed geometry */ protected Geometry parseGeometry(ValueGetter data) { byte endian = data.getByte(); // skip and test endian flag if (endian != data.endian) { throw new IllegalArgumentException("Endian inconsistency!"); } int typeword = data.getInt(); int realtype = typeword & 0x1FFFFFFF; // cut off high flag bits boolean haveZ = (typeword & 0x80000000) != 0; boolean haveM = (typeword & 0x40000000) != 0; boolean haveS = (typeword & 0x20000000) != 0; int srid = Geometry.UNKNOWN_SRID; if (haveS) { srid = Geometry.parseSRID(data.getInt()); } Geometry result1; switch (realtype) { case Geometry.POINT: result1 = parsePoint(data, haveZ, haveM); break; case Geometry.LINESTRING: result1 = parseLineString(data, haveZ, haveM); break; case Geometry.POLYGON: result1 = parsePolygon(data, haveZ, haveM); break; case Geometry.MULTIPOINT: result1 = parseMultiPoint(data); break; case Geometry.MULTILINESTRING: result1 = parseMultiLineString(data); break; case Geometry.MULTIPOLYGON: result1 = parseMultiPolygon(data); break; case Geometry.GEOMETRYCOLLECTION: result1 = parseCollection(data); break; default: throw new IllegalArgumentException("Unknown Geometry Type: " + realtype); } Geometry result = result1; if (srid != Geometry.UNKNOWN_SRID) { result.setSrid(srid); } return result; }
public void read(AbstractCityObject cityObject, long cityObjectId, HashSet<Long> generalizesToSet) throws SQLException { for (Long generalizationId : generalizesToSet) { ResultSet rs = null; try { psGeneralization.setLong(1, generalizationId); rs = psGeneralization.executeQuery(); if (rs.next()) { String gmlId = rs.getString("GMLID"); if (rs.wasNull() || gmlId == null) continue; int classId = rs.getInt("CLASS_ID"); CityGMLClass type = Util.classId2cityObject(classId); PGgeometry pgGeom = (PGgeometry) rs.getObject("ENVELOPE"); if (!rs.wasNull() && pgGeom != null && boundingBoxFilter.isActive()) { Geometry geom = pgGeom.getGeometry(); Envelope env = new EnvelopeImpl(); Point lower = new Point(geom.getFirstPoint().x, geom.getFirstPoint().y, geom.getFirstPoint().z); Point upper = new Point(geom.getPoint(2).x, geom.getPoint(2).y, geom.getPoint(2).z); env.setLowerCorner(lower); env.setUpperCorner(upper); if (boundingBoxFilter.filter(env)) continue; } if (featureGmlIdFilter.isActive() && featureGmlIdFilter.filter(gmlId)) continue; if (featureClassFilter.isActive() && featureClassFilter.filter(type)) continue; if (featureGmlNameFilter.isActive()) { // we need to get the gml:name of the feature // we only check top-level features TableEnum table = null; switch (type) { case BUILDING: table = TableEnum.BUILDING; break; case CITY_FURNITURE: table = TableEnum.CITY_FURNITURE; break; case LAND_USE: table = TableEnum.LAND_USE; break; case WATER_BODY: table = TableEnum.WATERBODY; break; case PLANT_COVER: table = TableEnum.SOLITARY_VEGETAT_OBJECT; break; case SOLITARY_VEGETATION_OBJECT: table = TableEnum.PLANT_COVER; break; case TRANSPORTATION_COMPLEX: case ROAD: case RAILWAY: case TRACK: case SQUARE: table = TableEnum.TRANSPORTATION_COMPLEX; break; case RELIEF_FEATURE: table = TableEnum.RELIEF_FEATURE; break; case GENERIC_CITY_OBJECT: table = TableEnum.GENERIC_CITYOBJECT; break; case CITY_OBJECT_GROUP: table = TableEnum.CITYOBJECTGROUP; break; } if (table != null) { Statement stmt = null; ResultSet nameRs = null; try { String query = "select NAME from " + table.toString() + " where ID=" + generalizationId; stmt = connection.createStatement(); nameRs = stmt.executeQuery(query); if (nameRs.next()) { String gmlName = nameRs.getString("NAME"); if (gmlName != null && featureGmlNameFilter.filter(gmlName)) continue; } } catch (SQLException sqlEx) { continue; } finally { if (nameRs != null) { try { nameRs.close(); } catch (SQLException sqlEx) { // } nameRs = null; } if (stmt != null) { try { stmt.close(); } catch (SQLException sqlEx) { // } stmt = null; } } } } GeneralizationRelation generalizesTo = new GeneralizationRelationImpl(); generalizesTo.setHref("#" + gmlId); cityObject.addGeneralizesTo(generalizesTo); } } finally { if (rs != null) rs.close(); } } }
/** * This retrieves the data and the public metadata for a single attribute column. * * @param columnId Either an entity ID (int) or a Map specifying public metadata values that * uniquely identify a column. * @param minParam Used for filtering numeric data * @param maxParam Used for filtering numeric data * @param sqlParams Specifies parameters to be used in place of '?' placeholders that appear in * the SQL query for the column. * @return The column data. * @throws RemoteException */ @SuppressWarnings("unchecked") public AttributeColumnData getColumn( Object columnId, double minParam, double maxParam, Object[] sqlParams) throws RemoteException { DataEntity entity = null; if (columnId instanceof Map) { @SuppressWarnings({"rawtypes"}) Map metadata = (Map) columnId; metadata.put(PublicMetadata.ENTITYTYPE, EntityType.COLUMN); int[] ids = findEntityIds(metadata, null); if (ids.length == 0) throw new RemoteException("No column with id " + columnId); if (ids.length > 1) throw new RemoteException( String.format( "The specified metadata does not uniquely identify a column (%s matching columns found): %s", ids.length, columnId)); entity = getColumnEntity(ids[0]); } else { columnId = cast(columnId, Integer.class); entity = getColumnEntity((Integer) columnId); } // if it's a geometry column, just return the metadata if (assertStreamingGeometryColumn(entity, false)) { GeometryStreamMetadata gsm = (GeometryStreamMetadata) getGeometryData(entity, GeomStreamComponent.TILE_DESCRIPTORS, null); AttributeColumnData result = new AttributeColumnData(); result.id = entity.id; result.metadata = entity.publicMetadata; result.metadataTileDescriptors = gsm.metadataTileDescriptors; result.geometryTileDescriptors = gsm.geometryTileDescriptors; return result; } // TODO - check if entity is a table String query = entity.privateMetadata.get(PrivateMetadata.SQLQUERY); int tableId = DataConfig.NULL; String tableField = null; if (Strings.isEmpty(query)) { String entityType = entity.publicMetadata.get(PublicMetadata.ENTITYTYPE); tableField = entity.privateMetadata.get(PrivateMetadata.SQLCOLUMN); if (!Strings.equal(entityType, EntityType.COLUMN)) throw new RemoteException( String.format( "Entity %s has no sqlQuery and is not a column (entityType=%s)", entity.id, entityType)); if (Strings.isEmpty(tableField)) throw new RemoteException( String.format( "Entity %s has no sqlQuery and no sqlColumn private metadata", entity.id)); // if there's no query, the query lives in the table entity instead of the column entity DataConfig config = getDataConfig(); List<Integer> parentIds = config.getParentIds(entity.id); Map<Integer, String> idToType = config.getEntityTypes(parentIds); for (int id : parentIds) { if (Strings.equal(idToType.get(id), EntityType.TABLE)) { tableId = id; break; } } } String dataType = entity.publicMetadata.get(PublicMetadata.DATATYPE); ConnectionInfo connInfo = getColumnConnectionInfo(entity); List<String> keys = null; List<Double> numericData = null; List<String> stringData = null; List<Object> thirdColumn = null; // hack for dimension slider format List<PGGeom> geometricData = null; if (!Strings.isEmpty(query)) { keys = new ArrayList<String>(); ////// begin MIN/MAX code // use config min,max or param min,max to filter the data double minValue = Double.NaN; double maxValue = Double.NaN; // server min,max values take priority over user-specified params if (entity.publicMetadata.containsKey(PublicMetadata.MIN)) { try { minValue = Double.parseDouble(entity.publicMetadata.get(PublicMetadata.MIN)); } catch (Exception e) { } } else { minValue = minParam; } if (entity.publicMetadata.containsKey(PublicMetadata.MAX)) { try { maxValue = Double.parseDouble(entity.publicMetadata.get(PublicMetadata.MAX)); } catch (Exception e) { } } else { maxValue = maxParam; } if (Double.isNaN(minValue)) minValue = Double.NEGATIVE_INFINITY; if (Double.isNaN(maxValue)) maxValue = Double.POSITIVE_INFINITY; ////// end MIN/MAX code try { Connection conn = getStaticReadOnlyConnection(connInfo); // use default sqlParams if not specified by query params if (sqlParams == null || sqlParams.length == 0) { String sqlParamsString = entity.privateMetadata.get(PrivateMetadata.SQLPARAMS); sqlParams = CSVParser.defaultParser.parseCSVRow(sqlParamsString, true); } SQLResult result = SQLUtils.getResultFromQuery(conn, query, sqlParams, false); // if dataType is defined in the config file, use that value. // otherwise, derive it from the sql result. if (Strings.isEmpty(dataType)) { dataType = DataType.fromSQLType(result.columnTypes[1]); entity.publicMetadata.put( PublicMetadata.DATATYPE, dataType); // fill in missing metadata for the client } if (dataType.equalsIgnoreCase(DataType.NUMBER)) // special case: "number" => Double { numericData = new LinkedList<Double>(); } else if (dataType.equalsIgnoreCase(DataType.GEOMETRY)) { geometricData = new LinkedList<PGGeom>(); } else { stringData = new LinkedList<String>(); } // hack for dimension slider format if (result.columnTypes.length == 3) thirdColumn = new LinkedList<Object>(); Object keyObj, dataObj; double value; for (int i = 0; i < result.rows.length; i++) { keyObj = result.rows[i][0]; if (keyObj == null) continue; dataObj = result.rows[i][1]; if (dataObj == null) continue; if (numericData != null) { try { if (dataObj instanceof String) dataObj = Double.parseDouble((String) dataObj); value = ((Number) dataObj).doubleValue(); } catch (Exception e) { continue; } // filter the data based on the min,max values if (minValue <= value && value <= maxValue) numericData.add(value); else continue; } else if (geometricData != null) { // The dataObj must be cast to PGgeometry before an individual Geometry can be // extracted. if (!(dataObj instanceof PGgeometry)) continue; Geometry geom = ((PGgeometry) dataObj).getGeometry(); int numPoints = geom.numPoints(); // Create PGGeom Bean here and fill it up! PGGeom bean = new PGGeom(); bean.type = geom.getType(); bean.xyCoords = new double[numPoints * 2]; for (int j = 0; j < numPoints; j++) { Point pt = geom.getPoint(j); bean.xyCoords[j * 2] = pt.x; bean.xyCoords[j * 2 + 1] = pt.y; } geometricData.add(bean); } else { stringData.add(dataObj.toString()); } // if we got here, it means a data value was added, so add the corresponding key keys.add(keyObj.toString()); // hack for dimension slider format if (thirdColumn != null) thirdColumn.add(result.rows[i][2]); } } catch (SQLException e) { System.err.println(query); e.printStackTrace(); throw new RemoteException(String.format("Unable to retrieve data for column %s", columnId)); } catch (NullPointerException e) { e.printStackTrace(); throw new RemoteException("Unexpected error", e); } } AttributeColumnData result = new AttributeColumnData(); result.id = entity.id; result.tableId = tableId; result.tableField = tableField; result.metadata = entity.publicMetadata; if (keys != null) result.keys = keys.toArray(new String[keys.size()]); if (numericData != null) result.data = numericData.toArray(); else if (geometricData != null) result.data = geometricData.toArray(); else if (stringData != null) result.data = stringData.toArray(); // hack for dimension slider if (thirdColumn != null) result.thirdColumn = thirdColumn.toArray(); return result; }