Strabon
changeset 1203:5fe95b6e25fc
fixed NULL pointer exception that was from StrabonPolyhedron when one passed a WKT representation containing the URI for the CRS (stRDF/wktLiteral). In this case, parsing of WKT using JTS was failing causing StrabonPolyhedron to continue parsing for GML, which was failing as well
| author | Babis Nikolaou <charnik@di.uoa.gr> |
|---|---|
| date | Sat Jul 13 20:11:01 2013 +0300 (2013-07-13) |
| parents | 7ad711e19d01 |
| children | d928a2a245f5 |
| files | evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/StrabonPolyhedron.java evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/WKTHelper.java postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java.orig runtime/src/test/java/eu/earthobservatory/runtime/postgis/TemplateTests.java |
line diff
1.1 --- a/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java Sat Jul 13 19:28:12 2013 +0300 1.2 +++ b/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java Sat Jul 13 20:11:01 2013 +0300 1.3 @@ -81,6 +81,39 @@ 1.4 } 1.5 1.6 /** 1.7 + * This constructor tries to guess the datatype of the WKT literal. 1.8 + * It should be used only when one does not have such information 1.9 + * available. 1.10 + * 1.11 + * NOTICE: it is not guaranteed that guessing will fill-in the 1.12 + * datatype, but it is guaranteed that parsing will be done 1.13 + * correctly in any case (well, except for illegal cases). 1.14 + * 1.15 + * @param literalValue 1.16 + */ 1.17 + public AbstractWKT(String literalValue) { 1.18 + datatype = null; 1.19 + 1.20 + if (literalValue.indexOf(WKTHelper.STRDF_SRID_DELIM) > 0) { // strdf:WKT 1.21 + datatype = GeoConstants.WKT; 1.22 + 1.23 + isstRDFWKT = true; 1.24 + parsestRDFWKT(literalValue); 1.25 + 1.26 + } else { // wktLiteral or plain WKT 1.27 + if (literalValue.charAt(0) == '<') { // starts with a URI, assume wktLiteral 1.28 + datatype = GeoConstants.WKTLITERAL; 1.29 + 1.30 + isstRDFWKT = false; 1.31 + parseWKTLITERAL(literalValue); 1.32 + 1.33 + } else { // cannot guess, only WKT representation was given 1.34 + parsestRDFWKT(literalValue); 1.35 + } 1.36 + } 1.37 + } 1.38 + 1.39 + /** 1.40 * Parses a WKT literal according to the specification of stRDF/stSPARQL. 1.41 * The literal value may (not) specify the URI of a spatial reference system. 1.42 *
2.1 --- a/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/StrabonPolyhedron.java Sat Jul 13 19:28:12 2013 +0300 2.2 +++ b/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/StrabonPolyhedron.java Sat Jul 13 20:11:01 2013 +0300 2.3 @@ -53,6 +53,7 @@ 2.4 * {@link StrabonPolyhedron} instance through any kind of representation and of course 2.5 * getting a {@link StrabonPolyhedron} instance in a specific representation. 2.6 * 2.7 + * @author Charalampos Nikolaou <charnik@di.uoa.gr> 2.8 * @author Manos Karpathiotakis <mk@di.uoa.gr> 2.9 * @author Kostis Kyzirakos <kk@di.uoa.gr> 2.10 * 2.11 @@ -104,6 +105,10 @@ 2.12 * in the representation of the argument. The representation could be 2.13 * either in WKT or in GML. 2.14 * 2.15 + * NOTICE: whoever creates StrabonPolyhedron objects is responsible 2.16 + * for cleaning the representation of the geometry by removing any 2.17 + * stRDF/GeoSPARQL specific information, such as the SRID. 2.18 + * 2.19 * @param representation 2.20 * @throws Exception 2.21 */
3.1 --- a/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/WKTHelper.java Sat Jul 13 19:28:12 2013 +0300 3.2 +++ b/evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/WKTHelper.java Sat Jul 13 20:11:01 2013 +0300 3.3 @@ -24,7 +24,7 @@ 3.4 3.5 private static Logger logger = LoggerFactory.getLogger(org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper.class); 3.6 3.7 - private static String SRID_DELIM = ";"; 3.8 + public static String STRDF_SRID_DELIM = ";"; 3.9 private static String CUT_DELIM = "/"; 3.10 private static String URI_ENDING = ">"; 3.11 3.12 @@ -37,7 +37,7 @@ 3.13 public static String getWithoutSRID(String wkt) { 3.14 if (wkt == null) return wkt; 3.15 3.16 - int pos = wkt.indexOf(SRID_DELIM); 3.17 + int pos = wkt.indexOf(STRDF_SRID_DELIM); 3.18 if (pos != -1) { 3.19 return wkt.substring(0, pos); 3.20 3.21 @@ -59,7 +59,7 @@ 3.22 3.23 if (wkt == null) return srid; 3.24 3.25 - int pos = wkt.indexOf(SRID_DELIM); 3.26 + int pos = wkt.indexOf(STRDF_SRID_DELIM); 3.27 if (pos != -1) { 3.28 try { 3.29 srid = Integer.parseInt(wkt.substring(wkt.lastIndexOf(CUT_DELIM) + 1).replace(URI_ENDING, ""));
4.1 --- a/postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java Sat Jul 13 19:28:12 2013 +0300 4.2 +++ b/postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java Sat Jul 13 20:11:01 2013 +0300 4.3 @@ -12,6 +12,7 @@ 4.4 import java.util.ArrayList; 4.5 import java.util.List; 4.6 4.7 +import org.openrdf.query.algebra.evaluation.function.spatial.AbstractWKT; 4.8 import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron; 4.9 import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 4.10 import org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar; 4.11 @@ -986,13 +987,17 @@ 4.12 4.13 StrabonPolyhedron poly = null; 4.14 try{ 4.15 - poly = new StrabonPolyhedron(raw); 4.16 + // have to parse it before and clean it from possible appearance of CRS 4.17 + AbstractWKT wkt = new AbstractWKT(raw); 4.18 + 4.19 + poly = new StrabonPolyhedron(wkt.getWKT()); 4.20 + 4.21 + filter.append(" ST_GeomFromText('"+poly.toWKT() +"',"+String.valueOf(wkt.getSRID())+")"); 4.22 + 4.23 } catch (Exception e) { 4.24 e.printStackTrace(); 4.25 } 4.26 4.27 - filter.append(" ST_GeomFromText('"+poly.toWKT() +"',"+String.valueOf(GeoConstants.defaultSRID)+")"); 4.28 - 4.29 return raw; 4.30 } 4.31
5.1 --- a/postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java.orig Sat Jul 13 19:28:12 2013 +0300 5.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 5.3 @@ -1,2150 +0,0 @@ 5.4 -/* 5.5 - * Copyright Aduna (http://www.aduna-software.com/) (c) 2008. 5.6 - * 5.7 - * Licensed under the Aduna BSD-style license. 5.8 - */ 5.9 -package org.openrdf.sail.postgis.evaluation; 5.10 - 5.11 -import java.util.ArrayList; 5.12 -import java.util.List; 5.13 - 5.14 -import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron; 5.15 -import org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar; 5.16 -import org.openrdf.sail.generaldb.algebra.GeneralDBDoubleValue; 5.17 -import org.openrdf.sail.generaldb.algebra.GeneralDBLabelColumn; 5.18 -import org.openrdf.sail.generaldb.algebra.GeneralDBNumericColumn; 5.19 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAbove; 5.20 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAnd; 5.21 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAnyInteract; 5.22 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlBelow; 5.23 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCase; 5.24 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlContains; 5.25 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlContainsMBB; 5.26 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCoveredBy; 5.27 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCovers; 5.28 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlDisjoint; 5.29 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlEqualsSpatial; 5.30 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoArea; 5.31 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoAsGML; 5.32 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoAsText; 5.33 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoBoundary; 5.34 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoBuffer; 5.35 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoConvexHull; 5.36 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDifference; 5.37 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDimension; 5.38 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDistance; 5.39 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoEnvelope; 5.40 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoGeometryType; 5.41 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIntersection; 5.42 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIsEmpty; 5.43 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIsSimple; 5.44 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid; 5.45 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference; 5.46 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform; 5.47 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion; 5.48 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside; 5.49 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlIntersects; 5.50 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlIsNull; 5.51 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlLeft; 5.52 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMathExpr; 5.53 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbEquals; 5.54 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbInside; 5.55 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbIntersects; 5.56 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlNot; 5.57 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull; 5.58 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlOverlap; 5.59 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlRelate; 5.60 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlRight; 5.61 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialConstructBinary; 5.62 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialConstructUnary; 5.63 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricBinary; 5.64 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricUnary; 5.65 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialProperty; 5.66 -import org.openrdf.sail.generaldb.algebra.GeneralDBSqlTouch; 5.67 -import org.openrdf.sail.generaldb.algebra.GeneralDBStringValue; 5.68 -import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn; 5.69 -import org.openrdf.sail.generaldb.algebra.GeneralDBUnionItem; 5.70 -import org.openrdf.sail.generaldb.algebra.base.BinaryGeneralDBOperator; 5.71 -import org.openrdf.sail.generaldb.algebra.base.GeneralDBFromItem; 5.72 -import org.openrdf.sail.generaldb.algebra.base.GeneralDBSqlExpr; 5.73 -import org.openrdf.sail.generaldb.algebra.base.TripleGeneralDBOperator; 5.74 -import org.openrdf.sail.generaldb.algebra.base.UnaryGeneralDBOperator; 5.75 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Contains; 5.76 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_CoveredBy; 5.77 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Covers; 5.78 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Disjoint; 5.79 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Equals; 5.80 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Inside; 5.81 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Meet; 5.82 -import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Overlap; 5.83 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Dc; 5.84 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ec; 5.85 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Eq; 5.86 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ntpp; 5.87 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ntppi; 5.88 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Po; 5.89 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Tpp; 5.90 -import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Tppi; 5.91 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Contains; 5.92 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Crosses; 5.93 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Disjoint; 5.94 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Equals; 5.95 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Intersects; 5.96 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Overlaps; 5.97 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Touches; 5.98 -import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Within; 5.99 -import org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder; 5.100 -import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlBracketBuilder; 5.101 -import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlExprBuilder; 5.102 -import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlJoinBuilder; 5.103 -import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlQueryBuilder; 5.104 -import org.openrdf.sail.rdbms.exceptions.RdbmsException; 5.105 -import org.openrdf.sail.rdbms.exceptions.UnsupportedRdbmsOperatorException; 5.106 - 5.107 -/** 5.108 - * Constructs an SQL query from {@link GeneralDBSqlExpr}s and {@link GeneralDBFromItem}s. 5.109 - * 5.110 - * @author Manos Karpathiotakis <mk@di.uoa.gr> 5.111 - * 5.112 - */ 5.113 -public class PostGISQueryBuilder extends GeneralDBQueryBuilder { 5.114 - 5.115 - public static final String STRDFGEO_FIELD = "strdfgeo"; 5.116 - public static final String SRID_FIELD = "srid"; 5.117 - public static final String ST_TRANSFORM = "ST_Transform"; 5.118 - public static final String ST_ASBINARY = "ST_AsBinary"; 5.119 - /** 5.120 - * If (spatial) label column met is null, I must not try to retrieve its srid. 5.121 - * Opting to ask for 'null' instead 5.122 - */ 5.123 - boolean nullLabel = false; 5.124 - 5.125 - public enum SpatialOperandsPostGIS { anyInteract, equals, contains, left, right, above, inside, below; } 5.126 - public enum SpatialFunctionsPostGIS 5.127 - { //stSPARQL++ 5.128 - //Spatial Relationships 5.129 - ST_Disjoint, 5.130 - ST_Touches, 5.131 - ST_Covers, 5.132 - ST_CoveredBy, 5.133 - ST_Overlaps, 5.134 - ST_Intersects, 5.135 - ST_Equals, 5.136 - ST_Relate, 5.137 - ST_Within, 5.138 - ST_Contains, 5.139 - 5.140 - 5.141 - //Spatial Constructs - Binary 5.142 - ST_Union, 5.143 - ST_Intersection, 5.144 - ST_Difference, 5.145 - ST_Buffer, 5.146 - ST_Transform, 5.147 - ST_SymDifference, 5.148 - 5.149 - 5.150 - //Spatial Constructs - Unary 5.151 - ST_Envelope, 5.152 - ST_ConvexHull, 5.153 - ST_Boundary, 5.154 - 5.155 - //Spatial Metrics - Binary 5.156 - ST_Distance, 5.157 - 5.158 - //Spatial Metrics - Unary 5.159 - ST_Area, 5.160 - 5.161 - //Spatial Properties - All Unary 5.162 - ST_Dimension, 5.163 - ST_GeometryType, 5.164 - ST_AsGML, 5.165 - ST_AsText, 5.166 - ST_SRID, 5.167 - ST_IsEmpty, 5.168 - ST_IsSimple, 5.169 - 5.170 - //GeoSPARQL 5.171 - //Simple Features 5.172 - SF_Equals, 5.173 - SF_Disjoint, 5.174 - SF_Intersects, 5.175 - SF_Touches, 5.176 - SF_Within, 5.177 - SF_Contains, 5.178 - SF_Overlaps, 5.179 - SF_Crosses, 5.180 - 5.181 - //RCC8 5.182 - RCC8_Eq, 5.183 - RCC8_Dc, 5.184 - RCC8_Ec, 5.185 - RCC8_Po, 5.186 - RCC8_Tppi, 5.187 - RCC8_Tpp, 5.188 - RCC8_Ntppi, 5.189 - RCC8_Ntpp, 5.190 - 5.191 - //Egenhofer 5.192 - EH_Equals, 5.193 - EH_Disjoint, 5.194 - EH_Meet, 5.195 - EH_Overlap, 5.196 - EH_Covers, 5.197 - EH_CoveredBy, 5.198 - EH_Inside, 5.199 - EH_Contains, 5.200 - ; 5.201 - } 5.202 - 5.203 - public enum DateTimeFunctionsPostGIS { 5.204 - Difference; 5.205 - } 5.206 - 5.207 - public PostGISQueryBuilder() { 5.208 - super(); 5.209 - } 5.210 - 5.211 - public PostGISQueryBuilder(GeneralDBSqlQueryBuilder builder) { 5.212 - super(builder); 5.213 - this.query = builder; 5.214 - } 5.215 - 5.216 - @Override 5.217 - protected void append(GeneralDBSqlNull expr, GeneralDBSqlExprBuilder filter) { 5.218 - filter.appendNull(); 5.219 - } 5.220 - 5.221 - @Override 5.222 - protected void append(GeneralDBSqlIsNull expr, GeneralDBSqlExprBuilder filter) 5.223 - throws UnsupportedRdbmsOperatorException 5.224 - { 5.225 - dispatch(expr.getArg(), filter); 5.226 - filter.isNull(); 5.227 - } 5.228 - 5.229 - @Override 5.230 - protected void append(GeneralDBSqlNot expr, GeneralDBSqlExprBuilder filter) 5.231 - throws UnsupportedRdbmsOperatorException 5.232 - { 5.233 - if (expr.getArg() instanceof GeneralDBSqlIsNull) { 5.234 - GeneralDBSqlIsNull arg = (GeneralDBSqlIsNull)expr.getArg(); 5.235 - dispatch(arg.getArg(), filter); 5.236 - filter.isNotNull(); 5.237 - } 5.238 - else { 5.239 - GeneralDBSqlBracketBuilder open = filter.not(); 5.240 - dispatch(expr.getArg(), (GeneralDBSqlExprBuilder) open); 5.241 - open.close(); 5.242 - } 5.243 - } 5.244 - 5.245 - @Override 5.246 - protected void append(GeneralDBLabelColumn var, GeneralDBSqlExprBuilder filter) { 5.247 - if (var.getRdbmsVar().isResource()) { 5.248 - filter.appendNull(); 5.249 - nullLabel = true; 5.250 - } 5.251 - else { 5.252 - if(var.isSpatial()) 5.253 - { 5.254 - filter.appendFunction(ST_ASBINARY); 5.255 - filter.openBracket(); 5.256 - //XXX SRID 5.257 - filter.appendFunction(ST_TRANSFORM); 5.258 - filter.openBracket(); 5.259 - // 5.260 - String alias = getLabelAlias(var.getRdbmsVar()); 5.261 - 5.262 - filter.column(alias, STRDFGEO_FIELD); 5.263 - //XXX SRID 5.264 - filter.appendComma(); 5.265 - filter.column(alias, SRID_FIELD); 5.266 - filter.closeBracket(); 5.267 - // 5.268 - filter.closeBracket(); 5.269 - 5.270 - //Adding srid field explicitly for my StrabonPolyhedron constructor later on! 5.271 - filter.appendComma(); 5.272 - filter.column(alias, SRID_FIELD); 5.273 - } 5.274 - else 5.275 - { 5.276 - //XXX original/default case 5.277 - String alias = getLabelAlias(var.getRdbmsVar()); 5.278 - filter.column(alias, "value"); 5.279 - } 5.280 - } 5.281 - } 5.282 - 5.283 - @Override 5.284 - protected void append(GeneralDBSqlAnd expr, GeneralDBSqlExprBuilder filter) 5.285 - throws UnsupportedRdbmsOperatorException 5.286 - { 5.287 - dispatch(expr.getLeftArg(), filter); 5.288 - filter.and(); 5.289 - dispatch(expr.getRightArg(), filter); 5.290 - } 5.291 - 5.292 - protected GeneralDBSqlJoinBuilder subJoinAndFilter(GeneralDBSqlJoinBuilder query, GeneralDBFromItem from) 5.293 - throws RdbmsException, UnsupportedRdbmsOperatorException 5.294 - { 5.295 - if (from instanceof GeneralDBUnionItem) { 5.296 - GeneralDBUnionItem union = (GeneralDBUnionItem)from; 5.297 - List<String> names = union.getSelectVarNames(); 5.298 - List<GeneralDBColumnVar> vars = union.appendVars(new ArrayList<GeneralDBColumnVar>()); 5.299 - GeneralDBSqlQueryBuilder subquery = query.subquery(); 5.300 - for (GeneralDBFromItem item : union.getUnion()) { 5.301 - for (int i = 0, n = names.size(); i < n; i++) { 5.302 - GeneralDBColumnVar var = item.getVar(names.get(i)); 5.303 - GeneralDBSqlExprBuilder select = subquery.select(); 5.304 - if (var == null) { 5.305 - select.appendNull(); 5.306 - } 5.307 - else if (var.isImplied()) { 5.308 - select.appendNumeric(vf.getInternalId(var.getValue())); 5.309 - } 5.310 - else { 5.311 - select.column(var.getAlias(), var.getColumn()); 5.312 - } 5.313 - select.as(vars.get(i).getColumn()); 5.314 - } 5.315 - from(subquery, item); 5.316 - subquery = subquery.union(); 5.317 - } 5.318 - } 5.319 - for (GeneralDBFromItem join : from.getJoins()) { 5.320 - join(query, join); 5.321 - } 5.322 - for (GeneralDBSqlExpr expr : from.getFilters()) { 5.323 - dispatch(expr, query.on().and()); 5.324 - } 5.325 - return query; 5.326 - } 5.327 - 5.328 - //FIXME my addition from here on 5.329 - 5.330 - //Issue with this function: crashes when MathExpr is present in Select but does not 5.331 - //involve spatial variables! must escape this somehow 5.332 - @Override 5.333 - public GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) throws UnsupportedRdbmsOperatorException 5.334 - { 5.335 - if(!(expr instanceof GeneralDBSqlSpatialMetricBinary) 5.336 - &&!(expr instanceof GeneralDBSqlSpatialMetricUnary) 5.337 - &&!(expr instanceof GeneralDBSqlMathExpr) 5.338 - &&!(expr instanceof GeneralDBSqlSpatialProperty)) 5.339 - { 5.340 - query.select().appendFunction(ST_ASBINARY); 5.341 - } 5.342 - else 5.343 - { 5.344 - query.select(); 5.345 - } 5.346 - if(expr instanceof BinaryGeneralDBOperator) 5.347 - { 5.348 - dispatchBinarySqlOperator((BinaryGeneralDBOperator) expr, query.select); 5.349 - } 5.350 - else if(expr instanceof UnaryGeneralDBOperator) 5.351 - { 5.352 - dispatchUnarySqlOperator((UnaryGeneralDBOperator) expr, query.select); 5.353 - } 5.354 - //SRID support must be explicitly added! 5.355 - 5.356 - return this; 5.357 - } 5.358 - 5.359 - //Spatial Relationship Functions 5.360 - @Override 5.361 - protected void append(GeneralDBSqlAnyInteract expr, GeneralDBSqlExprBuilder filter) 5.362 - throws UnsupportedRdbmsOperatorException 5.363 - { 5.364 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersects); 5.365 - } 5.366 - 5.367 - 5.368 - @Override 5.369 - protected void append(GeneralDBSqlIntersects expr, GeneralDBSqlExprBuilder filter) 5.370 - throws UnsupportedRdbmsOperatorException { 5.371 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersects); 5.372 - } 5.373 - 5.374 - @Override 5.375 - protected void append(GeneralDBSqlContains expr, GeneralDBSqlExprBuilder filter) 5.376 - throws UnsupportedRdbmsOperatorException { 5.377 - 5.378 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Contains); 5.379 - } 5.380 - 5.381 - 5.382 - 5.383 - 5.384 - @Override 5.385 - protected void append(GeneralDBSqlEqualsSpatial expr, GeneralDBSqlExprBuilder filter) 5.386 - throws UnsupportedRdbmsOperatorException { 5.387 - 5.388 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Equals); 5.389 - } 5.390 - 5.391 - @Override 5.392 - protected void append(GeneralDBSqlInside expr, GeneralDBSqlExprBuilder filter) 5.393 - throws UnsupportedRdbmsOperatorException { 5.394 - 5.395 - //appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.inside); 5.396 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Within); 5.397 - 5.398 - } 5.399 - 5.400 - @Override 5.401 - protected void append(GeneralDBSqlCovers expr, GeneralDBSqlExprBuilder filter) 5.402 - throws UnsupportedRdbmsOperatorException { 5.403 - 5.404 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Covers); 5.405 - } 5.406 - 5.407 - @Override 5.408 - protected void append(GeneralDBSqlCoveredBy expr, GeneralDBSqlExprBuilder filter) 5.409 - throws UnsupportedRdbmsOperatorException { 5.410 - 5.411 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_CoveredBy); 5.412 - } 5.413 - 5.414 - @Override 5.415 - protected void append(GeneralDBSqlTouch expr, GeneralDBSqlExprBuilder filter) 5.416 - throws UnsupportedRdbmsOperatorException { 5.417 - 5.418 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Touches); 5.419 - } 5.420 - 5.421 - @Override 5.422 - protected void append(GeneralDBSqlOverlap expr, GeneralDBSqlExprBuilder filter) 5.423 - throws UnsupportedRdbmsOperatorException { 5.424 - 5.425 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Overlaps); 5.426 - } 5.427 - 5.428 - protected void append(GeneralDBSqlDisjoint expr, GeneralDBSqlExprBuilder filter) 5.429 - throws UnsupportedRdbmsOperatorException { 5.430 - 5.431 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Disjoint); 5.432 - } 5.433 - 5.434 - @Override 5.435 - protected void append(GeneralDBSqlRelate expr, GeneralDBSqlExprBuilder filter) 5.436 - throws UnsupportedRdbmsOperatorException 5.437 - { 5.438 - appendGeneralDBSpatialFunctionTriple(expr, filter, SpatialFunctionsPostGIS.ST_Relate); 5.439 - } 5.440 - 5.441 - @Override 5.442 - protected void append(GeneralDBSqlLeft expr, GeneralDBSqlExprBuilder filter) 5.443 - throws UnsupportedRdbmsOperatorException 5.444 - { 5.445 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.left); 5.446 - } 5.447 - 5.448 - @Override 5.449 - protected void append(GeneralDBSqlRight expr, GeneralDBSqlExprBuilder filter) 5.450 - throws UnsupportedRdbmsOperatorException 5.451 - { 5.452 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.right); 5.453 - } 5.454 - 5.455 - @Override 5.456 - protected void append(GeneralDBSqlAbove expr, GeneralDBSqlExprBuilder filter) 5.457 - throws UnsupportedRdbmsOperatorException 5.458 - { 5.459 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.above); 5.460 - } 5.461 - 5.462 - @Override 5.463 - protected void append(GeneralDBSqlBelow expr, GeneralDBSqlExprBuilder filter) 5.464 - throws UnsupportedRdbmsOperatorException 5.465 - { 5.466 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.below); 5.467 - } 5.468 - 5.469 - @Override 5.470 - protected void append(GeneralDBSqlMbbIntersects expr, GeneralDBSqlExprBuilder filter) 5.471 - throws UnsupportedRdbmsOperatorException { 5.472 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.anyInteract); 5.473 - } 5.474 - 5.475 - @Override 5.476 - protected void append(GeneralDBSqlMbbInside expr, GeneralDBSqlExprBuilder filter) 5.477 - throws UnsupportedRdbmsOperatorException { 5.478 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.inside); 5.479 - } 5.480 - 5.481 - 5.482 - @Override 5.483 - protected void append(GeneralDBSqlContainsMBB expr, GeneralDBSqlExprBuilder filter) 5.484 - throws UnsupportedRdbmsOperatorException { 5.485 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.contains); 5.486 - } 5.487 - 5.488 - 5.489 - @Override 5.490 - protected void append(GeneralDBSqlMbbEquals expr, GeneralDBSqlExprBuilder filter) 5.491 - throws UnsupportedRdbmsOperatorException { 5.492 - appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.equals); 5.493 - } 5.494 - 5.495 - //GeoSPARQL - Spatial Relationship Functions 5.496 - //Simple Features 5.497 - @Override 5.498 - protected void append(GeneralDBSqlSF_Contains expr, GeneralDBSqlExprBuilder filter) 5.499 - throws UnsupportedRdbmsOperatorException 5.500 - { 5.501 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Contains); 5.502 - } 5.503 - 5.504 - @Override 5.505 - protected void append(GeneralDBSqlSF_Crosses expr, GeneralDBSqlExprBuilder filter) 5.506 - throws UnsupportedRdbmsOperatorException 5.507 - { 5.508 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Crosses); 5.509 - } 5.510 - 5.511 - @Override 5.512 - protected void append(GeneralDBSqlSF_Disjoint expr, GeneralDBSqlExprBuilder filter) 5.513 - throws UnsupportedRdbmsOperatorException 5.514 - { 5.515 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Disjoint); 5.516 - } 5.517 - 5.518 - @Override 5.519 - protected void append(GeneralDBSqlSF_Equals expr, GeneralDBSqlExprBuilder filter) 5.520 - throws UnsupportedRdbmsOperatorException 5.521 - { 5.522 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Equals); 5.523 - } 5.524 - 5.525 - @Override 5.526 - protected void append(GeneralDBSqlSF_Intersects expr, GeneralDBSqlExprBuilder filter) 5.527 - throws UnsupportedRdbmsOperatorException 5.528 - { 5.529 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Intersects); 5.530 - } 5.531 - 5.532 - @Override 5.533 - protected void append(GeneralDBSqlSF_Overlaps expr, GeneralDBSqlExprBuilder filter) 5.534 - throws UnsupportedRdbmsOperatorException 5.535 - { 5.536 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Overlaps); 5.537 - } 5.538 - 5.539 - @Override 5.540 - protected void append(GeneralDBSqlSF_Touches expr, GeneralDBSqlExprBuilder filter) 5.541 - throws UnsupportedRdbmsOperatorException 5.542 - { 5.543 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Touches); 5.544 - } 5.545 - 5.546 - @Override 5.547 - protected void append(GeneralDBSqlSF_Within expr, GeneralDBSqlExprBuilder filter) 5.548 - throws UnsupportedRdbmsOperatorException 5.549 - { 5.550 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Within); 5.551 - } 5.552 - 5.553 - //Egenhofer 5.554 - @Override 5.555 - protected void append(GeneralDBSqlEgenhofer_CoveredBy expr, GeneralDBSqlExprBuilder filter) 5.556 - throws UnsupportedRdbmsOperatorException 5.557 - { 5.558 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_CoveredBy); 5.559 - } 5.560 - 5.561 - @Override 5.562 - protected void append(GeneralDBSqlEgenhofer_Covers expr, GeneralDBSqlExprBuilder filter) 5.563 - throws UnsupportedRdbmsOperatorException 5.564 - { 5.565 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Covers); 5.566 - } 5.567 - 5.568 - @Override 5.569 - protected void append(GeneralDBSqlEgenhofer_Contains expr, GeneralDBSqlExprBuilder filter) 5.570 - throws UnsupportedRdbmsOperatorException 5.571 - { 5.572 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Contains); 5.573 - } 5.574 - 5.575 - @Override 5.576 - protected void append(GeneralDBSqlEgenhofer_Disjoint expr, GeneralDBSqlExprBuilder filter) 5.577 - throws UnsupportedRdbmsOperatorException 5.578 - { 5.579 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Disjoint); 5.580 - } 5.581 - 5.582 - @Override 5.583 - protected void append(GeneralDBSqlEgenhofer_Equals expr, GeneralDBSqlExprBuilder filter) 5.584 - throws UnsupportedRdbmsOperatorException 5.585 - { 5.586 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Equals); 5.587 - } 5.588 - 5.589 - @Override 5.590 - protected void append(GeneralDBSqlEgenhofer_Inside expr, GeneralDBSqlExprBuilder filter) 5.591 - throws UnsupportedRdbmsOperatorException 5.592 - { 5.593 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Inside); 5.594 - } 5.595 - 5.596 - @Override 5.597 - protected void append(GeneralDBSqlEgenhofer_Meet expr, GeneralDBSqlExprBuilder filter) 5.598 - throws UnsupportedRdbmsOperatorException 5.599 - { 5.600 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Meet); 5.601 - } 5.602 - 5.603 - @Override 5.604 - protected void append(GeneralDBSqlEgenhofer_Overlap expr, GeneralDBSqlExprBuilder filter) 5.605 - throws UnsupportedRdbmsOperatorException 5.606 - { 5.607 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Overlap); 5.608 - } 5.609 - 5.610 - //RCC8 5.611 - @Override 5.612 - protected void append(GeneralDBSqlRCC8_Dc expr, GeneralDBSqlExprBuilder filter) 5.613 - throws UnsupportedRdbmsOperatorException 5.614 - { 5.615 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Dc); 5.616 - } 5.617 - 5.618 - @Override 5.619 - protected void append(GeneralDBSqlRCC8_Eq expr, GeneralDBSqlExprBuilder filter) 5.620 - throws UnsupportedRdbmsOperatorException 5.621 - { 5.622 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Eq); 5.623 - } 5.624 - 5.625 - @Override 5.626 - protected void append(GeneralDBSqlRCC8_Ec expr, GeneralDBSqlExprBuilder filter) 5.627 - throws UnsupportedRdbmsOperatorException 5.628 - { 5.629 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ec); 5.630 - } 5.631 - 5.632 - @Override 5.633 - protected void append(GeneralDBSqlRCC8_Po expr, GeneralDBSqlExprBuilder filter) 5.634 - throws UnsupportedRdbmsOperatorException 5.635 - { 5.636 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Po); 5.637 - } 5.638 - 5.639 - @Override 5.640 - protected void append(GeneralDBSqlRCC8_Tppi expr, GeneralDBSqlExprBuilder filter) 5.641 - throws UnsupportedRdbmsOperatorException 5.642 - { 5.643 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Tppi); 5.644 - } 5.645 - 5.646 - @Override 5.647 - protected void append(GeneralDBSqlRCC8_Tpp expr, GeneralDBSqlExprBuilder filter) 5.648 - throws UnsupportedRdbmsOperatorException 5.649 - { 5.650 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Tpp); 5.651 - } 5.652 - 5.653 - @Override 5.654 - protected void append(GeneralDBSqlRCC8_Ntpp expr, GeneralDBSqlExprBuilder filter) 5.655 - throws UnsupportedRdbmsOperatorException 5.656 - { 5.657 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ntpp); 5.658 - } 5.659 - 5.660 - @Override 5.661 - protected void append(GeneralDBSqlRCC8_Ntppi expr, GeneralDBSqlExprBuilder filter) 5.662 - throws UnsupportedRdbmsOperatorException 5.663 - { 5.664 - appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ntppi); 5.665 - } 5.666 - 5.667 - //Spatial Construct Functions 5.668 - @Override 5.669 - protected void append(GeneralDBSqlGeoUnion expr, GeneralDBSqlExprBuilder filter) 5.670 - throws UnsupportedRdbmsOperatorException 5.671 - { 5.672 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Union); 5.673 - } 5.674 - 5.675 - @Override 5.676 - protected void append(GeneralDBSqlGeoBuffer expr, GeneralDBSqlExprBuilder filter) 5.677 - throws UnsupportedRdbmsOperatorException 5.678 - { 5.679 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Buffer); 5.680 - } 5.681 - 5.682 - //XXX Different Behavior 5.683 - @Override 5.684 - protected void append(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 5.685 - throws UnsupportedRdbmsOperatorException 5.686 - { 5.687 - appendTransformFunc(expr, filter); 5.688 - } 5.689 - 5.690 - @Override 5.691 - protected void append(GeneralDBSqlGeoEnvelope expr, GeneralDBSqlExprBuilder filter) 5.692 - throws UnsupportedRdbmsOperatorException 5.693 - { 5.694 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Envelope); 5.695 - } 5.696 - 5.697 - @Override 5.698 - protected void append(GeneralDBSqlGeoConvexHull expr, GeneralDBSqlExprBuilder filter) 5.699 - throws UnsupportedRdbmsOperatorException 5.700 - { 5.701 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_ConvexHull); 5.702 - } 5.703 - 5.704 - @Override 5.705 - protected void append(GeneralDBSqlGeoBoundary expr, GeneralDBSqlExprBuilder filter) 5.706 - throws UnsupportedRdbmsOperatorException 5.707 - { 5.708 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Boundary); 5.709 - } 5.710 - 5.711 - @Override 5.712 - protected void append(GeneralDBSqlGeoIntersection expr, GeneralDBSqlExprBuilder filter) 5.713 - throws UnsupportedRdbmsOperatorException 5.714 - { 5.715 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersection); 5.716 - } 5.717 - 5.718 - @Override 5.719 - protected void append(GeneralDBSqlGeoDifference expr, GeneralDBSqlExprBuilder filter) 5.720 - throws UnsupportedRdbmsOperatorException 5.721 - { 5.722 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Difference); 5.723 - } 5.724 - 5.725 - @Override 5.726 - protected void append(GeneralDBSqlGeoSymDifference expr, GeneralDBSqlExprBuilder filter) 5.727 - throws UnsupportedRdbmsOperatorException 5.728 - { 5.729 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_SymDifference); 5.730 - } 5.731 - 5.732 - //Spatial Metric Functions 5.733 - @Override 5.734 - protected void append(GeneralDBSqlGeoDistance expr, GeneralDBSqlExprBuilder filter) 5.735 - throws UnsupportedRdbmsOperatorException 5.736 - { 5.737 - appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Distance); 5.738 - } 5.739 - 5.740 - @Override 5.741 - protected void append(GeneralDBSqlGeoArea expr, GeneralDBSqlExprBuilder filter) 5.742 - throws UnsupportedRdbmsOperatorException 5.743 - { 5.744 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Area); 5.745 - } 5.746 - 5.747 - //Spatial Property Functions 5.748 - @Override 5.749 - protected void append(GeneralDBSqlGeoDimension expr, GeneralDBSqlExprBuilder filter) 5.750 - throws UnsupportedRdbmsOperatorException 5.751 - { 5.752 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Dimension); 5.753 - } 5.754 - 5.755 - @Override 5.756 - protected void append(GeneralDBSqlGeoGeometryType expr, GeneralDBSqlExprBuilder filter) 5.757 - throws UnsupportedRdbmsOperatorException 5.758 - { 5.759 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_GeometryType); 5.760 - } 5.761 - 5.762 - @Override 5.763 - protected void append(GeneralDBSqlGeoAsText expr, GeneralDBSqlExprBuilder filter) 5.764 - throws UnsupportedRdbmsOperatorException 5.765 - { 5.766 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_AsText); 5.767 - } 5.768 - 5.769 - @Override 5.770 - protected void append(GeneralDBSqlGeoAsGML expr, GeneralDBSqlExprBuilder filter) 5.771 - throws UnsupportedRdbmsOperatorException 5.772 - { 5.773 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_AsGML); 5.774 - } 5.775 - 5.776 - // @Override 5.777 - // protected void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter) 5.778 - // throws UnsupportedRdbmsOperatorException 5.779 - // { 5.780 - // appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_SRID); 5.781 - // } 5.782 - 5.783 - /** 5.784 - * Special Case because I need to retrieve a single different column from geo_values when this function occurs 5.785 - * in the select clause 5.786 - */ 5.787 - @Override 5.788 - protected void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter) 5.789 - throws UnsupportedRdbmsOperatorException 5.790 - { 5.791 - boolean sridNeeded = true; 5.792 - filter.openBracket(); 5.793 - 5.794 - boolean check1 = expr.getArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.795 - boolean check2 = false; 5.796 - if(expr.getArg() instanceof GeneralDBLabelColumn) 5.797 - { 5.798 - if(((GeneralDBLabelColumn) expr.getArg()).getRdbmsVar().isResource()) 5.799 - { 5.800 - check2 = true; 5.801 - } 5.802 - } 5.803 - if(check1) 5.804 - { 5.805 - this.append((GeneralDBSqlNull)expr.getArg(), filter); 5.806 - 5.807 - } 5.808 - else if (check2) 5.809 - { 5.810 - appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter); 5.811 - } 5.812 - else 5.813 - { 5.814 - //XXX Incorporating SRID 5.815 - GeneralDBSqlExpr tmp = expr; 5.816 - if(tmp.getParentNode() == null) 5.817 - { 5.818 - String sridExpr; 5.819 - while(true) 5.820 - { 5.821 - GeneralDBSqlExpr child = null; 5.822 - 5.823 - if(tmp instanceof BinaryGeneralDBOperator) 5.824 - { 5.825 - child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 5.826 - } 5.827 - else if(tmp instanceof UnaryGeneralDBOperator) 5.828 - { 5.829 - child = ((UnaryGeneralDBOperator) tmp).getArg(); 5.830 - } 5.831 - else if(tmp instanceof GeneralDBStringValue) 5.832 - { 5.833 - //Constant!! 5.834 - sridNeeded = false; 5.835 - break; 5.836 - } 5.837 - 5.838 - tmp = child; 5.839 - if(tmp instanceof GeneralDBLabelColumn) 5.840 - { 5.841 - //Reached the innermost left var -> need to capture its SRID 5.842 - String alias; 5.843 - if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) { 5.844 - //Predicates used in triple patterns non-existent in db 5.845 - alias="NULL"; 5.846 - } 5.847 - else 5.848 - { 5.849 - //Reached the innermost left var -> need to capture its SRID 5.850 - alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar()); 5.851 - alias=alias+".srid"; 5.852 - } 5.853 - sridExpr = alias; 5.854 - filter.append(sridExpr); 5.855 - filter.closeBracket(); 5.856 - return; 5.857 - //break; 5.858 - } 5.859 - else if(tmp instanceof GeneralDBStringValue) 5.860 - { 5.861 - //Constant!! 5.862 - sridNeeded = false; 5.863 - break; 5.864 - } 5.865 - 5.866 - } 5.867 - } 5.868 - 5.869 - if(sridNeeded) 5.870 - { 5.871 - filter.appendFunction("ST_SRID"); 5.872 - filter.openBracket(); 5.873 - if(expr.getArg() instanceof GeneralDBStringValue) 5.874 - { 5.875 - appendWKT(expr.getArg(),filter); 5.876 - } 5.877 - else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.878 - { 5.879 - appendConstructFunction(expr.getArg(), filter); 5.880 - } 5.881 - else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.882 - { 5.883 - appendConstructFunction(expr.getArg(), filter); 5.884 - } 5.885 - else if(expr.getArg() instanceof GeneralDBSqlCase) 5.886 - { 5.887 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getArg()).getEntries().get(0).getResult(); 5.888 - appendMBB(onlyLabel,filter); 5.889 - } 5.890 - else 5.891 - { 5.892 - appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter); 5.893 - } 5.894 - 5.895 - filter.closeBracket(); 5.896 - } 5.897 - else 5.898 - { 5.899 - //4326 by default - Software House additions 5.900 - filter.append("4326"); 5.901 - } 5.902 - } 5.903 - 5.904 - filter.closeBracket(); 5.905 - } 5.906 - 5.907 - @Override 5.908 - protected void append(GeneralDBSqlGeoIsSimple expr, GeneralDBSqlExprBuilder filter) 5.909 - throws UnsupportedRdbmsOperatorException 5.910 - { 5.911 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsSimple); 5.912 - } 5.913 - 5.914 - @Override 5.915 - protected void append(GeneralDBSqlGeoIsEmpty expr, GeneralDBSqlExprBuilder filter) 5.916 - throws UnsupportedRdbmsOperatorException 5.917 - { 5.918 - appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsEmpty); 5.919 - } 5.920 - 5.921 - 5.922 - /** 5.923 - * 'helper' functions 5.924 - */ 5.925 - 5.926 - @Override 5.927 - protected String appendWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 5.928 - { 5.929 - GeneralDBStringValue arg = (GeneralDBStringValue) expr; 5.930 - String raw = arg.getValue(); 5.931 - 5.932 - StrabonPolyhedron poly = null; 5.933 - try{ 5.934 - poly = new StrabonPolyhedron(raw); 5.935 - } catch (Exception e) { 5.936 - e.printStackTrace(); 5.937 - } 5.938 - 5.939 - filter.append(" ST_GeomFromText('"+poly.toWKT() +"',4326)"); 5.940 - 5.941 - return raw; 5.942 - } 5.943 - 5.944 - //Used in all the generaldb boolean spatial functions of the form ?GEO1 ~ ?GEO2 5.945 - // protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException 5.946 - // { 5.947 - // filter.openBracket(); 5.948 - // 5.949 - // boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.950 - // //boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.951 - // 5.952 - // if(check1a) 5.953 - // { 5.954 - // this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.955 - // 5.956 - // } 5.957 - //// else if(check2a) 5.958 - //// { 5.959 - //// this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.960 - //// } 5.961 - // else 5.962 - // { 5.963 - // if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.964 - // { 5.965 - // this.append((GeneralDBSqlCase)expr.getLeftArg(), filter); 5.966 - // } 5.967 - // else if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.968 - // { 5.969 - // appendWKT(expr.getLeftArg(),filter); 5.970 - // } 5.971 - // else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.972 - // { 5.973 - // appendConstructFunction(expr.getLeftArg(), filter); 5.974 - // } 5.975 - // else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.976 - // { 5.977 - // appendConstructFunction(expr.getLeftArg(), filter); 5.978 - // } 5.979 - // else 5.980 - // { 5.981 - // appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.982 - // } 5.983 - // 5.984 - // switch(operand) 5.985 - // { 5.986 - // case anyInteract: filter.anyInteract(); break; 5.987 - // case equals: filter.equals(); break; 5.988 - // case contains: filter.contains(); break; 5.989 - // case inside: filter.inside(); break; 5.990 - // case left: filter.left(); break; 5.991 - // case right: filter.right(); break; 5.992 - // case above: filter.above(); break; 5.993 - // case below: filter.below(); break; 5.994 - // } 5.995 - // 5.996 - // boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.997 - // 5.998 - // if(check2a) 5.999 - // { 5.1000 - // this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1001 - // } 5.1002 - // else 5.1003 - // { 5.1004 - // 5.1005 - // if(expr.getRightArg() instanceof GeneralDBSqlCase) 5.1006 - // { 5.1007 - // this.append((GeneralDBSqlCase)expr.getRightArg(), filter); 5.1008 - // } 5.1009 - // else if(expr.getRightArg() instanceof GeneralDBStringValue) 5.1010 - // { 5.1011 - // appendWKT(expr.getRightArg(),filter); 5.1012 - // } 5.1013 - // else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1014 - // { 5.1015 - // appendConstructFunction(expr.getRightArg(), filter); 5.1016 - // } 5.1017 - // else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1018 - // { 5.1019 - // appendConstructFunction(expr.getRightArg(), filter); 5.1020 - // } 5.1021 - // else 5.1022 - // { 5.1023 - // appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter); 5.1024 - // } 5.1025 - // 5.1026 - // } 5.1027 - // } 5.1028 - // filter.closeBracket(); 5.1029 - // } 5.1030 - 5.1031 - 5.1032 - protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException 5.1033 - { 5.1034 - filter.openBracket(); 5.1035 - 5.1036 - boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1037 - boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1038 - 5.1039 - if(check1a) 5.1040 - { 5.1041 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1042 - 5.1043 - } 5.1044 - else if(check2a) 5.1045 - { 5.1046 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1047 - } 5.1048 - else 5.1049 - { 5.1050 - if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.1051 - { 5.1052 - this.append((GeneralDBSqlCase)expr.getLeftArg(), filter); 5.1053 - } 5.1054 - else if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.1055 - { 5.1056 - appendWKT(expr.getLeftArg(),filter); 5.1057 - } 5.1058 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1059 - { 5.1060 - appendConstructFunction(expr.getLeftArg(), filter); 5.1061 - } 5.1062 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1063 - { 5.1064 - appendConstructFunction(expr.getLeftArg(), filter); 5.1065 - } 5.1066 - else 5.1067 - { 5.1068 - appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.1069 - } 5.1070 - 5.1071 - switch(operand) 5.1072 - { 5.1073 - case anyInteract: filter.intersectsMBB(); break; 5.1074 - case equals: filter.equalsMBB(); break; 5.1075 - case contains: filter.containsMBB(); break; 5.1076 - case inside: filter.insideMBB(); break; 5.1077 - case left: filter.leftMBB(); break; 5.1078 - case right: filter.rightMBB(); break; 5.1079 - case above: filter.aboveMBB(); break; 5.1080 - case below: filter.belowMBB(); break; 5.1081 - } 5.1082 - 5.1083 - // boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1084 - // 5.1085 - // if(check2a) 5.1086 - // { 5.1087 - // this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1088 - // } 5.1089 - // else 5.1090 - // { 5.1091 - 5.1092 - if(expr.getRightArg() instanceof GeneralDBSqlCase) 5.1093 - { 5.1094 - this.append((GeneralDBSqlCase)expr.getRightArg(), filter); 5.1095 - } 5.1096 - else if(expr.getRightArg() instanceof GeneralDBStringValue) 5.1097 - { 5.1098 - appendWKT(expr.getRightArg(),filter); 5.1099 - } 5.1100 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1101 - { 5.1102 - appendConstructFunction(expr.getRightArg(), filter); 5.1103 - } 5.1104 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1105 - { 5.1106 - appendConstructFunction(expr.getRightArg(), filter); 5.1107 - } 5.1108 - else 5.1109 - { 5.1110 - appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter); 5.1111 - } 5.1112 - 5.1113 - //} 5.1114 - } 5.1115 - filter.closeBracket(); 5.1116 - } 5.1117 - 5.1118 - //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2) 5.1119 - protected void appendTransformFunc(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 5.1120 - throws UnsupportedRdbmsOperatorException 5.1121 - { 5.1122 - //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))") 5.1123 - boolean sridNeeded = true; 5.1124 - //XXX Incorporating SRID 5.1125 - String sridExpr = null; 5.1126 - 5.1127 - filter.openBracket(); 5.1128 - filter.appendFunction(ST_TRANSFORM); 5.1129 - filter.openBracket(); 5.1130 - 5.1131 - boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1132 - boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1133 - 5.1134 - if(check1) 5.1135 - { 5.1136 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1137 - 5.1138 - } 5.1139 - else if(check2) 5.1140 - { 5.1141 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1142 - } 5.1143 - else 5.1144 - { 5.1145 - GeneralDBSqlExpr tmp = expr; 5.1146 - if(tmp instanceof GeneralDBSqlSpatialConstructBinary && tmp.getParentNode() == null) 5.1147 - { 5.1148 - while(true) 5.1149 - { 5.1150 - GeneralDBSqlExpr child; 5.1151 - 5.1152 - if(tmp instanceof BinaryGeneralDBOperator) 5.1153 - { 5.1154 - child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 5.1155 - } 5.1156 - else //(tmp instanceof UnaryGeneralDBOperator) 5.1157 - { 5.1158 - child = ((UnaryGeneralDBOperator) tmp).getArg(); 5.1159 - } 5.1160 - 5.1161 - tmp = child; 5.1162 - if(tmp instanceof GeneralDBLabelColumn) 5.1163 - { 5.1164 - String alias; 5.1165 - if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) { 5.1166 - //Predicates used in triple patterns non-existent in db 5.1167 - alias="NULL"; 5.1168 - } 5.1169 - else 5.1170 - { 5.1171 - //Reached the innermost left var -> need to capture its SRID 5.1172 - alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar()); 5.1173 - alias=alias+".srid"; 5.1174 - } 5.1175 - sridExpr = alias; 5.1176 - break; 5.1177 - } 5.1178 - else if (tmp instanceof GeneralDBStringValue) //Constant!! 5.1179 - { 5.1180 - sridNeeded = false; 5.1181 - break; 5.1182 - } 5.1183 - 5.1184 - } 5.1185 - if(sridNeeded) 5.1186 - { 5.1187 - filter.appendFunction(ST_TRANSFORM); 5.1188 - filter.openBracket(); 5.1189 - } 5.1190 - } 5.1191 - 5.1192 - if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.1193 - { 5.1194 - appendWKT(expr.getLeftArg(),filter); 5.1195 - } 5.1196 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1197 - { 5.1198 - appendConstructFunction(expr.getLeftArg(), filter); 5.1199 - } 5.1200 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1201 - { 5.1202 - appendConstructFunction(expr.getLeftArg(), filter); 5.1203 - } 5.1204 - else if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.1205 - { 5.1206 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 5.1207 - appendMBB(onlyLabel,filter); 5.1208 - } 5.1209 - else 5.1210 - { 5.1211 - appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.1212 - } 5.1213 - 5.1214 - //SRID Support 5.1215 - if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null) 5.1216 - { 5.1217 - filter.appendComma(); 5.1218 - //filter.append(((GeneralDBSqlSpatialConstructBinary)expr).getSrid()); 5.1219 - filter.append(sridExpr); 5.1220 - filter.closeBracket(); 5.1221 - } 5.1222 - 5.1223 - filter.appendComma(); 5.1224 - 5.1225 - if(expr.getRightArg() instanceof GeneralDBSqlCase) //case met in transform! 5.1226 - { 5.1227 - GeneralDBURIColumn plainURI = (GeneralDBURIColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult(); 5.1228 - 5.1229 - //XXX This case would be met if we recovered the SRID URI from the db!!! 5.1230 - //Need to set sridExpr to the value of this new URI, otherwise the appended uri 5.1231 - //to the spatial object will be the wrong one!!!! (Seee following case) 5.1232 - filter.keepSRID_part1(); 5.1233 - append(plainURI, filter); 5.1234 - filter.keepSRID_part2(); 5.1235 - append(plainURI, filter); 5.1236 - filter.keepSRID_part3(); 5.1237 - } 5.1238 - else if(expr.getRightArg() instanceof GeneralDBStringValue) 5.1239 - { 5.1240 - String unparsedSRID = ((GeneralDBStringValue)expr.getRightArg()).getValue(); 5.1241 - // int srid = Integer.parseInt(unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1)); 5.1242 - sridExpr = unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1); 5.1243 - filter.append(sridExpr); 5.1244 - filter.closeBracket(); 5.1245 - } 5.1246 - 5.1247 - 5.1248 - } 5.1249 - filter.closeBracket(); 5.1250 - //In this case, SRID is the one that has been provided by the user!! 5.1251 - //I am including this extra binding to be used in subsequent (Aggregate) steps 5.1252 - if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null) 5.1253 - { 5.1254 - filter.appendComma(); 5.1255 - filter.append(sridExpr); 5.1256 - } 5.1257 - 5.1258 - } 5.1259 - 5.1260 - /** Addition for datetime metric functions 5.1261 - * 5.1262 - * @author George Garbis <ggarbis@di.uoa.gr> 5.1263 - * 5.1264 - */ 5.1265 - 5.1266 - protected void appendGeneralDBDateTimeFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, DateTimeFunctionsPostGIS func) 5.1267 - throws UnsupportedRdbmsOperatorException 5.1268 - { 5.1269 - 5.1270 - filter.openBracket(); 5.1271 - 5.1272 - boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1273 - boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1274 - 5.1275 - if(check1) 5.1276 - { 5.1277 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1278 - 5.1279 - } 5.1280 - else if(check2) 5.1281 - { 5.1282 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1283 - } 5.1284 - else 5.1285 - { 5.1286 - switch (func){ 5.1287 - case Difference: 5.1288 - append(((GeneralDBLabelColumn)expr.getRightArg()),filter); 5.1289 - filter.append(" - "); 5.1290 - append(((GeneralDBLabelColumn)expr.getRightArg()),filter); 5.1291 - break; 5.1292 - } 5.1293 - 5.1294 - } 5.1295 - } 5.1296 - 5.1297 - // Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1, ?GEO2) 5.1298 - // EXCEPT ST_Transform!!! 5.1299 - protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 5.1300 - throws UnsupportedRdbmsOperatorException 5.1301 - { 5.1302 - //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))") 5.1303 - boolean sridNeeded = true; 5.1304 - String sridExpr = null; 5.1305 - 5.1306 - filter.openBracket(); 5.1307 - 5.1308 - boolean check1 = expr.getArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1309 - boolean check2 = false; 5.1310 - if(expr.getArg() instanceof GeneralDBLabelColumn) 5.1311 - { 5.1312 - if(((GeneralDBLabelColumn) expr.getArg()).getRdbmsVar().isResource()) 5.1313 - { 5.1314 - check2 = true; 5.1315 - } 5.1316 - } 5.1317 - if(check1) 5.1318 - { 5.1319 - this.append((GeneralDBSqlNull)expr.getArg(), filter); 5.1320 - 5.1321 - } 5.1322 - else if (check2) 5.1323 - { 5.1324 - appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter); 5.1325 - } 5.1326 - else 5.1327 - { 5.1328 - 5.1329 - GeneralDBSqlExpr tmp = expr; 5.1330 - 5.1331 - 5.1332 - if(tmp instanceof GeneralDBSqlSpatialConstructUnary && tmp.getParentNode() == null) 5.1333 - { 5.1334 - while(true) 5.1335 - { 5.1336 - GeneralDBSqlExpr child = null; 5.1337 - 5.1338 - if(tmp instanceof BinaryGeneralDBOperator) 5.1339 - { 5.1340 - child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 5.1341 - } 5.1342 - else if(tmp instanceof UnaryGeneralDBOperator) 5.1343 - { 5.1344 - child = ((UnaryGeneralDBOperator) tmp).getArg(); 5.1345 - } 5.1346 - else if(tmp instanceof GeneralDBStringValue) 5.1347 - { 5.1348 - sridNeeded = false; 5.1349 - break; 5.1350 - } 5.1351 - 5.1352 - tmp = child; 5.1353 - if(tmp instanceof GeneralDBLabelColumn) 5.1354 - { 5.1355 - //Reached the innermost left var -> need to capture its SRID 5.1356 - String alias; 5.1357 - if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) { 5.1358 - //Predicates used in triple patterns non-existent in db 5.1359 - alias="NULL"; 5.1360 - } 5.1361 - else 5.1362 - { 5.1363 - //Reached the innermost left var -> need to capture its SRID 5.1364 - alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar()); 5.1365 - alias=alias+".srid"; 5.1366 - } 5.1367 - sridExpr = alias; 5.1368 - break; 5.1369 - } 5.1370 - else if (tmp instanceof GeneralDBStringValue) //Constant!! 5.1371 - { 5.1372 - sridNeeded = false; 5.1373 - break; 5.1374 - } 5.1375 - 5.1376 - } 5.1377 - if(sridNeeded) 5.1378 - { 5.1379 - filter.appendFunction(ST_TRANSFORM); 5.1380 - filter.openBracket(); 5.1381 - } 5.1382 - } 5.1383 - ///// 5.1384 - 5.1385 - switch(func) 5.1386 - { 5.1387 - case ST_Envelope: filter.appendFunction("ST_Envelope"); break; 5.1388 - case ST_ConvexHull: filter.appendFunction("ST_ConvexHull"); break; 5.1389 - case ST_Boundary: filter.appendFunction("ST_Boundary"); break; 5.1390 - case ST_Area: filter.appendFunction("ST_Area"); break; 5.1391 - case ST_Dimension: filter.appendFunction("ST_Dimension"); break; 5.1392 - case ST_GeometryType: filter.appendFunction("ST_GeometryType"); break; 5.1393 - case ST_AsText: filter.appendFunction("ST_AsText"); break; 5.1394 - case ST_AsGML: filter.appendFunction("ST_AsGML"); break; 5.1395 - case ST_SRID: filter.appendFunction("ST_SRID"); break; 5.1396 - case ST_IsEmpty: filter.appendFunction("ST_IsEmpty"); break; 5.1397 - case ST_IsSimple: filter.appendFunction("ST_IsSimple"); break; 5.1398 - } 5.1399 - filter.openBracket(); 5.1400 - if(expr.getArg() instanceof GeneralDBStringValue) 5.1401 - { 5.1402 - appendWKT(expr.getArg(),filter); 5.1403 - } 5.1404 - else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1405 - { 5.1406 - appendConstructFunction(expr.getArg(), filter); 5.1407 - } 5.1408 - else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1409 - { 5.1410 - appendConstructFunction(expr.getArg(), filter); 5.1411 - } 5.1412 - else if(expr.getArg() instanceof GeneralDBSqlCase) 5.1413 - { 5.1414 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getArg()).getEntries().get(0).getResult(); 5.1415 - appendMBB(onlyLabel,filter); 5.1416 - } 5.1417 - else 5.1418 - { 5.1419 - appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter); 5.1420 - } 5.1421 - 5.1422 - filter.closeBracket(); 5.1423 - // //SRID Support 5.1424 - if(sridNeeded) 5.1425 - { 5.1426 - if(expr instanceof GeneralDBSqlSpatialConstructUnary && expr.getParentNode() == null) 5.1427 - { 5.1428 - filter.appendComma(); 5.1429 - // filter.append(((GeneralDBSqlSpatialConstructUnary)expr).getSrid()); 5.1430 - filter.append(sridExpr); 5.1431 - filter.closeBracket(); 5.1432 - } 5.1433 - } 5.1434 - /// 5.1435 - } 5.1436 - 5.1437 - filter.closeBracket(); 5.1438 - //Used to explicitly include SRID 5.1439 - if(expr instanceof GeneralDBSqlSpatialConstructUnary && expr.getParentNode() == null) 5.1440 - { 5.1441 - filter.appendComma(); 5.1442 - filter.append(sridExpr); 5.1443 - } 5.1444 - } 5.1445 - 5.1446 - //Used in all the generaldb boolean spatial functions of the form ST_Function(?GEO1,?GEO2) 5.1447 - protected void appendGeneralDBSpatialFunctionTriple(TripleGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 5.1448 - throws UnsupportedRdbmsOperatorException 5.1449 - { 5.1450 - filter.openBracket(); 5.1451 - 5.1452 - boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1453 - boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1454 - boolean check3 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1455 - 5.1456 - if(check1a) 5.1457 - { 5.1458 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1459 - 5.1460 - } 5.1461 - else if(check2a) 5.1462 - { 5.1463 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1464 - } 5.1465 - else if(check3) 5.1466 - { 5.1467 - this.append((GeneralDBSqlNull)expr.getThirdArg(), filter); 5.1468 - } 5.1469 - else 5.1470 - { 5.1471 - switch(func) 5.1472 - { 5.1473 - case ST_Relate: filter.appendFunction("ST_Relate"); break; 5.1474 - } 5.1475 - filter.openBracket(); 5.1476 - if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.1477 - { 5.1478 - appendWKT(expr.getLeftArg(),filter); 5.1479 - } 5.1480 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1481 - { 5.1482 - appendConstructFunction(expr.getLeftArg(), filter); 5.1483 - } 5.1484 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1485 - { 5.1486 - appendConstructFunction(expr.getLeftArg(), filter); 5.1487 - } 5.1488 - else if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.1489 - { 5.1490 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 5.1491 - appendMBB(onlyLabel,filter); 5.1492 - } 5.1493 - else 5.1494 - { 5.1495 - appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.1496 - } 5.1497 - filter.appendComma(); 5.1498 - // boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1499 - // if(check2) 5.1500 - // { 5.1501 - // this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1502 - // } 5.1503 - // else 5.1504 - // { 5.1505 - if(expr.getRightArg() instanceof GeneralDBStringValue) 5.1506 - { 5.1507 - appendWKT(expr.getRightArg(),filter); 5.1508 - } 5.1509 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1510 - { 5.1511 - appendConstructFunction(expr.getRightArg(), filter); 5.1512 - } 5.1513 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1514 - { 5.1515 - appendConstructFunction(expr.getRightArg(), filter); 5.1516 - } 5.1517 - else if(expr.getRightArg() instanceof GeneralDBSqlCase) 5.1518 - { 5.1519 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult(); 5.1520 - appendMBB(onlyLabel,filter); 5.1521 - } 5.1522 - else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer! 5.1523 - { 5.1524 - append(((GeneralDBDoubleValue)expr.getRightArg()), filter); 5.1525 - } 5.1526 - else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer! 5.1527 - { 5.1528 - append(((GeneralDBNumericColumn)expr.getRightArg()), filter); 5.1529 - } 5.1530 - //case met in buffer when in select -> buffer(?spatial,?thematic) 5.1531 - else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial()) 5.1532 - { 5.1533 - append(((GeneralDBLabelColumn)expr.getRightArg()),filter); 5.1534 - appendCastToDouble(filter); 5.1535 - } 5.1536 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary) 5.1537 - { 5.1538 - appendMetricFunction(expr.getRightArg(), filter); 5.1539 - } 5.1540 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary) 5.1541 - { 5.1542 - appendMetricFunction(expr.getRightArg(), filter); 5.1543 - } 5.1544 - else 5.1545 - { 5.1546 - appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter); 5.1547 - } 5.1548 - 5.1549 - // } 5.1550 - //3rd arg 5.1551 - filter.appendComma(); 5.1552 - // boolean check3 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1553 - // if(check3) 5.1554 - // { 5.1555 - // this.append((GeneralDBSqlNull)expr.getThirdArg(), filter); 5.1556 - // } 5.1557 - // else 5.1558 - // { 5.1559 - 5.1560 - if(expr.getThirdArg() instanceof GeneralDBStringValue) 5.1561 - { 5.1562 - append(((GeneralDBStringValue)expr.getThirdArg()),filter); 5.1563 - } 5.1564 - else if(expr.getThirdArg() instanceof GeneralDBSqlCase) 5.1565 - { 5.1566 - append(((GeneralDBSqlCase)expr.getThirdArg()),filter); 5.1567 - } 5.1568 - //case met in buffer when in select -> buffer(?spatial,?thematic) 5.1569 - else if(expr.getThirdArg() instanceof GeneralDBLabelColumn )//&& !((GeneralDBLabelColumn)expr.getThirdArg()).isSpatial()) 5.1570 - { 5.1571 - 5.1572 - append(((GeneralDBLabelColumn)expr.getThirdArg()),filter); 5.1573 - } 5.1574 - 5.1575 - 5.1576 - // } 5.1577 - filter.closeBracket(); 5.1578 - } 5.1579 - 5.1580 - filter.closeBracket(); 5.1581 - } 5.1582 - 5.1583 - 5.1584 - //GeoSPARQL 5.1585 - //XXX 5.1586 - protected void appendRelate(BinaryGeneralDBOperator expr, PostGISSqlExprBuilder filter, char[] intersectionPattern) 5.1587 - throws UnsupportedRdbmsOperatorException 5.1588 - { 5.1589 - filter.openBracket(); 5.1590 - 5.1591 - boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1592 - boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1593 - 5.1594 - if(check1) 5.1595 - { 5.1596 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1597 - 5.1598 - } 5.1599 - else if(check2) 5.1600 - { 5.1601 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.1602 - } 5.1603 - else 5.1604 - { 5.1605 - filter.appendFunction("ST_Relate"); 5.1606 - 5.1607 - 5.1608 - filter.openBracket(); 5.1609 - if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.1610 - { 5.1611 - appendWKT(expr.getLeftArg(),filter); 5.1612 - } 5.1613 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1614 - { 5.1615 - appendConstructFunction(expr.getLeftArg(), filter); 5.1616 - } 5.1617 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1618 - { 5.1619 - appendConstructFunction(expr.getLeftArg(), filter); 5.1620 - } 5.1621 - else if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.1622 - { 5.1623 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 5.1624 - appendMBB(onlyLabel,filter); 5.1625 - } 5.1626 - else 5.1627 - { 5.1628 - appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.1629 - } 5.1630 - filter.appendComma(); 5.1631 - 5.1632 - if(expr.getRightArg() instanceof GeneralDBStringValue) 5.1633 - { 5.1634 - appendWKT(expr.getRightArg(),filter); 5.1635 - } 5.1636 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.1637 - { 5.1638 - appendConstructFunction(expr.getRightArg(), filter); 5.1639 - } 5.1640 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.1641 - { 5.1642 - appendConstructFunction(expr.getRightArg(), filter); 5.1643 - } 5.1644 - else if(expr.getRightArg() instanceof GeneralDBSqlCase) 5.1645 - { 5.1646 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult(); 5.1647 - appendMBB(onlyLabel,filter); 5.1648 - } 5.1649 - else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer! 5.1650 - { 5.1651 - append(((GeneralDBDoubleValue)expr.getRightArg()), filter); 5.1652 - } 5.1653 - else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer! 5.1654 - { 5.1655 - append(((GeneralDBNumericColumn)expr.getRightArg()), filter); 5.1656 - } 5.1657 - //case met in buffer when in select -> buffer(?spatial,?thematic) 5.1658 - else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial()) 5.1659 - { 5.1660 - append(((GeneralDBLabelColumn)expr.getRightArg()),filter); 5.1661 - appendCastToDouble(filter); 5.1662 - } 5.1663 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary) 5.1664 - { 5.1665 - appendMetricFunction(expr.getRightArg(), filter); 5.1666 - } 5.1667 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary) 5.1668 - { 5.1669 - appendMetricFunction(expr.getRightArg(), filter); 5.1670 - } 5.1671 - else 5.1672 - { 5.1673 - appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter); 5.1674 - } 5.1675 - 5.1676 - //3rd arg 5.1677 - filter.appendComma(); 5.1678 - 5.1679 - //must turn the table of characters I have to a valid sql value! 5.1680 - filter.append("'"); 5.1681 - for(int i = 0; i< intersectionPattern.length; i++) 5.1682 - { 5.1683 - filter.append(intersectionPattern[i]+""); 5.1684 - } 5.1685 - filter.append("'"); 5.1686 - 5.1687 - filter.closeBracket(); 5.1688 - 5.1689 - } 5.1690 - 5.1691 - filter.closeBracket(); 5.1692 - } 5.1693 - 5.1694 - 5.1695 - protected void appendgeoSPARQLSpatialRelation(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 5.1696 - throws UnsupportedRdbmsOperatorException 5.1697 - { 5.1698 - filter.openBracket(); 5.1699 - boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.1700 - if(check1) 5.1701 - { 5.1702 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.1703 - 5.1704 - } 5.1705 - else 5.1706 - { 5.1707 - char[][] intersectionPattern = null; 5.1708 - switch(func) 5.1709 - { 5.1710 - case ST_Covers: 5.1711 - intersectionPattern = new char[1][9]; 5.1712 - intersectionPattern[0][0] = 'T'; 5.1713 - intersectionPattern[0][1] = '*'; 5.1714 - intersectionPattern[0][2] = 'T'; 5.1715 - intersectionPattern[0][3] = 'F'; 5.1716 - intersectionPattern[0][4] = 'T'; 5.1717 - intersectionPattern[0][5] = '*'; 5.1718 - intersectionPattern[0][6] = 'F'; 5.1719 - intersectionPattern[0][7] = 'F'; 5.1720 - intersectionPattern[0][8] = '*'; 5.1721 - break; 5.1722 - case ST_CoveredBy: 5.1723 - intersectionPattern = new char[1][9]; 5.1724 - intersectionPattern[0][0] = 'T'; 5.1725 - intersectionPattern[0][1] = 'F'; 5.1726 - intersectionPattern[0][2] = 'F'; 5.1727 - intersectionPattern[0][3] = '*'; 5.1728 - intersectionPattern[0][4] = 'T'; 5.1729 - intersectionPattern[0][5] = 'F'; 5.1730 - intersectionPattern[0][6] = 'T'; 5.1731 - intersectionPattern[0][7] = '*'; 5.1732 - intersectionPattern[0][8] = '*'; 5.1733 - break; 5.1734 - case SF_Contains: 5.1735 - intersectionPattern = new char[1][9]; 5.1736 - intersectionPattern[0][0] = 'T'; 5.1737 - intersectionPattern[0][1] = '*'; 5.1738 - intersectionPattern[0][2] = '*'; 5.1739 - intersectionPattern[0][3] = '*'; 5.1740 - intersectionPattern[0][4] = '*'; 5.1741 - intersectionPattern[0][5] = '*'; 5.1742 - intersectionPattern[0][6] = 'F'; 5.1743 - intersectionPattern[0][7] = 'F'; 5.1744 - intersectionPattern[0][8] = '*'; 5.1745 - break; 5.1746 - case SF_Crosses: 5.1747 - intersectionPattern = new char[1][9]; 5.1748 - intersectionPattern[0][0] = 'T'; 5.1749 - intersectionPattern[0][1] = '*'; 5.1750 - intersectionPattern[0][2] = 'T'; 5.1751 - intersectionPattern[0][3] = '*'; 5.1752 - intersectionPattern[0][4] = '*'; 5.1753 - intersectionPattern[0][5] = '*'; 5.1754 - intersectionPattern[0][6] = '*'; 5.1755 - intersectionPattern[0][7] = '*'; 5.1756 - intersectionPattern[0][8] = '*'; 5.1757 - break; 5.1758 - case SF_Disjoint: 5.1759 - case EH_Disjoint: 5.1760 - intersectionPattern = new char[1][9]; 5.1761 - intersectionPattern[0][0] = 'F'; 5.1762 - intersectionPattern[0][1] = 'F'; 5.1763 - intersectionPattern[0][2] = '*'; 5.1764 - intersectionPattern[0][3] = 'F'; 5.1765 - intersectionPattern[0][4] = 'F'; 5.1766 - intersectionPattern[0][5] = '*'; 5.1767 - intersectionPattern[0][6] = '*'; 5.1768 - intersectionPattern[0][7] = '*'; 5.1769 - intersectionPattern[0][8] = '*'; 5.1770 - break; 5.1771 - case SF_Equals: 5.1772 - case EH_Equals: 5.1773 - case RCC8_Eq: 5.1774 - intersectionPattern = new char[1][9]; 5.1775 - intersectionPattern[0][0] = 'T'; 5.1776 - intersectionPattern[0][1] = 'F'; 5.1777 - intersectionPattern[0][2] = 'F'; 5.1778 - intersectionPattern[0][3] = 'F'; 5.1779 - intersectionPattern[0][4] = 'T'; 5.1780 - intersectionPattern[0][5] = 'F'; 5.1781 - intersectionPattern[0][6] = 'F'; 5.1782 - intersectionPattern[0][7] = 'F'; 5.1783 - intersectionPattern[0][8] = 'T'; 5.1784 - break; 5.1785 - case SF_Overlaps: 5.1786 - case EH_Overlap: 5.1787 - intersectionPattern = new char[1][9]; 5.1788 - intersectionPattern[0][0] = 'T'; 5.1789 - intersectionPattern[0][1] = '*'; 5.1790 - intersectionPattern[0][2] = 'T'; 5.1791 - intersectionPattern[0][3] = '*'; 5.1792 - intersectionPattern[0][4] = '*'; 5.1793 - intersectionPattern[0][5] = '*'; 5.1794 - intersectionPattern[0][6] = 'T'; 5.1795 - intersectionPattern[0][7] = '*'; 5.1796 - intersectionPattern[0][8] = '*'; 5.1797 - break; 5.1798 - case SF_Within: 5.1799 - intersectionPattern = new char[1][9]; 5.1800 - intersectionPattern[0][0] = 'T'; 5.1801 - intersectionPattern[0][1] = '*'; 5.1802 - intersectionPattern[0][2] = 'F'; 5.1803 - intersectionPattern[0][3] = '*'; 5.1804 - intersectionPattern[0][4] = '*'; 5.1805 - intersectionPattern[0][5] = 'F'; 5.1806 - intersectionPattern[0][6] = '*'; 5.1807 - intersectionPattern[0][7] = '*'; 5.1808 - intersectionPattern[0][8] = '*'; 5.1809 - break; 5.1810 - case EH_Covers: 5.1811 - intersectionPattern = new char[1][9]; 5.1812 - intersectionPattern[0][0] = 'T'; 5.1813 - intersectionPattern[0][1] = '*'; 5.1814 - intersectionPattern[0][2] = 'T'; 5.1815 - intersectionPattern[0][3] = 'F'; 5.1816 - intersectionPattern[0][4] = 'T'; 5.1817 - intersectionPattern[0][5] = '*'; 5.1818 - intersectionPattern[0][6] = 'F'; 5.1819 - intersectionPattern[0][7] = 'F'; 5.1820 - intersectionPattern[0][8] = '*'; 5.1821 - break; 5.1822 - case EH_CoveredBy: 5.1823 - intersectionPattern = new char[1][9]; 5.1824 - intersectionPattern[0][0] = 'T'; 5.1825 - intersectionPattern[0][1] = 'F'; 5.1826 - intersectionPattern[0][2] = 'F'; 5.1827 - intersectionPattern[0][3] = '*'; 5.1828 - intersectionPattern[0][4] = 'T'; 5.1829 - intersectionPattern[0][5] = 'F'; 5.1830 - intersectionPattern[0][6] = 'T'; 5.1831 - intersectionPattern[0][7] = '*'; 5.1832 - intersectionPattern[0][8] = '*'; 5.1833 - break; 5.1834 - case EH_Inside: 5.1835 - intersectionPattern = new char[1][9]; 5.1836 - intersectionPattern[0][0] = 'T'; 5.1837 - intersectionPattern[0][1] = 'F'; 5.1838 - intersectionPattern[0][2] = 'F'; 5.1839 - intersectionPattern[0][3] = '*'; 5.1840 - intersectionPattern[0][4] = 'F'; 5.1841 - intersectionPattern[0][5] = 'F'; 5.1842 - intersectionPattern[0][6] = 'T'; 5.1843 - intersectionPattern[0][7] = '*'; 5.1844 - intersectionPattern[0][8] = '*'; 5.1845 - break; 5.1846 - case EH_Contains: 5.1847 - intersectionPattern = new char[1][9]; 5.1848 - intersectionPattern[0][0] = 'T'; 5.1849 - intersectionPattern[0][1] = '*'; 5.1850 - intersectionPattern[0][2] = 'T'; 5.1851 - intersectionPattern[0][3] = 'F'; 5.1852 - intersectionPattern[0][4] = 'F'; 5.1853 - intersectionPattern[0][5] = '*'; 5.1854 - intersectionPattern[0][6] = 'F'; 5.1855 - intersectionPattern[0][7] = 'F'; 5.1856 - intersectionPattern[0][8] = '*'; 5.1857 - break; 5.1858 - case RCC8_Dc: 5.1859 - intersectionPattern = new char[1][9]; 5.1860 - intersectionPattern[0][0] = 'F'; 5.1861 - intersectionPattern[0][1] = 'F'; 5.1862 - intersectionPattern[0][2] = 'T'; 5.1863 - intersectionPattern[0][3] = 'F'; 5.1864 - intersectionPattern[0][4] = 'F'; 5.1865 - intersectionPattern[0][5] = 'T'; 5.1866 - intersectionPattern[0][6] = 'T'; 5.1867 - intersectionPattern[0][7] = 'T'; 5.1868 - intersectionPattern[0][8] = 'T'; 5.1869 - break; 5.1870 - case RCC8_Ec: 5.1871 - intersectionPattern = new char[1][9]; 5.1872 - intersectionPattern[0][0] = 'F'; 5.1873 - intersectionPattern[0][1] = 'F'; 5.1874 - intersectionPattern[0][2] = 'T'; 5.1875 - intersectionPattern[0][3] = 'F'; 5.1876 - intersectionPattern[0][4] = 'T'; 5.1877 - intersectionPattern[0][5] = 'T'; 5.1878 - intersectionPattern[0][6] = 'T'; 5.1879 - intersectionPattern[0][7] = 'T'; 5.1880 - intersectionPattern[0][8] = 'T'; 5.1881 - break; 5.1882 - case RCC8_Po: 5.1883 - intersectionPattern = new char[1][9]; 5.1884 - intersectionPattern[0][0] = 'T'; 5.1885 - intersectionPattern[0][1] = 'T'; 5.1886 - intersectionPattern[0][2] = 'T'; 5.1887 - intersectionPattern[0][3] = 'T'; 5.1888 - intersectionPattern[0][4] = 'T'; 5.1889 - intersectionPattern[0][5] = 'T'; 5.1890 - intersectionPattern[0][6] = 'T'; 5.1891 - intersectionPattern[0][7] = 'T'; 5.1892 - intersectionPattern[0][8] = 'T'; 5.1893 - break; 5.1894 - case RCC8_Tppi: 5.1895 - intersectionPattern = new char[1][9]; 5.1896 - intersectionPattern[0][0] = 'T'; 5.1897 - intersectionPattern[0][1] = 'T'; 5.1898 - intersectionPattern[0][2] = 'T'; 5.1899 - intersectionPattern[0][3] = 'F'; 5.1900 - intersectionPattern[0][4] = 'T'; 5.1901 - intersectionPattern[0][5] = 'T'; 5.1902 - intersectionPattern[0][6] = 'F'; 5.1903 - intersectionPattern[0][7] = 'F'; 5.1904 - intersectionPattern[0][8] = 'T'; 5.1905 - break; 5.1906 - case RCC8_Tpp: 5.1907 - intersectionPattern = new char[1][9]; 5.1908 - intersectionPattern[0][0] = 'T'; 5.1909 - intersectionPattern[0][1] = 'F'; 5.1910 - intersectionPattern[0][2] = 'F'; 5.1911 - intersectionPattern[0][3] = 'T'; 5.1912 - intersectionPattern[0][4] = 'T'; 5.1913 - intersectionPattern[0][5] = 'F'; 5.1914 - intersectionPattern[0][6] = 'T'; 5.1915 - intersectionPattern[0][7] = 'T'; 5.1916 - intersectionPattern[0][8] = 'T'; 5.1917 - break; 5.1918 - case RCC8_Ntpp: 5.1919 - intersectionPattern = new char[1][9]; 5.1920 - intersectionPattern[0][0] = 'T'; 5.1921 - intersectionPattern[0][1] = 'F'; 5.1922 - intersectionPattern[0][2] = 'F'; 5.1923 - intersectionPattern[0][3] = 'T'; 5.1924 - intersectionPattern[0][4] = 'F'; 5.1925 - intersectionPattern[0][5] = 'F'; 5.1926 - intersectionPattern[0][6] = 'T'; 5.1927 - intersectionPattern[0][7] = 'T'; 5.1928 - intersectionPattern[0][8] = 'T'; 5.1929 - break; 5.1930 - case RCC8_Ntppi: 5.1931 - intersectionPattern = new char[1][9]; 5.1932 - intersectionPattern[0][0] = 'T'; 5.1933 - intersectionPattern[0][1] = 'T'; 5.1934 - intersectionPattern[0][2] = 'T'; 5.1935 - intersectionPattern[0][3] = 'F'; 5.1936 - intersectionPattern[0][4] = 'F'; 5.1937 - intersectionPattern[0][5] = 'T'; 5.1938 - intersectionPattern[0][6] = 'F'; 5.1939 - intersectionPattern[0][7] = 'F'; 5.1940 - intersectionPattern[0][8] = 'T'; 5.1941 - break; 5.1942 - case SF_Intersects: 5.1943 - intersectionPattern = new char[4][9]; 5.1944 - intersectionPattern[0][0] = 'T'; 5.1945 - intersectionPattern[0][1] = '*'; 5.1946 - intersectionPattern[0][2] = '*'; 5.1947 - intersectionPattern[0][3] = '*'; 5.1948 - intersectionPattern[0][4] = '*'; 5.1949 - intersectionPattern[0][5] = '*'; 5.1950 - intersectionPattern[0][6] = '*'; 5.1951 - intersectionPattern[0][7] = '*'; 5.1952 - intersectionPattern[0][8] = '*'; 5.1953 - // 5.1954 - intersectionPattern[1][0] = '*'; 5.1955 - intersectionPattern[1][1] = 'T'; 5.1956 - intersectionPattern[1][2] = '*'; 5.1957 - intersectionPattern[1][3] = '*'; 5.1958 - intersectionPattern[1][4] = '*'; 5.1959 - intersectionPattern[1][5] = '*'; 5.1960 - intersectionPattern[1][6] = '*'; 5.1961 - intersectionPattern[1][7] = '*'; 5.1962 - intersectionPattern[1][8] = '*'; 5.1963 - // 5.1964 - intersectionPattern[2][0] = '*'; 5.1965 - intersectionPattern[2][1] = '*'; 5.1966 - intersectionPattern[2][2] = '*'; 5.1967 - intersectionPattern[2][3] = 'T'; 5.1968 - intersectionPattern[2][4] = '*'; 5.1969 - intersectionPattern[2][5] = '*'; 5.1970 - intersectionPattern[2][6] = '*'; 5.1971 - intersectionPattern[2][7] = '*'; 5.1972 - intersectionPattern[2][8] = '*'; 5.1973 - // 5.1974 - intersectionPattern[3][0] = '*'; 5.1975 - intersectionPattern[3][1] = '*'; 5.1976 - intersectionPattern[3][2] = '*'; 5.1977 - intersectionPattern[3][3] = '*'; 5.1978 - intersectionPattern[3][4] = 'T'; 5.1979 - intersectionPattern[3][5] = '*'; 5.1980 - intersectionPattern[3][6] = '*'; 5.1981 - intersectionPattern[3][7] = '*'; 5.1982 - intersectionPattern[3][8] = '*'; 5.1983 - break; 5.1984 - 5.1985 - case SF_Touches: 5.1986 - case EH_Meet: 5.1987 - intersectionPattern = new char[3][9]; 5.1988 - intersectionPattern[0][0] = 'F'; 5.1989 - intersectionPattern[0][1] = 'T'; 5.1990 - intersectionPattern[0][2] = '*'; 5.1991 - intersectionPattern[0][3] = '*'; 5.1992 - intersectionPattern[0][4] = '*'; 5.1993 - intersectionPattern[0][5] = '*'; 5.1994 - intersectionPattern[0][6] = '*'; 5.1995 - intersectionPattern[0][7] = '*'; 5.1996 - intersectionPattern[0][8] = '*'; 5.1997 - // 5.1998 - intersectionPattern[1][0] = 'F'; 5.1999 - intersectionPattern[1][1] = '*'; 5.2000 - intersectionPattern[1][2] = '*'; 5.2001 - intersectionPattern[1][3] = 'T'; 5.2002 - intersectionPattern[1][4] = '*'; 5.2003 - intersectionPattern[1][5] = '*'; 5.2004 - intersectionPattern[1][6] = '*'; 5.2005 - intersectionPattern[1][7] = '*'; 5.2006 - intersectionPattern[1][8] = '*'; 5.2007 - // 5.2008 - intersectionPattern[2][0] = 'F'; 5.2009 - intersectionPattern[2][1] = '*'; 5.2010 - intersectionPattern[2][2] = '*'; 5.2011 - intersectionPattern[2][3] = '*'; 5.2012 - intersectionPattern[2][4] = 'T'; 5.2013 - intersectionPattern[2][5] = '*'; 5.2014 - intersectionPattern[2][6] = '*'; 5.2015 - intersectionPattern[2][7] = '*'; 5.2016 - intersectionPattern[2][8] = '*'; 5.2017 - // 5.2018 - 5.2019 - } 5.2020 - 5.2021 - for(int i = 0; i < intersectionPattern.length ; i++) 5.2022 - { 5.2023 - appendRelate(expr, filter, intersectionPattern[i]); 5.2024 - if(i < intersectionPattern.length - 1) 5.2025 - { 5.2026 - //append OR and continue 5.2027 - filter.or(); 5.2028 - } 5.2029 - } 5.2030 - 5.2031 - //Also need bounding box intersection query to enable the usage of the Gist R-tree index 5.2032 - if(func != SpatialFunctionsPostGIS.SF_Disjoint && func != SpatialFunctionsPostGIS.EH_Disjoint && func != SpatialFunctionsPostGIS.RCC8_Dc) 5.2033 - { 5.2034 - filter.and(); 5.2035 - appendGeneralDBSpatialFunctionBinary(expr, filter,SpatialFunctionsPostGIS.ST_Intersects); 5.2036 - } 5.2037 - } 5.2038 - filter.closeBracket(); 5.2039 - } 5.2040 - 5.2041 - @Override 5.2042 - //GeoSPARQL 5.2043 - //XXX 5.2044 - 5.2045 - protected void appendRelate(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, char[] intersectionPattern) 5.2046 - throws UnsupportedRdbmsOperatorException 5.2047 - { 5.2048 - filter.openBracket(); 5.2049 - System.out.println(expr.getLeftArg().getClass().getCanonicalName()); 5.2050 - boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.2051 - if(check1) 5.2052 - { 5.2053 - this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 5.2054 - 5.2055 - } 5.2056 - else 5.2057 - { 5.2058 - filter.appendFunction("ST_Relate"); 5.2059 - 5.2060 - 5.2061 - filter.openBracket(); 5.2062 - if(expr.getLeftArg() instanceof GeneralDBStringValue) 5.2063 - { 5.2064 - appendWKT(expr.getLeftArg(),filter); 5.2065 - } 5.2066 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.2067 - { 5.2068 - appendConstructFunction(expr.getLeftArg(), filter); 5.2069 - } 5.2070 - else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.2071 - { 5.2072 - appendConstructFunction(expr.getLeftArg(), filter); 5.2073 - } 5.2074 - else if(expr.getLeftArg() instanceof GeneralDBSqlCase) 5.2075 - { 5.2076 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 5.2077 - appendMBB(onlyLabel,filter); 5.2078 - } 5.2079 - else 5.2080 - { 5.2081 - appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 5.2082 - } 5.2083 - filter.appendComma(); 5.2084 - boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 5.2085 - if(check2) 5.2086 - { 5.2087 - this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 5.2088 - } 5.2089 - else 5.2090 - { 5.2091 - if(expr.getRightArg() instanceof GeneralDBStringValue) 5.2092 - { 5.2093 - appendWKT(expr.getRightArg(),filter); 5.2094 - } 5.2095 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 5.2096 - { 5.2097 - appendConstructFunction(expr.getRightArg(), filter); 5.2098 - } 5.2099 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary) 5.2100 - { 5.2101 - appendConstructFunction(expr.getRightArg(), filter); 5.2102 - } 5.2103 - else if(expr.getRightArg() instanceof GeneralDBSqlCase) 5.2104 - { 5.2105 - GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult(); 5.2106 - appendMBB(onlyLabel,filter); 5.2107 - } 5.2108 - else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer! 5.2109 - { 5.2110 - append(((GeneralDBDoubleValue)expr.getRightArg()), filter); 5.2111 - } 5.2112 - else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer! 5.2113 - { 5.2114 - append(((GeneralDBNumericColumn)expr.getRightArg()), filter); 5.2115 - } 5.2116 - //case met in buffer when in select -> buffer(?spatial,?thematic) 5.2117 - else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial()) 5.2118 - { 5.2119 - append(((GeneralDBLabelColumn)expr.getRightArg()),filter); 5.2120 - appendCastToDouble(filter); 5.2121 - } 5.2122 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary) 5.2123 - { 5.2124 - appendMetricFunction(expr.getRightArg(), filter); 5.2125 - } 5.2126 - else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary) 5.2127 - { 5.2128 - appendMetricFunction(expr.getRightArg(), filter); 5.2129 - } 5.2130 - else 5.2131 - { 5.2132 - appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter); 5.2133 - } 5.2134 - 5.2135 - } 5.2136 - //3rd arg 5.2137 - filter.appendComma(); 5.2138 - 5.2139 - //must turn the table of characters I have to a valid sql value! 5.2140 - filter.append("'"); 5.2141 - for(int i = 0; i< intersectionPattern.length; i++) 5.2142 - { 5.2143 - filter.append(intersectionPattern[i]+""); 5.2144 - } 5.2145 - filter.append("'"); 5.2146 - 5.2147 - filter.closeBracket(); 5.2148 - } 5.2149 - 5.2150 - filter.closeBracket(); 5.2151 - } 5.2152 - 5.2153 -}
6.1 --- a/runtime/src/test/java/eu/earthobservatory/runtime/postgis/TemplateTests.java Sat Jul 13 19:28:12 2013 +0300 6.2 +++ b/runtime/src/test/java/eu/earthobservatory/runtime/postgis/TemplateTests.java Sat Jul 13 20:11:01 2013 +0300 6.3 @@ -9,14 +9,15 @@ 6.4 */ 6.5 package eu.earthobservatory.runtime.postgis; 6.6 6.7 +import static org.junit.Assert.assertNull; 6.8 + 6.9 import java.io.IOException; 6.10 import java.io.InputStream; 6.11 +import java.sql.Connection; 6.12 import java.sql.DriverManager; 6.13 import java.sql.PreparedStatement; 6.14 import java.sql.ResultSet; 6.15 import java.sql.SQLException; 6.16 -import java.sql.Statement; 6.17 -import java.sql.Connection; 6.18 import java.util.ArrayList; 6.19 import java.util.Properties; 6.20 6.21 @@ -26,13 +27,10 @@ 6.22 import org.openrdf.rio.RDFHandlerException; 6.23 import org.openrdf.rio.RDFParseException; 6.24 6.25 - 6.26 import eu.earthobservatory.runtime.generaldb.InvalidDatasetFormatFault; 6.27 import eu.earthobservatory.runtime.generaldb.SimpleTests; 6.28 import eu.earthobservatory.runtime.generaldb.Strabon; 6.29 6.30 -import static org.junit.Assert.assertNull; 6.31 - 6.32 /** 6.33 * A set of simple tests on SPARQL query functionality 6.34 *