source: postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java @ 743:6b543070da6f

Revision 743:6b543070da6f, 79.7 KB checked in by Konstantina Bereta <Konstantina.Bereta@…>, 6 years ago (diff)

Now periods as constant typed literal values are supported as well

Line 
1/*
2 * Copyright Aduna (http://www.aduna-software.com/) (c) 2008.
3 *
4 * Licensed under the Aduna BSD-style license.
5 */
6package org.openrdf.sail.postgis.evaluation;
7
8import java.util.ArrayList;
9import java.util.List;
10
11import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron;
12import org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar;
13import org.openrdf.sail.generaldb.algebra.GeneralDBDoubleValue;
14import org.openrdf.sail.generaldb.algebra.GeneralDBLabelColumn;
15import org.openrdf.sail.generaldb.algebra.GeneralDBNumericColumn;
16import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAbove;
17import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAnd;
18import org.openrdf.sail.generaldb.algebra.GeneralDBSqlAnyInteract;
19import org.openrdf.sail.generaldb.algebra.GeneralDBSqlBelow;
20import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCase;
21import org.openrdf.sail.generaldb.algebra.GeneralDBSqlContains;
22import org.openrdf.sail.generaldb.algebra.GeneralDBSqlContainsMBB;
23import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCoveredBy;
24import org.openrdf.sail.generaldb.algebra.GeneralDBSqlCovers;
25import org.openrdf.sail.generaldb.algebra.GeneralDBSqlDisjoint;
26import org.openrdf.sail.generaldb.algebra.GeneralDBSqlEqualsSpatial;
27import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoArea;
28import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoAsGML;
29import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoAsText;
30import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoBoundary;
31import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoBuffer;
32import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoConvexHull;
33import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDifference;
34import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDimension;
35import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoDistance;
36import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoEnvelope;
37import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoGeometryType;
38import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIntersection;
39import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIsEmpty;
40import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoIsSimple;
41import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid;
42import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference;
43import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform;
44import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion;
45import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside;
46import org.openrdf.sail.generaldb.algebra.GeneralDBSqlIntersects;
47import org.openrdf.sail.generaldb.algebra.GeneralDBSqlIsNull;
48import org.openrdf.sail.generaldb.algebra.GeneralDBSqlLeft;
49import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMathExpr;
50import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbEquals;
51import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbInside;
52import org.openrdf.sail.generaldb.algebra.GeneralDBSqlMbbIntersects;
53import org.openrdf.sail.generaldb.algebra.GeneralDBSqlNot;
54import org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull;
55import org.openrdf.sail.generaldb.algebra.GeneralDBSqlOverlap;
56import org.openrdf.sail.generaldb.algebra.GeneralDBSqlRelate;
57import org.openrdf.sail.generaldb.algebra.GeneralDBSqlRight;
58import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialConstructBinary;
59import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialConstructUnary;
60import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricBinary;
61import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricUnary;
62import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialProperty;
63import org.openrdf.sail.generaldb.algebra.GeneralDBSqlTouch;
64import org.openrdf.sail.generaldb.algebra.GeneralDBStringValue;
65import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn;
66import org.openrdf.sail.generaldb.algebra.GeneralDBUnionItem;
67import org.openrdf.sail.generaldb.algebra.base.BinaryGeneralDBOperator;
68import org.openrdf.sail.generaldb.algebra.base.GeneralDBFromItem;
69import org.openrdf.sail.generaldb.algebra.base.GeneralDBSqlExpr;
70import org.openrdf.sail.generaldb.algebra.base.TripleGeneralDBOperator;
71import org.openrdf.sail.generaldb.algebra.base.UnaryGeneralDBOperator;
72import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Contains;
73import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_CoveredBy;
74import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Covers;
75import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Disjoint;
76import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Equals;
77import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Inside;
78import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Meet;
79import org.openrdf.sail.generaldb.algebra.egenhofer.GeneralDBSqlEgenhofer_Overlap;
80import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Dc;
81import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ec;
82import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Eq;
83import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ntpp;
84import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Ntppi;
85import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Po;
86import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Tpp;
87import org.openrdf.sail.generaldb.algebra.rcc8.GeneralDBSqlRCC8_Tppi;
88import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Contains;
89import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Crosses;
90import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Disjoint;
91import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Equals;
92import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Intersects;
93import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Overlaps;
94import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Touches;
95import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Within;
96import org.openrdf.sail.generaldb.algebra.temporal.*;
97import org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder;
98import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlBracketBuilder;
99import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlExprBuilder;
100import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlJoinBuilder;
101import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlQueryBuilder;
102import org.openrdf.sail.rdbms.exceptions.RdbmsException;
103import org.openrdf.sail.rdbms.exceptions.UnsupportedRdbmsOperatorException;
104
105/**
106 * Constructs an SQL query from {@link GeneralDBSqlExpr}s and {@link GeneralDBFromItem}s.
107 *
108 * @author Manos Karpathiotakis <mk@di.uoa.gr>
109 * @Konstantina Bereta <Konstantina.Bereta@di.uoa.gr>
110 *
111 */
112public class PostGISQueryBuilder extends GeneralDBQueryBuilder {
113
114        public static final String STRDFGEO_FIELD = "strdfgeo";
115        public static final String SRID_FIELD = "srid";
116        public static final String ST_TRANSFORM = "ST_Transform";
117        public static final String ST_ASBINARY = "ST_AsBinary";
118       
119        public static final String PERIOD_COLUMN = "period"; //this is the name of the period column in period_values table
120        public static final String PERIOD_TO_CSTRING="period_out"; //postgres temporal functions for converting period to cstring
121        public static final String CSTRING_TO_TEXT="textin"; //postres function for converting cstring to text
122        /**
123         * If (spatial) label column met is null, I must not try to retrieve its srid.
124         * Opting to ask for 'null' instead
125         */
126        boolean nullLabel = false;
127
128        public enum SpatialOperandsPostGIS { anyInteract, equals, contains, left, right, above, inside, below; }
129        public enum SpatialFunctionsPostGIS
130        {       //stSPARQL++
131                //Spatial Relationships
132                ST_Disjoint,
133                ST_Touches,
134                ST_Covers,
135                ST_CoveredBy,
136                ST_Overlaps,
137                ST_Intersects,
138                ST_Equals,
139                ST_Relate,
140                ST_Within,
141                ST_Contains,
142               
143               
144                //Spatial Constructs - Binary
145                ST_Union,
146                ST_Intersection,
147                ST_Difference,
148                ST_Buffer,
149                ST_Transform,
150                ST_SymDifference,
151
152
153                //Spatial Constructs - Unary
154                ST_Envelope,
155                ST_ConvexHull,
156                ST_Boundary,
157
158                //Spatial Metrics - Binary
159                ST_Distance,
160
161                //Spatial Metrics - Unary
162                ST_Area,
163
164                //Spatial Properties - All Unary
165                ST_Dimension,
166                ST_GeometryType,
167                ST_AsGML,
168                ST_AsText,
169                ST_SRID,
170                ST_IsEmpty,
171                ST_IsSimple,
172
173                //GeoSPARQL
174                //Simple Features
175                SF_Equals,
176                SF_Disjoint,
177                SF_Intersects,
178                SF_Touches,
179                SF_Within,
180                SF_Contains,
181                SF_Overlaps,
182                SF_Crosses,
183
184                //RCC8
185                RCC8_Eq,
186                RCC8_Dc,
187                RCC8_Ec,
188                RCC8_Po,
189                RCC8_Tppi,
190                RCC8_Tpp,
191                RCC8_Ntppi,
192                RCC8_Ntpp,
193
194                //Egenhofer
195                EH_Equals,
196                EH_Disjoint,
197                EH_Meet,
198                EH_Overlap,
199                EH_Covers,
200                EH_CoveredBy,
201                EH_Inside,
202                EH_Contains,
203                ;
204        }
205
206        public PostGISQueryBuilder() {
207                super();
208        }
209
210        public PostGISQueryBuilder(GeneralDBSqlQueryBuilder builder) {
211                super(builder);
212                this.query = builder;
213        }
214
215        @Override
216        protected void append(GeneralDBSqlNull expr, GeneralDBSqlExprBuilder filter) {
217                filter.appendNull();
218        }
219
220        @Override
221        protected void append(GeneralDBSqlIsNull expr, GeneralDBSqlExprBuilder filter)
222                        throws UnsupportedRdbmsOperatorException
223                        {
224                dispatch(expr.getArg(), filter);
225                filter.isNull();
226                        }
227
228        @Override
229        protected void append(GeneralDBSqlNot expr, GeneralDBSqlExprBuilder filter)
230                        throws UnsupportedRdbmsOperatorException
231                        {
232                if (expr.getArg() instanceof GeneralDBSqlIsNull) {
233                        GeneralDBSqlIsNull arg = (GeneralDBSqlIsNull)expr.getArg();
234                        dispatch(arg.getArg(), filter);
235                        filter.isNotNull();
236                }
237                else {
238                        GeneralDBSqlBracketBuilder open = filter.not();
239                        dispatch(expr.getArg(), (GeneralDBSqlExprBuilder) open);
240                        open.close();
241                }
242                        }
243
244        @Override
245        protected void append(GeneralDBLabelColumn var, GeneralDBSqlExprBuilder filter) {
246                if (var.getRdbmsVar().isResource()) {
247                        filter.appendNull();
248                        nullLabel = true;
249                }
250                else {
251                        String alias = getLabelAlias(var.getRdbmsVar());
252
253                        if(var.isSpatial())
254                        {
255                                filter.appendFunction(ST_ASBINARY);
256                                filter.openBracket();
257                                //XXX SRID
258                                filter.appendFunction(ST_TRANSFORM);
259                                filter.openBracket();
260                                //
261
262                                filter.column(alias, STRDFGEO_FIELD);
263                                //XXX SRID
264                                filter.appendComma();
265                                filter.column(alias, SRID_FIELD);
266                                filter.closeBracket();
267                                //
268                                filter.closeBracket();
269
270                                //Adding srid field explicitly for my StrabonPolyhedron constructor later on!
271                                filter.appendComma();
272                                filter.column(alias, SRID_FIELD);
273                        }
274                        else if(var.isTemporal())
275                        {
276                                //textin(period_out(period))
277                                filter.appendFunction(CSTRING_TO_TEXT);
278                                filter.openBracket();
279                                filter.appendFunction(PERIOD_TO_CSTRING);
280                                filter.openBracket();
281                                filter.column(alias,PERIOD_COLUMN);
282                                filter.closeBracket();
283                                filter.closeBracket();
284                        }
285                        else{
286                                //XXX original/default case
287                                System.out.println("DEFAUUUUULT!: a value column will be printed");
288                                filter.column(alias, "value");
289                        }
290                }
291        }
292
293        @Override
294        protected void append(GeneralDBSqlAnd expr, GeneralDBSqlExprBuilder filter)
295                        throws UnsupportedRdbmsOperatorException
296                        {
297                dispatch(expr.getLeftArg(), filter);
298                filter.and();
299                dispatch(expr.getRightArg(), filter);
300                        }
301
302        protected GeneralDBSqlJoinBuilder subJoinAndFilter(GeneralDBSqlJoinBuilder query, GeneralDBFromItem from)
303                        throws RdbmsException, UnsupportedRdbmsOperatorException
304                        {
305                if (from instanceof GeneralDBUnionItem) {
306                        GeneralDBUnionItem union = (GeneralDBUnionItem)from;
307                        List<String> names = union.getSelectVarNames();
308                        List<GeneralDBColumnVar> vars = union.appendVars(new ArrayList<GeneralDBColumnVar>());
309                        GeneralDBSqlQueryBuilder subquery = query.subquery();
310                        for (GeneralDBFromItem item : union.getUnion()) {
311                                for (int i = 0, n = names.size(); i < n; i++) {
312                                        GeneralDBColumnVar var = item.getVar(names.get(i));
313                                        GeneralDBSqlExprBuilder select = subquery.select();
314                                        if (var == null) {
315                                                select.appendNull();
316                                        }
317                                        else if (var.isImplied()) {
318                                                select.appendNumeric(vf.getInternalId(var.getValue()));
319                                        }
320                                        else {
321                                                select.column(var.getAlias(), var.getColumn());
322                                        }
323                                        select.as(vars.get(i).getColumn());
324                                }
325                                from(subquery, item);
326                                subquery = subquery.union();
327                        }
328                }
329                for (GeneralDBFromItem join : from.getJoins()) {
330                        join(query, join);
331                }
332                for (GeneralDBSqlExpr expr : from.getFilters()) {
333                        dispatch(expr, query.on().and());
334                }
335                return query;
336                        }
337
338        //FIXME my addition from here on
339
340        //Issue with this function: crashes when MathExpr is present in Select but does not
341        //involve spatial variables! must escape this somehow
342        @Override
343        public GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) throws UnsupportedRdbmsOperatorException
344        {
345                if(!(expr instanceof GeneralDBSqlSpatialMetricBinary)
346                                &&!(expr instanceof GeneralDBSqlSpatialMetricUnary)
347                                &&!(expr instanceof GeneralDBSqlMathExpr)
348                                &&!(expr instanceof GeneralDBSqlSpatialProperty))
349                {
350                        query.select().appendFunction(ST_ASBINARY);
351                }
352                else
353                {
354                        query.select();
355                }
356                if(expr instanceof BinaryGeneralDBOperator)
357                {
358                        dispatchBinarySqlOperator((BinaryGeneralDBOperator) expr, query.select);
359                }
360                else if(expr instanceof UnaryGeneralDBOperator)
361                {
362                        dispatchUnarySqlOperator((UnaryGeneralDBOperator) expr, query.select);
363                }
364                //SRID support must be explicitly added!
365
366                return this;
367        }
368
369        //Spatial Relationship Functions
370        @Override
371        protected void append(GeneralDBSqlAnyInteract expr, GeneralDBSqlExprBuilder filter)
372                        throws UnsupportedRdbmsOperatorException
373                        {
374                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersects);
375                        }
376
377
378        @Override
379        protected void append(GeneralDBSqlIntersects expr,      GeneralDBSqlExprBuilder filter)
380                        throws UnsupportedRdbmsOperatorException {
381                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersects);
382        }
383
384        @Override
385        protected void append(GeneralDBSqlContains expr, GeneralDBSqlExprBuilder filter)
386                        throws UnsupportedRdbmsOperatorException {
387
388                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Contains);
389        }
390
391
392
393       
394        @Override
395        protected void append(GeneralDBSqlEqualsSpatial expr, GeneralDBSqlExprBuilder filter)
396                        throws UnsupportedRdbmsOperatorException {
397
398                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Equals);
399        }
400
401        @Override
402        protected void append(GeneralDBSqlInside expr, GeneralDBSqlExprBuilder filter)
403                        throws UnsupportedRdbmsOperatorException {
404
405                //appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.inside);
406                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Within);
407
408        }
409
410        @Override
411        protected void append(GeneralDBSqlCovers expr, GeneralDBSqlExprBuilder filter)
412                        throws UnsupportedRdbmsOperatorException {
413
414                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Covers);
415        }
416
417        @Override
418        protected void append(GeneralDBSqlCoveredBy expr, GeneralDBSqlExprBuilder filter)
419                        throws UnsupportedRdbmsOperatorException {
420
421                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_CoveredBy);
422        }
423
424        @Override
425        protected void append(GeneralDBSqlTouch expr, GeneralDBSqlExprBuilder filter)
426                        throws UnsupportedRdbmsOperatorException {
427
428                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Touches);
429        }
430
431        @Override
432        protected void append(GeneralDBSqlOverlap expr, GeneralDBSqlExprBuilder filter)
433                        throws UnsupportedRdbmsOperatorException {
434
435                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Overlaps);
436        }
437
438        @Override
439        protected void append(GeneralDBSqlDisjoint expr, GeneralDBSqlExprBuilder filter)
440                        throws UnsupportedRdbmsOperatorException {
441
442                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Disjoint);
443        }
444
445        @Override
446        protected void append(GeneralDBSqlRelate expr, GeneralDBSqlExprBuilder filter)
447                        throws UnsupportedRdbmsOperatorException
448                        {
449                appendGeneralDBSpatialFunctionTriple(expr, filter, SpatialFunctionsPostGIS.ST_Relate);
450                        }
451
452        @Override       
453        protected void append(GeneralDBSqlLeft expr, GeneralDBSqlExprBuilder filter)
454                        throws UnsupportedRdbmsOperatorException
455                        {
456                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.left);
457                        }
458
459        @Override
460        protected void append(GeneralDBSqlRight expr, GeneralDBSqlExprBuilder filter)
461                        throws UnsupportedRdbmsOperatorException
462                        {
463                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.right);
464                        }
465
466        @Override
467        protected void append(GeneralDBSqlAbove expr, GeneralDBSqlExprBuilder filter)
468                        throws UnsupportedRdbmsOperatorException
469                        {
470                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.above);
471                        }
472
473        @Override
474        protected void append(GeneralDBSqlBelow expr, GeneralDBSqlExprBuilder filter)
475                        throws UnsupportedRdbmsOperatorException
476                        {
477                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.below);
478                        }
479
480        @Override
481        protected void append(GeneralDBSqlMbbIntersects expr, GeneralDBSqlExprBuilder filter)
482                        throws UnsupportedRdbmsOperatorException {
483                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.anyInteract);
484        }
485
486        @Override
487        protected void append(GeneralDBSqlMbbInside expr, GeneralDBSqlExprBuilder filter)
488                        throws UnsupportedRdbmsOperatorException {
489                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.inside);
490        }
491
492       
493        @Override
494        protected void append(GeneralDBSqlContainsMBB expr, GeneralDBSqlExprBuilder filter)
495                        throws UnsupportedRdbmsOperatorException {
496                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.contains);
497        }
498
499       
500        @Override
501        protected void append(GeneralDBSqlMbbEquals expr, GeneralDBSqlExprBuilder filter)
502                        throws UnsupportedRdbmsOperatorException {
503                appendStSPARQLSpatialOperand(expr, filter, SpatialOperandsPostGIS.equals);
504        }
505
506        //GeoSPARQL - Spatial Relationship Functions
507        //Simple Features
508        @Override
509        protected void append(GeneralDBSqlSF_Contains expr, GeneralDBSqlExprBuilder filter)
510                        throws UnsupportedRdbmsOperatorException
511                        {
512                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Contains);
513                        }
514
515        @Override
516        protected void append(GeneralDBSqlSF_Crosses expr, GeneralDBSqlExprBuilder filter)
517                        throws UnsupportedRdbmsOperatorException
518                        {
519                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Crosses);
520                        }
521
522        @Override
523        protected void append(GeneralDBSqlSF_Disjoint expr, GeneralDBSqlExprBuilder filter)
524                        throws UnsupportedRdbmsOperatorException
525                        {
526                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Disjoint);
527                        }
528
529        @Override
530        protected void append(GeneralDBSqlSF_Equals expr, GeneralDBSqlExprBuilder filter)
531                        throws UnsupportedRdbmsOperatorException
532                        {
533                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Equals);
534                        }
535
536        @Override
537        protected void append(GeneralDBSqlSF_Intersects expr, GeneralDBSqlExprBuilder filter)
538                        throws UnsupportedRdbmsOperatorException
539                        {
540                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Intersects);
541                        }
542
543        @Override
544        protected void append(GeneralDBSqlSF_Overlaps expr, GeneralDBSqlExprBuilder filter)
545                        throws UnsupportedRdbmsOperatorException
546                        {
547                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Overlaps);
548                        }
549
550        @Override
551        protected void append(GeneralDBSqlSF_Touches expr, GeneralDBSqlExprBuilder filter)
552                        throws UnsupportedRdbmsOperatorException
553                        {
554                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Touches);
555                        }
556
557        @Override
558        protected void append(GeneralDBSqlSF_Within expr, GeneralDBSqlExprBuilder filter)
559                        throws UnsupportedRdbmsOperatorException
560                        {
561                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.SF_Within);
562                        }
563
564        //Egenhofer
565        @Override
566        protected void append(GeneralDBSqlEgenhofer_CoveredBy expr, GeneralDBSqlExprBuilder filter)
567                        throws UnsupportedRdbmsOperatorException
568                        {
569                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_CoveredBy);
570                        }
571
572        @Override
573        protected void append(GeneralDBSqlEgenhofer_Covers expr, GeneralDBSqlExprBuilder filter)
574                        throws UnsupportedRdbmsOperatorException
575                        {
576                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Covers);
577                        }
578
579        @Override
580        protected void append(GeneralDBSqlEgenhofer_Contains expr, GeneralDBSqlExprBuilder filter)
581                        throws UnsupportedRdbmsOperatorException
582                        {
583                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Contains);
584                        }
585
586        @Override
587        protected void append(GeneralDBSqlEgenhofer_Disjoint expr, GeneralDBSqlExprBuilder filter)
588                        throws UnsupportedRdbmsOperatorException
589                        {
590                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Disjoint);
591                        }
592
593        @Override
594        protected void append(GeneralDBSqlEgenhofer_Equals expr, GeneralDBSqlExprBuilder filter)
595                        throws UnsupportedRdbmsOperatorException
596                        {
597                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Equals);
598                        }
599
600        @Override
601        protected void append(GeneralDBSqlEgenhofer_Inside expr, GeneralDBSqlExprBuilder filter)
602                        throws UnsupportedRdbmsOperatorException
603                        {
604                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Inside);
605                        }
606
607        @Override
608        protected void append(GeneralDBSqlEgenhofer_Meet expr, GeneralDBSqlExprBuilder filter)
609                        throws UnsupportedRdbmsOperatorException
610                        {
611                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Meet);
612                        }
613
614        @Override
615        protected void append(GeneralDBSqlEgenhofer_Overlap expr, GeneralDBSqlExprBuilder filter)
616                        throws UnsupportedRdbmsOperatorException
617                        {
618                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.EH_Overlap);
619                        }
620
621        //RCC8
622        @Override
623        protected void append(GeneralDBSqlRCC8_Dc expr, GeneralDBSqlExprBuilder filter)
624                        throws UnsupportedRdbmsOperatorException
625                        {
626                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Dc);
627                        }
628
629        @Override
630        protected void append(GeneralDBSqlRCC8_Eq expr, GeneralDBSqlExprBuilder filter)
631                        throws UnsupportedRdbmsOperatorException
632                        {
633                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Eq);
634                        }
635
636        @Override
637        protected void append(GeneralDBSqlRCC8_Ec expr, GeneralDBSqlExprBuilder filter)
638                        throws UnsupportedRdbmsOperatorException
639                        {
640                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ec);
641                        }
642
643        @Override
644        protected void append(GeneralDBSqlRCC8_Po expr, GeneralDBSqlExprBuilder filter)
645                        throws UnsupportedRdbmsOperatorException
646                        {
647                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Po);
648                        }
649
650        @Override
651        protected void append(GeneralDBSqlRCC8_Tppi expr, GeneralDBSqlExprBuilder filter)
652                        throws UnsupportedRdbmsOperatorException
653                        {
654                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Tppi);
655                        }
656
657        @Override
658        protected void append(GeneralDBSqlRCC8_Tpp expr, GeneralDBSqlExprBuilder filter)
659                        throws UnsupportedRdbmsOperatorException
660                        {
661                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Tpp);
662                        }
663
664        @Override
665        protected void append(GeneralDBSqlRCC8_Ntpp expr, GeneralDBSqlExprBuilder filter)
666                        throws UnsupportedRdbmsOperatorException
667                        {
668                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ntpp);
669                        }
670
671        @Override
672        protected void append(GeneralDBSqlRCC8_Ntppi expr, GeneralDBSqlExprBuilder filter)
673                        throws UnsupportedRdbmsOperatorException
674                        {
675                appendgeoSPARQLSpatialRelation(expr, filter,SpatialFunctionsPostGIS.RCC8_Ntppi);
676                        }
677
678        //Spatial Construct Functions
679        @Override
680        protected void append(GeneralDBSqlGeoUnion expr, GeneralDBSqlExprBuilder filter)
681                        throws UnsupportedRdbmsOperatorException
682                        {
683                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Union);
684                        }
685
686        @Override
687        protected void append(GeneralDBSqlGeoBuffer expr, GeneralDBSqlExprBuilder filter)
688                        throws UnsupportedRdbmsOperatorException
689                        {
690                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Buffer);
691                        }
692
693        //XXX Different Behavior
694        @Override
695        protected void append(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter)
696                        throws UnsupportedRdbmsOperatorException
697                        {
698                appendTransformFunc(expr, filter);
699                        }
700
701        @Override
702        protected void append(GeneralDBSqlGeoEnvelope expr, GeneralDBSqlExprBuilder filter)
703                        throws UnsupportedRdbmsOperatorException
704                        {
705                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Envelope);
706                        }
707
708        @Override
709        protected void append(GeneralDBSqlGeoConvexHull expr, GeneralDBSqlExprBuilder filter)
710                        throws UnsupportedRdbmsOperatorException
711                        {
712                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_ConvexHull);
713                        }
714
715        @Override
716        protected void append(GeneralDBSqlGeoBoundary expr, GeneralDBSqlExprBuilder filter)
717                        throws UnsupportedRdbmsOperatorException
718                        {
719                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Boundary);
720                        }
721
722        @Override
723        protected void append(GeneralDBSqlGeoIntersection expr, GeneralDBSqlExprBuilder filter)
724                        throws UnsupportedRdbmsOperatorException
725                        {
726                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Intersection);
727                        }
728
729        @Override
730        protected void append(GeneralDBSqlGeoDifference expr, GeneralDBSqlExprBuilder filter)
731                        throws UnsupportedRdbmsOperatorException
732                        {
733                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Difference);
734                        }
735
736        @Override
737        protected void append(GeneralDBSqlGeoSymDifference expr, GeneralDBSqlExprBuilder filter)
738                        throws UnsupportedRdbmsOperatorException
739                        {
740                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_SymDifference);
741                        }
742
743        //Spatial Metric Functions
744        @Override
745        protected void append(GeneralDBSqlGeoDistance expr, GeneralDBSqlExprBuilder filter)
746                        throws UnsupportedRdbmsOperatorException
747                        {
748                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Distance);
749                        }
750
751        @Override
752        protected void append(GeneralDBSqlGeoArea expr, GeneralDBSqlExprBuilder filter)
753                        throws UnsupportedRdbmsOperatorException
754                        {
755                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Area);
756                        }
757
758        //Spatial Property Functions
759        @Override
760        protected void append(GeneralDBSqlGeoDimension expr, GeneralDBSqlExprBuilder filter)
761                        throws UnsupportedRdbmsOperatorException
762                        {
763                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_Dimension);
764                        }
765
766        @Override
767        protected void append(GeneralDBSqlGeoGeometryType expr, GeneralDBSqlExprBuilder filter)
768                        throws UnsupportedRdbmsOperatorException
769                        {
770                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_GeometryType);
771                        }
772
773        @Override
774        protected void append(GeneralDBSqlGeoAsText expr, GeneralDBSqlExprBuilder filter)
775                        throws UnsupportedRdbmsOperatorException
776                        {
777                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_AsText);
778                        }
779
780        @Override
781        protected void append(GeneralDBSqlGeoAsGML expr, GeneralDBSqlExprBuilder filter)
782                        throws UnsupportedRdbmsOperatorException
783                        {
784                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_AsGML);
785                        }
786       
787       
788
789        //      @Override
790        //      protected void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter)
791        //      throws UnsupportedRdbmsOperatorException
792        //      {
793        //              appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_SRID);
794        //      }
795
796        /**
797         * Special Case because I need to retrieve a single different column from geo_values when this function occurs
798         * in the select clause
799         */
800        @Override
801        protected void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter)
802                        throws UnsupportedRdbmsOperatorException
803                        {
804                boolean sridNeeded = true;
805                filter.openBracket();
806
807                boolean check1 = expr.getArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
808                boolean check2 = false;
809                if(expr.getArg() instanceof GeneralDBLabelColumn)
810                {
811                        if(((GeneralDBLabelColumn) expr.getArg()).getRdbmsVar().isResource())
812                        {
813                                check2 = true;
814                        }
815                }
816                if(check1)
817                {
818                        this.append((GeneralDBSqlNull)expr.getArg(), filter);
819
820                }
821                else if (check2)
822                {
823                        appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter);
824                }
825                else
826                {
827                        //XXX Incorporating SRID
828                        GeneralDBSqlExpr tmp = expr;
829                        if(tmp.getParentNode() == null)
830                        {
831                                String sridExpr;
832                                while(true)
833                                {
834                                        GeneralDBSqlExpr child = null;
835
836                                        if(tmp instanceof BinaryGeneralDBOperator)
837                                        {
838                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg();
839                                        }
840                                        else if(tmp instanceof UnaryGeneralDBOperator)
841                                        {
842                                                child = ((UnaryGeneralDBOperator) tmp).getArg();
843                                        }
844                                        else if(tmp instanceof GeneralDBStringValue)
845                                        {
846                                                //Constant!!
847                                                sridNeeded  = false;
848                                                break;
849                                        }
850
851                                        tmp = child;
852                                        if(tmp instanceof GeneralDBLabelColumn)
853                                        {
854                                                //Reached the innermost left var -> need to capture its SRID
855                                                String alias;
856                                                if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) {
857                                                        //Predicates used in triple patterns non-existent in db
858                                                        alias="NULL";
859                                                }
860                                                else
861                                                {
862                                                        //Reached the innermost left var -> need to capture its SRID
863                                                        alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar());
864                                                        alias=alias+".srid";
865                                                }
866                                                sridExpr = alias;
867                                                filter.append(sridExpr);
868                                                filter.closeBracket();
869                                                return;
870                                                //break;
871                                        }
872                                        else if(tmp instanceof GeneralDBStringValue)
873                                        {
874                                                //Constant!!
875                                                sridNeeded  = false;
876                                                break;
877                                        }
878
879                                }
880                        }
881
882                        if(sridNeeded)
883                        {
884                                filter.appendFunction("ST_SRID");
885                                filter.openBracket();
886                                if(expr.getArg() instanceof GeneralDBStringValue)
887                                {
888                                        appendWKT(expr.getArg(),filter);
889                                }
890                                else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructBinary)
891                                {
892                                        appendConstructFunction(expr.getArg(), filter);
893                                }
894                                else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructUnary)
895                                {
896                                        appendConstructFunction(expr.getArg(), filter);
897                                }
898                                else if(expr.getArg() instanceof GeneralDBSqlCase)
899                                {
900                                        GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getArg()).getEntries().get(0).getResult();
901                                        appendMBB(onlyLabel,filter);
902                                }
903                                else
904                                {
905                                        appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter);
906                                }
907
908                                filter.closeBracket();
909                        }
910                        else
911                        {
912                                //4326 by default - Software House additions
913                                filter.append("4326");
914                        }
915                }
916
917                filter.closeBracket();
918                        }
919
920        @Override
921        protected void append(GeneralDBSqlGeoIsSimple expr, GeneralDBSqlExprBuilder filter)
922                        throws UnsupportedRdbmsOperatorException
923                        {
924                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsSimple);
925                        }
926
927        @Override
928        protected void append(GeneralDBSqlGeoIsEmpty expr, GeneralDBSqlExprBuilder filter)
929                        throws UnsupportedRdbmsOperatorException
930                        {
931                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsEmpty);
932                        }
933
934
935        /**
936         * 'helper' functions
937         */
938
939        @Override
940        protected String appendWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter)
941        {
942                GeneralDBStringValue arg = (GeneralDBStringValue) expr;
943                String raw = arg.getValue();
944
945                StrabonPolyhedron poly = null;
946                try{
947                        poly = new StrabonPolyhedron(raw);
948                } catch (Exception e) {
949                        e.printStackTrace();
950                }
951
952                filter.append(" ST_GeomFromText('"+poly.toWKT() +"',4326)");
953
954                return raw;
955        }
956       
957        /*Temporal Functions
958         *
959         * */
960       
961        protected String appendPeriodConstant(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter)
962        {
963                GeneralDBStringValue arg = (GeneralDBStringValue) expr;
964                String period = arg.getValue();
965               
966                //FIXME period constant should be validated before appended
967               
968                filter.append("period_in(textout('"+period+"'))");
969                return period;
970        }
971       
972        @Override
973        protected void append(GeneralDBSqlPeriodContainedBy expr, GeneralDBSqlExprBuilder filter)
974                        throws UnsupportedRdbmsOperatorException
975                        {
976                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getOperator());
977                        }
978       
979        @Override
980        protected void append(GeneralDBSqlPeriodContains expr, GeneralDBSqlExprBuilder filter)
981                        throws UnsupportedRdbmsOperatorException
982                        {
983                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getOperator());
984                        }
985
986        @Override
987        protected void append(GeneralDBSqlPeriodOverlaps expr, GeneralDBSqlExprBuilder filter)
988                        throws UnsupportedRdbmsOperatorException
989                        {
990                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getOperator());
991                        }
992
993        @Override
994        protected void append(GeneralDBSqlAfterPeriod expr, GeneralDBSqlExprBuilder filter)
995                        throws UnsupportedRdbmsOperatorException
996                        {
997                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getOperator());
998                        }
999       
1000        @Override
1001        protected void append(GeneralDBSqlBeforePeriod expr,
1002                        GeneralDBSqlExprBuilder filter)
1003                        throws UnsupportedRdbmsOperatorException {
1004                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getOperator());
1005               
1006        }
1007       
1008        @Override
1009        protected void append(GeneralDBSqlPeriodIntersection expr, GeneralDBSqlExprBuilder filter)
1010                        throws UnsupportedRdbmsOperatorException
1011                        {
1012                //appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsEmpty);
1013                        }
1014       
1015        @Override
1016        protected void append(GeneralDBSqlPeriodMinus expr, GeneralDBSqlExprBuilder filter)
1017                        throws UnsupportedRdbmsOperatorException
1018                        {
1019                //appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsEmpty);
1020                        }
1021       
1022        @Override
1023        protected void append(GeneralDBSqlPeriodUnion expr, GeneralDBSqlExprBuilder filter)
1024                        throws UnsupportedRdbmsOperatorException
1025                        {
1026                //appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_IsEmpty);
1027                        }
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037       
1038
1039        //Used in all the generaldb boolean spatial functions of the form ?GEO1 ~ ?GEO2
1040        //      protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException
1041        //      {
1042        //              filter.openBracket();
1043        //
1044        //              boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1045        //              //boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1046        //
1047        //              if(check1a)
1048        //              {
1049        //                      this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1050        //
1051        //              }
1052        ////            else if(check2a)
1053        ////            {
1054        ////                    this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1055        ////            }
1056        //              else
1057        //              {
1058        //                      if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1059        //                      {
1060        //                              this.append((GeneralDBSqlCase)expr.getLeftArg(), filter);
1061        //                      }
1062        //                      else if(expr.getLeftArg() instanceof GeneralDBStringValue)
1063        //                      {
1064        //                              appendWKT(expr.getLeftArg(),filter);
1065        //                      }
1066        //                      else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
1067        //                      {
1068        //                              appendConstructFunction(expr.getLeftArg(), filter);
1069        //                      }
1070        //                      else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1071        //                      {
1072        //                              appendConstructFunction(expr.getLeftArg(), filter);
1073        //                      }
1074        //                      else
1075        //                      {
1076        //                              appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1077        //                      }
1078        //
1079        //                      switch(operand)
1080        //                      {
1081        //                      case anyInteract: filter.anyInteract(); break;
1082        //                      case equals: filter.equals(); break;
1083        //                      case contains: filter.contains(); break;
1084        //                      case inside: filter.inside(); break;
1085        //                      case left: filter.left(); break;
1086        //                      case right: filter.right(); break;
1087        //                      case above: filter.above(); break;
1088        //                      case below: filter.below(); break;
1089        //                      }
1090        //
1091        //                      boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1092        //
1093        //                      if(check2a)
1094        //                      {
1095        //                              this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1096        //                      }
1097        //                      else
1098        //                      {
1099        //
1100        //                              if(expr.getRightArg() instanceof GeneralDBSqlCase)
1101        //                              {
1102        //                                      this.append((GeneralDBSqlCase)expr.getRightArg(), filter);
1103        //                              }
1104        //                              else if(expr.getRightArg() instanceof GeneralDBStringValue)
1105        //                              {
1106        //                                      appendWKT(expr.getRightArg(),filter);
1107        //                              }
1108        //                              else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
1109        //                              {
1110        //                                      appendConstructFunction(expr.getRightArg(), filter);
1111        //                              }
1112        //                              else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
1113        //                              {
1114        //                                      appendConstructFunction(expr.getRightArg(), filter);
1115        //                              }
1116        //                              else
1117        //                              {
1118        //                                      appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
1119        //                              }
1120        //
1121        //                      }
1122        //              }
1123        //              filter.closeBracket();
1124        //      }
1125
1126
1127        protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException
1128        {
1129                filter.openBracket();
1130
1131                boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1132                boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1133
1134                if(check1a)
1135                {
1136                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1137
1138                }
1139                else if(check2a)
1140                {
1141                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1142                }
1143                else
1144                {
1145                        if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1146                        {
1147                                this.append((GeneralDBSqlCase)expr.getLeftArg(), filter);
1148                        }
1149                        else if(expr.getLeftArg() instanceof GeneralDBStringValue)
1150                        {
1151                                appendWKT(expr.getLeftArg(),filter);
1152                        }
1153                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
1154                        {
1155                                appendConstructFunction(expr.getLeftArg(), filter);
1156                        }
1157                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1158                        {
1159                                appendConstructFunction(expr.getLeftArg(), filter);
1160                        }
1161                        else
1162                        {
1163                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1164                        }
1165
1166                        switch(operand)
1167                        {
1168                        case anyInteract: filter.intersectsMBB(); break;
1169                        case equals: filter.equalsMBB(); break;
1170                        case contains: filter.containsMBB(); break;
1171                        case inside: filter.insideMBB(); break;
1172                        case left: filter.leftMBB(); break;
1173                        case right: filter.rightMBB(); break;
1174                        case above: filter.aboveMBB(); break;
1175                        case below: filter.belowMBB(); break;
1176                        }
1177
1178                        //                      boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1179                        //
1180                        //                      if(check2a)
1181                        //                      {
1182                        //                              this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1183                        //                      }
1184                        //                      else
1185                        //                      {
1186
1187                        if(expr.getRightArg() instanceof GeneralDBSqlCase)
1188                        {
1189                                this.append((GeneralDBSqlCase)expr.getRightArg(), filter);
1190                        }
1191                        else if(expr.getRightArg() instanceof GeneralDBStringValue)
1192                        {
1193                                appendWKT(expr.getRightArg(),filter);
1194                        }
1195                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
1196                        {
1197                                appendConstructFunction(expr.getRightArg(), filter);
1198                        }
1199                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
1200                        {
1201                                appendConstructFunction(expr.getRightArg(), filter);
1202                        }
1203                        else
1204                        {
1205                                appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
1206                        }
1207
1208                        //}
1209                }
1210                filter.closeBracket();
1211        }
1212
1213        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)
1214        protected void appendTransformFunc(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter)
1215                        throws UnsupportedRdbmsOperatorException
1216                        {
1217                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))")
1218                boolean sridNeeded = true;
1219                //XXX Incorporating SRID
1220                String sridExpr = null;
1221
1222                filter.openBracket();
1223                filter.appendFunction(ST_TRANSFORM);
1224                filter.openBracket();
1225
1226                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1227                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1228
1229                if(check1)
1230                {
1231                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1232
1233                }
1234                else if(check2)
1235                {
1236                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1237                }
1238                else
1239                {
1240                        GeneralDBSqlExpr tmp = expr;
1241                        if(tmp instanceof GeneralDBSqlSpatialConstructBinary && tmp.getParentNode() == null)
1242                        {
1243                                while(true)
1244                                {
1245                                        GeneralDBSqlExpr child;
1246
1247                                        if(tmp instanceof BinaryGeneralDBOperator)
1248                                        {
1249                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg();
1250                                        }
1251                                        else //(tmp instanceof UnaryGeneralDBOperator)
1252                                        {
1253                                                child = ((UnaryGeneralDBOperator) tmp).getArg();
1254                                        }
1255
1256                                        tmp = child;
1257                                        if(tmp instanceof GeneralDBLabelColumn)
1258                                        {
1259                                                String alias;
1260                                                if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) {
1261                                                        //Predicates used in triple patterns non-existent in db
1262                                                        alias="NULL";
1263                                                }
1264                                                else
1265                                                {
1266                                                        //Reached the innermost left var -> need to capture its SRID
1267                                                        alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar());
1268                                                        alias=alias+".srid";
1269                                                }
1270                                                sridExpr = alias;
1271                                                break;
1272                                        }
1273                                        else if (tmp instanceof GeneralDBStringValue) //Constant!!
1274                                        {
1275                                                sridNeeded  = false;
1276                                                break;
1277                                        }
1278
1279                                }
1280                                if(sridNeeded)
1281                                {
1282                                        filter.appendFunction(ST_TRANSFORM);
1283                                        filter.openBracket();
1284                                }
1285                        }
1286
1287                        if(expr.getLeftArg() instanceof GeneralDBStringValue)
1288                        {
1289                                appendWKT(expr.getLeftArg(),filter);
1290                        }
1291                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
1292                        {
1293                                appendConstructFunction(expr.getLeftArg(), filter);
1294                        }
1295                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1296                        {
1297                                appendConstructFunction(expr.getLeftArg(), filter);
1298                        }
1299                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1300                        {
1301                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
1302                                appendMBB(onlyLabel,filter);
1303                        }
1304                        else
1305                        {
1306                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1307                        }
1308
1309                        //SRID Support
1310                        if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1311                        {
1312                                filter.appendComma();
1313                                //filter.append(((GeneralDBSqlSpatialConstructBinary)expr).getSrid());
1314                                filter.append(sridExpr);
1315                                filter.closeBracket();
1316                        }
1317
1318                        filter.appendComma();
1319
1320                        if(expr.getRightArg() instanceof GeneralDBSqlCase) //case met in transform!
1321                        {
1322                                GeneralDBURIColumn plainURI = (GeneralDBURIColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult();
1323
1324                                //XXX This case would be met if we recovered the SRID URI from the db!!!
1325                                //Need to set sridExpr to the value of this new URI, otherwise the appended uri
1326                                //to the spatial object will be the wrong one!!!! (Seee following case)
1327                                filter.keepSRID_part1();
1328                                append(plainURI, filter);
1329                                filter.keepSRID_part2();
1330                                append(plainURI, filter);
1331                                filter.keepSRID_part3();
1332                        }
1333                        else if(expr.getRightArg() instanceof GeneralDBStringValue)
1334                        {
1335                                String unparsedSRID = ((GeneralDBStringValue)expr.getRightArg()).getValue();
1336                                //                              int srid = Integer.parseInt(unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1));
1337                                sridExpr = unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1);
1338                                filter.append(sridExpr);
1339                                filter.closeBracket();
1340                        }
1341
1342
1343                }
1344                filter.closeBracket();
1345                //In this case, SRID is the one that has been provided by the user!!
1346                //I am including this extra binding to be used in subsequent (Aggregate) steps
1347                if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1348                {
1349                        filter.appendComma();
1350                        filter.append(sridExpr);
1351                }
1352
1353                        }
1354
1355
1356
1357        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)
1358        //EXCEPT ST_Transform!!!
1359        protected void appendGeneralDBTemporalFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, String func)
1360                        throws UnsupportedRdbmsOperatorException
1361                        {
1362                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))")
1363                boolean sridNeeded = true;
1364                //XXX Incorporating SRID
1365                String sridExpr = null;
1366
1367                //filter.openBracket();
1368
1369                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1370                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1371
1372                if(check1)
1373                {
1374                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1375
1376                }
1377                else if(check2)
1378                {
1379                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1380                }
1381                else
1382                {
1383
1384                        GeneralDBSqlExpr tmp = expr;
1385                        if(tmp instanceof GeneralDBSqlTemporalConstructBinary && tmp.getParentNode() == null)
1386                        {
1387                                while(true)
1388                                {
1389                                        GeneralDBSqlExpr child;
1390
1391                                        if(tmp instanceof BinaryGeneralDBOperator)
1392                                        {
1393                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg();
1394                                        }
1395                                        else //(tmp instanceof UnaryGeneralDBOperator)
1396                                        {
1397                                                child = ((UnaryGeneralDBOperator) tmp).getArg();
1398                                        }
1399
1400                                        tmp = child;
1401                                        if(tmp instanceof GeneralDBLabelColumn)
1402                                        {
1403                                                //Reached the innermost left var -> need to capture its SRID
1404                                                String alias;
1405                                                if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) {
1406                                                        //Predicates used in triple patterns non-existent in db
1407                                                        alias="NULL";
1408                                                }
1409                                                else
1410                                                {
1411                                                        //Reached the innermost left var -> need to capture its SRID
1412                                                        alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar());
1413                                                        alias=alias+".srid";
1414                                                }
1415                                                sridExpr = alias;
1416                                                break;
1417                                        }
1418                                        else if (tmp instanceof GeneralDBStringValue) //Constant!!
1419                                        {
1420                                                sridNeeded  = false;
1421                                                break;
1422                                        }
1423
1424                                }
1425                                if(sridNeeded)
1426                                {
1427                                        filter.appendFunction(ST_TRANSFORM);
1428                                        filter.openBracket();
1429                                }
1430                        }
1431                        /////
1432
1433
1434               
1435                       
1436                       
1437                        filter.openBracket();
1438                        if (expr.getLeftArg() instanceof GeneralDBSqlTemporalConstructBinary)
1439                        {
1440                                appendConstructFunction(expr.getLeftArg(), filter);
1441                        }
1442                        else if(expr.getLeftArg() instanceof GeneralDBStringValue)
1443                        {
1444                                appendPeriodConstant(expr.getLeftArg(), filter);
1445                        }
1446                        else
1447                        {                       
1448                                appendPeriod((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1449
1450                        }
1451                       
1452                        if(func.equals("=")|| func.equals("!=")|| func.equals("-")|| func.equals("+")|| func.equals("~")||
1453                                        func.equals("@")|| func.equals("<<")|| func.equals(">>")|| func.equals("&>")|| func.equals("&>")|| func.equals("&&"))
1454                        {
1455                                filter.append(" ");
1456                                filter.appendFunction(func);
1457                                filter.append(" ");
1458                        }
1459                       
1460                //TODO:Think about adding more temporal function types (e.g., metrics, unary operators)
1461                       
1462                        /*else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1463                        {
1464                                appendConstructFunction(expr.getLeftArg(), filter);
1465                        }
1466                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1467                        {
1468                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
1469                                appendMBB(onlyLabel,filter);
1470                        }
1471                        else
1472                        {
1473                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1474                        }*/
1475                        //filter.appendComma();
1476
1477                       
1478//                      //filter.openBracket();
1479                        if (expr.getRightArg() instanceof GeneralDBSqlTemporalConstructBinary)
1480                        {
1481                                appendConstructFunction(expr.getRightArg(), filter);
1482                        }
1483                        else if(expr.getRightArg() instanceof GeneralDBStringValue)
1484                        {
1485                                appendPeriodConstant(expr.getRightArg(), filter);
1486                        }
1487                        else
1488                        {
1489                                appendPeriod((GeneralDBLabelColumn)(expr.getRightArg()),filter);
1490                        }
1491               
1492
1493//                      //filter.closeBracket();
1494                        //SRID Support
1495                        if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1496                        {
1497                                filter.appendComma();
1498                                //filter.append(((GeneralDBSqlSpatialConstructBinary)expr).getSrid());
1499                                filter.append(sridExpr);
1500                                filter.closeBracket();
1501                        }
1502                        ///
1503                }
1504                filter.closeBracket();
1505                //Used to explicitly include SRID
1506                if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1507                {
1508                        filter.appendComma();
1509                        filter.append(sridExpr);
1510                }
1511
1512                        }
1513       
1514        protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func)
1515                        throws UnsupportedRdbmsOperatorException
1516                        {
1517                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))")
1518                boolean sridNeeded = true;
1519                //XXX Incorporating SRID
1520                String sridExpr = null;
1521
1522                filter.openBracket();
1523
1524                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1525                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1526
1527                if(check1)
1528                {
1529                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1530
1531                }
1532                else if(check2)
1533                {
1534                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1535                }
1536                else
1537                {
1538
1539                        GeneralDBSqlExpr tmp = expr;
1540                        if(tmp instanceof GeneralDBSqlSpatialConstructBinary && tmp.getParentNode() == null)
1541                        {
1542                                while(true)
1543                                {
1544                                        GeneralDBSqlExpr child;
1545
1546                                        if(tmp instanceof BinaryGeneralDBOperator)
1547                                        {
1548                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg();
1549                                        }
1550                                        else //(tmp instanceof UnaryGeneralDBOperator)
1551                                        {
1552                                                child = ((UnaryGeneralDBOperator) tmp).getArg();
1553                                        }
1554
1555                                        tmp = child;
1556                                        if(tmp instanceof GeneralDBLabelColumn)
1557                                        {
1558                                                //Reached the innermost left var -> need to capture its SRID
1559                                                String alias;
1560                                                if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) {
1561                                                        //Predicates used in triple patterns non-existent in db
1562                                                        alias="NULL";
1563                                                }
1564                                                else
1565                                                {
1566                                                        //Reached the innermost left var -> need to capture its SRID
1567                                                        alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar());
1568                                                        alias=alias+".srid";
1569                                                }
1570                                                sridExpr = alias;
1571                                                break;
1572                                        }
1573                                        else if (tmp instanceof GeneralDBStringValue) //Constant!!
1574                                        {
1575                                                sridNeeded  = false;
1576                                                break;
1577                                        }
1578
1579                                }
1580                                if(sridNeeded)
1581                                {
1582                                        filter.appendFunction(ST_TRANSFORM);
1583                                        filter.openBracket();
1584                                }
1585                        }
1586                        /////
1587
1588
1589
1590                        switch(func)
1591                        {
1592                        //XXX Careful: ST_Transform support MISSING!!!
1593                        case ST_Difference: filter.appendFunction("ST_Difference"); break;
1594                        case ST_Intersection: filter.appendFunction("ST_Intersection"); break;
1595                        case ST_Union: filter.appendFunction("ST_Union"); break;
1596                        case ST_SymDifference: filter.appendFunction("ST_SymDifference"); break;
1597                        case ST_Buffer: filter.appendFunction("ST_Buffer"); break;
1598                        case ST_Distance: filter.appendFunction("ST_Distance"); break;
1599                        case ST_Touches: filter.appendFunction("ST_Touches"); break;
1600                        case ST_Disjoint: filter.appendFunction("ST_Disjoint"); break;
1601                        case ST_Covers: filter.appendFunction("ST_Covers"); break;
1602                        case ST_Contains: filter.appendFunction("ST_Contains"); break;
1603                        case ST_CoveredBy: filter.appendFunction("ST_CoveredBy"); break;
1604                        case ST_Overlaps: filter.appendFunction("ST_Overlaps"); break;
1605                        case ST_Intersects: filter.appendFunction("ST_Intersects"); break;
1606                        case ST_Equals: filter.appendFunction("ST_Equals"); break;
1607                        case ST_Within: filter.appendFunction("ST_Within"); break;
1608                       
1609                        }
1610                       
1611                        filter.openBracket();
1612                        if(expr.getLeftArg() instanceof GeneralDBStringValue)
1613                        {
1614                                appendWKT(expr.getLeftArg(),filter);
1615                        }
1616                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
1617                        {
1618                                appendConstructFunction(expr.getLeftArg(), filter);
1619                        }
1620                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1621                        {
1622                                appendConstructFunction(expr.getLeftArg(), filter);
1623                        }
1624                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1625                        {
1626                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
1627                                appendMBB(onlyLabel,filter);
1628                        }
1629                        else
1630                        {
1631                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1632                        }
1633                        filter.appendComma();
1634
1635
1636                        if(expr.getRightArg() instanceof GeneralDBStringValue)
1637                        {
1638                                appendWKT(expr.getRightArg(),filter);
1639                        }
1640                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
1641                        {
1642                                appendConstructFunction(expr.getRightArg(), filter);
1643                        }
1644                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
1645                        {
1646                                appendConstructFunction(expr.getRightArg(), filter);
1647                        }
1648                        else if(expr.getRightArg() instanceof GeneralDBSqlCase)
1649                        {
1650                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult();
1651                                appendMBB(onlyLabel,filter);                                     
1652                        }
1653                        else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer!
1654                        {
1655                                append(((GeneralDBDoubleValue)expr.getRightArg()), filter);
1656                        }
1657                        else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer!
1658                        {
1659                                append(((GeneralDBNumericColumn)expr.getRightArg()), filter);
1660                        }
1661                        else if(expr.getRightArg() instanceof GeneralDBURIColumn) //case met in transform!
1662                        {
1663                                filter.keepSRID_part1();
1664                                append(((GeneralDBURIColumn)expr.getRightArg()), filter);
1665                                filter.keepSRID_part2();
1666                                append(((GeneralDBURIColumn)expr.getRightArg()), filter);
1667                                filter.keepSRID_part3();
1668                        }
1669                        //case met in buffer when in select -> buffer(?spatial,?thematic)
1670                        else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial())
1671                        {
1672                                append(((GeneralDBLabelColumn)expr.getRightArg()),filter);
1673                                appendCastToDouble(filter);
1674                        }
1675                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary)
1676                        {
1677                                appendMetricFunction(expr.getRightArg(), filter);
1678                        }
1679                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary)
1680                        {
1681                                appendMetricFunction(expr.getRightArg(), filter);
1682                        }
1683                        else
1684                        {
1685                                appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
1686                        }
1687
1688
1689                        filter.closeBracket();
1690                        //SRID Support
1691                        if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1692                        {
1693                                filter.appendComma();
1694                                //filter.append(((GeneralDBSqlSpatialConstructBinary)expr).getSrid());
1695                                filter.append(sridExpr);
1696                                filter.closeBracket();
1697                        }
1698                        ///
1699                }
1700                filter.closeBracket();
1701                //Used to explicitly include SRID
1702                if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null)
1703                {
1704                        filter.appendComma();
1705                        filter.append(sridExpr);
1706                }
1707
1708                        }
1709
1710        //Used in all the generaldb boolean spatial functions of the form ST_Function(?GEO1)
1711        protected void appendGeneralDBSpatialFunctionUnary(UnaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func)
1712                        throws UnsupportedRdbmsOperatorException
1713                        {
1714                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))")
1715                boolean sridNeeded = true;
1716                String sridExpr = null;
1717
1718                filter.openBracket();
1719
1720                boolean check1 = expr.getArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1721                boolean check2 = false;
1722                if(expr.getArg() instanceof GeneralDBLabelColumn)
1723                {
1724                        if(((GeneralDBLabelColumn) expr.getArg()).getRdbmsVar().isResource())
1725                        {
1726                                check2 = true;
1727                        }
1728                }
1729                if(check1)
1730                {
1731                        this.append((GeneralDBSqlNull)expr.getArg(), filter);
1732
1733                }
1734                else if (check2)
1735                {
1736                        appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter);
1737                }
1738                else
1739                {
1740
1741                        GeneralDBSqlExpr tmp = expr;
1742
1743
1744                        if(tmp instanceof GeneralDBSqlSpatialConstructUnary && tmp.getParentNode() == null)
1745                        {
1746                                while(true)
1747                                {
1748                                        GeneralDBSqlExpr child = null;
1749
1750                                        if(tmp instanceof BinaryGeneralDBOperator)
1751                                        {
1752                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg();
1753                                        }
1754                                        else if(tmp instanceof UnaryGeneralDBOperator)
1755                                        {
1756                                                child = ((UnaryGeneralDBOperator) tmp).getArg();
1757                                        }
1758                                        else if(tmp instanceof GeneralDBStringValue)
1759                                        {
1760                                                sridNeeded  = false;
1761                                                break;
1762                                        }
1763
1764                                        tmp = child;
1765                                        if(tmp instanceof GeneralDBLabelColumn)
1766                                        {
1767                                                //Reached the innermost left var -> need to capture its SRID
1768                                                String alias;
1769                                                if (((GeneralDBLabelColumn) tmp).getRdbmsVar().isResource()) {
1770                                                        //Predicates used in triple patterns non-existent in db
1771                                                        alias="NULL";
1772                                                }
1773                                                else
1774                                                {
1775                                                        //Reached the innermost left var -> need to capture its SRID
1776                                                        alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar());
1777                                                        alias=alias+".srid";
1778                                                }
1779                                                sridExpr = alias;
1780                                                break;
1781                                        }
1782                                        else if (tmp instanceof GeneralDBStringValue) //Constant!!
1783                                        {
1784                                                sridNeeded  = false;
1785                                                break;
1786                                        }
1787
1788                                }
1789                                if(sridNeeded)
1790                                {
1791                                        filter.appendFunction(ST_TRANSFORM);
1792                                        filter.openBracket();
1793                                }
1794                        }
1795                        /////
1796
1797                        switch(func)
1798                        {
1799                        case ST_Envelope: filter.appendFunction("ST_Envelope"); break;
1800                        case ST_ConvexHull: filter.appendFunction("ST_ConvexHull"); break;
1801                        case ST_Boundary: filter.appendFunction("ST_Boundary"); break;
1802                        case ST_Area: filter.appendFunction("ST_Area"); break;
1803                        case ST_Dimension: filter.appendFunction("ST_Dimension"); break;
1804                        case ST_GeometryType: filter.appendFunction("ST_GeometryType"); break;
1805                        case ST_AsText: filter.appendFunction("ST_AsText"); break;
1806                        case ST_AsGML: filter.appendFunction("ST_AsGML"); break;
1807                        case ST_SRID: filter.appendFunction("ST_SRID"); break;
1808                        case ST_IsEmpty: filter.appendFunction("ST_IsEmpty"); break;
1809                        case ST_IsSimple: filter.appendFunction("ST_IsSimple"); break;
1810                        }
1811                        filter.openBracket();
1812                        if(expr.getArg() instanceof GeneralDBStringValue)
1813                        {
1814                                appendWKT(expr.getArg(),filter);
1815                        }
1816                        else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructBinary)
1817                        {
1818                                appendConstructFunction(expr.getArg(), filter);
1819                        }
1820                        else if(expr.getArg() instanceof GeneralDBSqlSpatialConstructUnary)
1821                        {
1822                                appendConstructFunction(expr.getArg(), filter);
1823                        }
1824                        else if(expr.getArg() instanceof GeneralDBSqlCase)
1825                        {
1826                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getArg()).getEntries().get(0).getResult();
1827                                appendMBB(onlyLabel,filter);
1828                        }
1829                        else
1830                        {
1831                                appendMBB((GeneralDBLabelColumn)(expr.getArg()),filter);
1832                        }
1833
1834                        filter.closeBracket();
1835                        //                      //SRID Support
1836                        if(sridNeeded)
1837                        {
1838                                if(expr instanceof GeneralDBSqlSpatialConstructUnary && expr.getParentNode() == null)
1839                                {
1840                                        filter.appendComma();
1841                                        //                              filter.append(((GeneralDBSqlSpatialConstructUnary)expr).getSrid());
1842                                        filter.append(sridExpr);
1843                                        filter.closeBracket();
1844                                }
1845                        }
1846                        ///
1847                }
1848
1849                filter.closeBracket();
1850                //Used to explicitly include SRID
1851                if(expr instanceof GeneralDBSqlSpatialConstructUnary && expr.getParentNode() == null)
1852                {
1853                        filter.appendComma();
1854                        filter.append(sridExpr);
1855                }
1856                        }
1857
1858        //Used in all the generaldb boolean spatial functions of the form ST_Function(?GEO1,?GEO2)
1859        protected void appendGeneralDBSpatialFunctionTriple(TripleGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func)
1860                        throws UnsupportedRdbmsOperatorException
1861                        {
1862                filter.openBracket();
1863
1864                boolean check1a = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1865                boolean check2a = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1866                boolean check3 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1867
1868                if(check1a)
1869                {
1870                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
1871
1872                }
1873                else if(check2a)
1874                {
1875                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1876                }
1877                else if(check3)
1878                {
1879                        this.append((GeneralDBSqlNull)expr.getThirdArg(), filter);
1880                }
1881                else
1882                {
1883                        switch(func)
1884                        {
1885                        case ST_Relate: filter.appendFunction("ST_Relate"); break;
1886                        }
1887                        filter.openBracket();
1888                        if(expr.getLeftArg() instanceof GeneralDBStringValue)
1889                        {
1890                                appendWKT(expr.getLeftArg(),filter);
1891                        }
1892                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
1893                        {
1894                                appendConstructFunction(expr.getLeftArg(), filter);
1895                        }
1896                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
1897                        {
1898                                appendConstructFunction(expr.getLeftArg(), filter);
1899                        }
1900                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
1901                        {
1902                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
1903                                appendMBB(onlyLabel,filter);
1904                        }
1905                        else
1906                        {
1907                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
1908                        }
1909                        filter.appendComma();
1910                        //                      boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1911                        //                      if(check2)
1912                        //                      {
1913                        //                              this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
1914                        //                      }
1915                        //                      else
1916                        //                      {
1917                        if(expr.getRightArg() instanceof GeneralDBStringValue)
1918                        {
1919                                appendWKT(expr.getRightArg(),filter);
1920                        }
1921                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
1922                        {
1923                                appendConstructFunction(expr.getRightArg(), filter);
1924                        }
1925                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
1926                        {
1927                                appendConstructFunction(expr.getRightArg(), filter);
1928                        }
1929                        else if(expr.getRightArg() instanceof GeneralDBSqlCase)
1930                        {
1931                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult();
1932                                appendMBB(onlyLabel,filter);                                     
1933                        }
1934                        else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer!
1935                        {
1936                                append(((GeneralDBDoubleValue)expr.getRightArg()), filter);
1937                        }
1938                        else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer!
1939                        {
1940                                append(((GeneralDBNumericColumn)expr.getRightArg()), filter);
1941                        }
1942                        //case met in buffer when in select -> buffer(?spatial,?thematic)
1943                        else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial())
1944                        {
1945                                append(((GeneralDBLabelColumn)expr.getRightArg()),filter);
1946                                appendCastToDouble(filter);
1947                        }
1948                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary)
1949                        {
1950                                appendMetricFunction(expr.getRightArg(), filter);
1951                        }
1952                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary)
1953                        {
1954                                appendMetricFunction(expr.getRightArg(), filter);
1955                        }
1956                        else
1957                        {
1958                                appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
1959                        }
1960
1961                        //                      }
1962                        //3rd arg
1963                        filter.appendComma();
1964                        //                      boolean check3 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
1965                        //                      if(check3)
1966                        //                      {
1967                        //                              this.append((GeneralDBSqlNull)expr.getThirdArg(), filter);
1968                        //                      }
1969                        //                      else
1970                        //                      {
1971
1972                        if(expr.getThirdArg() instanceof GeneralDBStringValue)
1973                        {
1974                                append(((GeneralDBStringValue)expr.getThirdArg()),filter);     
1975                        }
1976                        else if(expr.getThirdArg() instanceof GeneralDBSqlCase)
1977                        {
1978                                append(((GeneralDBSqlCase)expr.getThirdArg()),filter);                           
1979                        }
1980                        //case met in buffer when in select -> buffer(?spatial,?thematic)
1981                        else if(expr.getThirdArg() instanceof GeneralDBLabelColumn )//&& !((GeneralDBLabelColumn)expr.getThirdArg()).isSpatial())
1982                        {
1983
1984                                append(((GeneralDBLabelColumn)expr.getThirdArg()),filter);
1985                        }
1986
1987
1988                        //                      }
1989                        filter.closeBracket();
1990                }
1991
1992                filter.closeBracket();
1993                        }
1994
1995
1996        //GeoSPARQL
1997        //XXX
1998        protected void appendRelate(BinaryGeneralDBOperator expr, PostGISSqlExprBuilder filter, char[] intersectionPattern)
1999                        throws UnsupportedRdbmsOperatorException
2000                        {
2001                filter.openBracket();
2002
2003                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
2004                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
2005
2006                if(check1)
2007                {
2008                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
2009
2010                }
2011                else if(check2)
2012                {
2013                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
2014                }
2015                else
2016                {       
2017                        filter.appendFunction("ST_Relate");
2018
2019
2020                        filter.openBracket();
2021                        if(expr.getLeftArg() instanceof GeneralDBStringValue)
2022                        {
2023                                appendWKT(expr.getLeftArg(),filter);
2024                        }
2025                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
2026                        {
2027                                appendConstructFunction(expr.getLeftArg(), filter);
2028                        }
2029                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
2030                        {
2031                                appendConstructFunction(expr.getLeftArg(), filter);
2032                        }
2033                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
2034                        {
2035                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
2036                                appendMBB(onlyLabel,filter);
2037                        }
2038                        else
2039                        {
2040                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
2041                        }
2042                        filter.appendComma();
2043
2044                        if(expr.getRightArg() instanceof GeneralDBStringValue)
2045                        {
2046                                appendWKT(expr.getRightArg(),filter);
2047                        }
2048                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
2049                        {
2050                                appendConstructFunction(expr.getRightArg(), filter);
2051                        }
2052                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
2053                        {
2054                                appendConstructFunction(expr.getRightArg(), filter);
2055                        }
2056                        else if(expr.getRightArg() instanceof GeneralDBSqlCase)
2057                        {
2058                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult();
2059                                appendMBB(onlyLabel,filter);                                     
2060                        }
2061                        else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer!
2062                        {
2063                                append(((GeneralDBDoubleValue)expr.getRightArg()), filter);
2064                        }
2065                        else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer!
2066                        {
2067                                append(((GeneralDBNumericColumn)expr.getRightArg()), filter);
2068                        }
2069                        //case met in buffer when in select -> buffer(?spatial,?thematic)
2070                        else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial())
2071                        {
2072                                append(((GeneralDBLabelColumn)expr.getRightArg()),filter);
2073                                appendCastToDouble(filter);
2074                        }
2075                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary)
2076                        {
2077                                appendMetricFunction(expr.getRightArg(), filter);
2078                        }
2079                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary)
2080                        {
2081                                appendMetricFunction(expr.getRightArg(), filter);
2082                        }
2083                        else
2084                        {
2085                                appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
2086                        }
2087
2088                        //3rd arg
2089                        filter.appendComma();
2090
2091                        //must turn the table of characters I have to a valid sql value!
2092                        filter.append("'");
2093                        for(int i = 0; i< intersectionPattern.length; i++)
2094                        {
2095                                filter.append(intersectionPattern[i]+"");
2096                        }
2097                        filter.append("'");
2098
2099                        filter.closeBracket();
2100
2101                }
2102
2103                filter.closeBracket();
2104                        }
2105
2106
2107        protected void appendgeoSPARQLSpatialRelation(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func)
2108                        throws UnsupportedRdbmsOperatorException
2109                        {
2110                filter.openBracket();
2111                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
2112                if(check1)
2113                {
2114                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
2115
2116                }
2117                else
2118                {
2119                        char[][] intersectionPattern = null;
2120                        switch(func)
2121                        {
2122                        case ST_Covers:
2123                                intersectionPattern = new char[1][9];
2124                                intersectionPattern[0][0] = 'T';
2125                                intersectionPattern[0][1] = '*';
2126                                intersectionPattern[0][2] = 'T';
2127                                intersectionPattern[0][3] = 'F';
2128                                intersectionPattern[0][4] = 'T';
2129                                intersectionPattern[0][5] = '*';
2130                                intersectionPattern[0][6] = 'F';
2131                                intersectionPattern[0][7] = 'F';
2132                                intersectionPattern[0][8] = '*';
2133                                break;
2134                        case ST_CoveredBy:
2135                                intersectionPattern = new char[1][9];
2136                                intersectionPattern[0][0] = 'T';
2137                                intersectionPattern[0][1] = 'F';
2138                                intersectionPattern[0][2] = 'F';
2139                                intersectionPattern[0][3] = '*';
2140                                intersectionPattern[0][4] = 'T';
2141                                intersectionPattern[0][5] = 'F';
2142                                intersectionPattern[0][6] = 'T';
2143                                intersectionPattern[0][7] = '*';
2144                                intersectionPattern[0][8] = '*';
2145                                break;
2146                        case SF_Contains: 
2147                                intersectionPattern = new char[1][9];
2148                                intersectionPattern[0][0] = 'T';
2149                                intersectionPattern[0][1] = '*';
2150                                intersectionPattern[0][2] = '*';
2151                                intersectionPattern[0][3] = '*';
2152                                intersectionPattern[0][4] = '*';
2153                                intersectionPattern[0][5] = '*';
2154                                intersectionPattern[0][6] = 'F';
2155                                intersectionPattern[0][7] = 'F';
2156                                intersectionPattern[0][8] = '*';
2157                                break;
2158                        case SF_Crosses: 
2159                                intersectionPattern = new char[1][9];
2160                                intersectionPattern[0][0] = 'T';
2161                                intersectionPattern[0][1] = '*';
2162                                intersectionPattern[0][2] = 'T';
2163                                intersectionPattern[0][3] = '*';
2164                                intersectionPattern[0][4] = '*';
2165                                intersectionPattern[0][5] = '*';
2166                                intersectionPattern[0][6] = '*';
2167                                intersectionPattern[0][7] = '*';
2168                                intersectionPattern[0][8] = '*';
2169                                break;
2170                        case SF_Disjoint:
2171                        case EH_Disjoint:
2172                                intersectionPattern = new char[1][9];
2173                                intersectionPattern[0][0] = 'F';
2174                                intersectionPattern[0][1] = 'F';
2175                                intersectionPattern[0][2] = '*';
2176                                intersectionPattern[0][3] = 'F';
2177                                intersectionPattern[0][4] = 'F';
2178                                intersectionPattern[0][5] = '*';
2179                                intersectionPattern[0][6] = '*';
2180                                intersectionPattern[0][7] = '*';
2181                                intersectionPattern[0][8] = '*';
2182                                break;
2183                        case SF_Equals:
2184                        case EH_Equals:
2185                        case RCC8_Eq:   
2186                                intersectionPattern = new char[1][9];
2187                                intersectionPattern[0][0] = 'T';
2188                                intersectionPattern[0][1] = 'F';
2189                                intersectionPattern[0][2] = 'F';
2190                                intersectionPattern[0][3] = 'F';
2191                                intersectionPattern[0][4] = 'T';
2192                                intersectionPattern[0][5] = 'F';
2193                                intersectionPattern[0][6] = 'F';
2194                                intersectionPattern[0][7] = 'F';
2195                                intersectionPattern[0][8] = 'T';
2196                                break;
2197                        case SF_Overlaps:
2198                        case EH_Overlap:
2199                                intersectionPattern = new char[1][9];
2200                                intersectionPattern[0][0] = 'T';
2201                                intersectionPattern[0][1] = '*';
2202                                intersectionPattern[0][2] = 'T';
2203                                intersectionPattern[0][3] = '*';
2204                                intersectionPattern[0][4] = '*';
2205                                intersectionPattern[0][5] = '*';
2206                                intersectionPattern[0][6] = 'T';
2207                                intersectionPattern[0][7] = '*';
2208                                intersectionPattern[0][8] = '*';
2209                                break;
2210                        case SF_Within:
2211                                intersectionPattern = new char[1][9];
2212                                intersectionPattern[0][0] = 'T';
2213                                intersectionPattern[0][1] = '*';
2214                                intersectionPattern[0][2] = 'F';
2215                                intersectionPattern[0][3] = '*';
2216                                intersectionPattern[0][4] = '*';
2217                                intersectionPattern[0][5] = 'F';
2218                                intersectionPattern[0][6] = '*';
2219                                intersectionPattern[0][7] = '*';
2220                                intersectionPattern[0][8] = '*';
2221                                break;
2222                        case EH_Covers:
2223                                intersectionPattern = new char[1][9];
2224                                intersectionPattern[0][0] = 'T';
2225                                intersectionPattern[0][1] = '*';
2226                                intersectionPattern[0][2] = 'T';
2227                                intersectionPattern[0][3] = 'F';
2228                                intersectionPattern[0][4] = 'T';
2229                                intersectionPattern[0][5] = '*';
2230                                intersectionPattern[0][6] = 'F';
2231                                intersectionPattern[0][7] = 'F';
2232                                intersectionPattern[0][8] = '*';
2233                                break;
2234                        case EH_CoveredBy:
2235                                intersectionPattern = new char[1][9];
2236                                intersectionPattern[0][0] = 'T';
2237                                intersectionPattern[0][1] = 'F';
2238                                intersectionPattern[0][2] = 'F';
2239                                intersectionPattern[0][3] = '*';
2240                                intersectionPattern[0][4] = 'T';
2241                                intersectionPattern[0][5] = 'F';
2242                                intersectionPattern[0][6] = 'T';
2243                                intersectionPattern[0][7] = '*';
2244                                intersectionPattern[0][8] = '*';
2245                                break;
2246                        case EH_Inside:
2247                                intersectionPattern = new char[1][9];
2248                                intersectionPattern[0][0] = 'T';
2249                                intersectionPattern[0][1] = 'F';
2250                                intersectionPattern[0][2] = 'F';
2251                                intersectionPattern[0][3] = '*';
2252                                intersectionPattern[0][4] = 'F';
2253                                intersectionPattern[0][5] = 'F';
2254                                intersectionPattern[0][6] = 'T';
2255                                intersectionPattern[0][7] = '*';
2256                                intersectionPattern[0][8] = '*';
2257                                break;
2258                        case EH_Contains:
2259                                intersectionPattern = new char[1][9];
2260                                intersectionPattern[0][0] = 'T';
2261                                intersectionPattern[0][1] = '*';
2262                                intersectionPattern[0][2] = 'T';
2263                                intersectionPattern[0][3] = 'F';
2264                                intersectionPattern[0][4] = 'F';
2265                                intersectionPattern[0][5] = '*';
2266                                intersectionPattern[0][6] = 'F';
2267                                intersectionPattern[0][7] = 'F';
2268                                intersectionPattern[0][8] = '*';
2269                                break;
2270                        case RCC8_Dc:   
2271                                intersectionPattern = new char[1][9];
2272                                intersectionPattern[0][0] = 'F';
2273                                intersectionPattern[0][1] = 'F';
2274                                intersectionPattern[0][2] = 'T';
2275                                intersectionPattern[0][3] = 'F';
2276                                intersectionPattern[0][4] = 'F';
2277                                intersectionPattern[0][5] = 'T';
2278                                intersectionPattern[0][6] = 'T';
2279                                intersectionPattern[0][7] = 'T';
2280                                intersectionPattern[0][8] = 'T';
2281                                break;
2282                        case RCC8_Ec:   
2283                                intersectionPattern = new char[1][9];
2284                                intersectionPattern[0][0] = 'F';
2285                                intersectionPattern[0][1] = 'F';
2286                                intersectionPattern[0][2] = 'T';
2287                                intersectionPattern[0][3] = 'F';
2288                                intersectionPattern[0][4] = 'T';
2289                                intersectionPattern[0][5] = 'T';
2290                                intersectionPattern[0][6] = 'T';
2291                                intersectionPattern[0][7] = 'T';
2292                                intersectionPattern[0][8] = 'T';
2293                                break;
2294                        case RCC8_Po:   
2295                                intersectionPattern = new char[1][9];
2296                                intersectionPattern[0][0] = 'T';
2297                                intersectionPattern[0][1] = 'T';
2298                                intersectionPattern[0][2] = 'T';
2299                                intersectionPattern[0][3] = 'T';
2300                                intersectionPattern[0][4] = 'T';
2301                                intersectionPattern[0][5] = 'T';
2302                                intersectionPattern[0][6] = 'T';
2303                                intersectionPattern[0][7] = 'T';
2304                                intersectionPattern[0][8] = 'T';
2305                                break;
2306                        case RCC8_Tppi:
2307                                intersectionPattern = new char[1][9];
2308                                intersectionPattern[0][0] = 'T';
2309                                intersectionPattern[0][1] = 'T';
2310                                intersectionPattern[0][2] = 'T';
2311                                intersectionPattern[0][3] = 'F';
2312                                intersectionPattern[0][4] = 'T';
2313                                intersectionPattern[0][5] = 'T';
2314                                intersectionPattern[0][6] = 'F';
2315                                intersectionPattern[0][7] = 'F';
2316                                intersectionPattern[0][8] = 'T';
2317                                break;
2318                        case RCC8_Tpp: 
2319                                intersectionPattern = new char[1][9];
2320                                intersectionPattern[0][0] = 'T';
2321                                intersectionPattern[0][1] = 'F';
2322                                intersectionPattern[0][2] = 'F';
2323                                intersectionPattern[0][3] = 'T';
2324                                intersectionPattern[0][4] = 'T';
2325                                intersectionPattern[0][5] = 'F';
2326                                intersectionPattern[0][6] = 'T';
2327                                intersectionPattern[0][7] = 'T';
2328                                intersectionPattern[0][8] = 'T';
2329                                break;
2330                        case RCC8_Ntpp:
2331                                intersectionPattern = new char[1][9];
2332                                intersectionPattern[0][0] = 'T';
2333                                intersectionPattern[0][1] = 'F';
2334                                intersectionPattern[0][2] = 'F';
2335                                intersectionPattern[0][3] = 'T';
2336                                intersectionPattern[0][4] = 'F';
2337                                intersectionPattern[0][5] = 'F';
2338                                intersectionPattern[0][6] = 'T';
2339                                intersectionPattern[0][7] = 'T';
2340                                intersectionPattern[0][8] = 'T';
2341                                break;
2342                        case RCC8_Ntppi:       
2343                                intersectionPattern = new char[1][9];
2344                                intersectionPattern[0][0] = 'T';
2345                                intersectionPattern[0][1] = 'T';
2346                                intersectionPattern[0][2] = 'T';
2347                                intersectionPattern[0][3] = 'F';
2348                                intersectionPattern[0][4] = 'F';
2349                                intersectionPattern[0][5] = 'T';
2350                                intersectionPattern[0][6] = 'F';
2351                                intersectionPattern[0][7] = 'F';
2352                                intersectionPattern[0][8] = 'T';
2353                                break;
2354                        case SF_Intersects:   
2355                                intersectionPattern = new char[4][9];
2356                                intersectionPattern[0][0] = 'T';
2357                                intersectionPattern[0][1] = '*';
2358                                intersectionPattern[0][2] = '*';
2359                                intersectionPattern[0][3] = '*';
2360                                intersectionPattern[0][4] = '*';
2361                                intersectionPattern[0][5] = '*';
2362                                intersectionPattern[0][6] = '*';
2363                                intersectionPattern[0][7] = '*';
2364                                intersectionPattern[0][8] = '*';
2365                                //
2366                                intersectionPattern[1][0] = '*';
2367                                intersectionPattern[1][1] = 'T';
2368                                intersectionPattern[1][2] = '*';
2369                                intersectionPattern[1][3] = '*';
2370                                intersectionPattern[1][4] = '*';
2371                                intersectionPattern[1][5] = '*';
2372                                intersectionPattern[1][6] = '*';
2373                                intersectionPattern[1][7] = '*';
2374                                intersectionPattern[1][8] = '*';
2375                                //
2376                                intersectionPattern[2][0] = '*';
2377                                intersectionPattern[2][1] = '*';
2378                                intersectionPattern[2][2] = '*';
2379                                intersectionPattern[2][3] = 'T';
2380                                intersectionPattern[2][4] = '*';
2381                                intersectionPattern[2][5] = '*';
2382                                intersectionPattern[2][6] = '*';
2383                                intersectionPattern[2][7] = '*';
2384                                intersectionPattern[2][8] = '*';
2385                                //
2386                                intersectionPattern[3][0] = '*';
2387                                intersectionPattern[3][1] = '*';
2388                                intersectionPattern[3][2] = '*';
2389                                intersectionPattern[3][3] = '*';
2390                                intersectionPattern[3][4] = 'T';
2391                                intersectionPattern[3][5] = '*';
2392                                intersectionPattern[3][6] = '*';
2393                                intersectionPattern[3][7] = '*';
2394                                intersectionPattern[3][8] = '*';
2395                                break;
2396
2397                        case SF_Touches:
2398                        case EH_Meet:
2399                                intersectionPattern = new char[3][9];
2400                                intersectionPattern[0][0] = 'F';
2401                                intersectionPattern[0][1] = 'T';
2402                                intersectionPattern[0][2] = '*';
2403                                intersectionPattern[0][3] = '*';
2404                                intersectionPattern[0][4] = '*';
2405                                intersectionPattern[0][5] = '*';
2406                                intersectionPattern[0][6] = '*';
2407                                intersectionPattern[0][7] = '*';
2408                                intersectionPattern[0][8] = '*';
2409                                //
2410                                intersectionPattern[1][0] = 'F';
2411                                intersectionPattern[1][1] = '*';
2412                                intersectionPattern[1][2] = '*';
2413                                intersectionPattern[1][3] = 'T';
2414                                intersectionPattern[1][4] = '*';
2415                                intersectionPattern[1][5] = '*';
2416                                intersectionPattern[1][6] = '*';
2417                                intersectionPattern[1][7] = '*';
2418                                intersectionPattern[1][8] = '*';
2419                                //
2420                                intersectionPattern[2][0] = 'F';
2421                                intersectionPattern[2][1] = '*';
2422                                intersectionPattern[2][2] = '*';
2423                                intersectionPattern[2][3] = '*';
2424                                intersectionPattern[2][4] = 'T';
2425                                intersectionPattern[2][5] = '*';
2426                                intersectionPattern[2][6] = '*';
2427                                intersectionPattern[2][7] = '*';
2428                                intersectionPattern[2][8] = '*';
2429                                //
2430
2431                        }
2432
2433                        for(int i = 0; i < intersectionPattern.length ; i++)
2434                        {
2435                                appendRelate(expr, filter, intersectionPattern[i]);
2436                                if(i < intersectionPattern.length - 1)
2437                                {
2438                                        //append OR and continue
2439                                        filter.or();
2440                                }
2441                        }
2442
2443                        //Also need bounding box intersection query to enable the usage of the Gist R-tree index
2444                        if(func != SpatialFunctionsPostGIS.SF_Disjoint && func != SpatialFunctionsPostGIS.EH_Disjoint && func != SpatialFunctionsPostGIS.RCC8_Dc)
2445                        {
2446                                filter.and();
2447                                appendGeneralDBSpatialFunctionBinary(expr, filter,SpatialFunctionsPostGIS.ST_Intersects);
2448                        }
2449                }
2450                filter.closeBracket();
2451                        }
2452
2453        @Override
2454        //GeoSPARQL
2455        //XXX
2456
2457        protected void appendRelate(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, char[] intersectionPattern)
2458                        throws UnsupportedRdbmsOperatorException
2459                        {
2460                filter.openBracket();
2461                System.out.println(expr.getLeftArg().getClass().getCanonicalName());
2462                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
2463                if(check1)
2464                {
2465                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter);
2466
2467                }
2468                else
2469                {       
2470                        filter.appendFunction("ST_Relate");
2471
2472
2473                        filter.openBracket();
2474                        if(expr.getLeftArg() instanceof GeneralDBStringValue)
2475                        {
2476                                appendWKT(expr.getLeftArg(),filter);
2477                        }
2478                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary)
2479                        {
2480                                appendConstructFunction(expr.getLeftArg(), filter);
2481                        }
2482                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary)
2483                        {
2484                                appendConstructFunction(expr.getLeftArg(), filter);
2485                        }
2486                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase)
2487                        {
2488                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult();
2489                                appendMBB(onlyLabel,filter);
2490                        }
2491                        else
2492                        {
2493                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter);
2494                        }
2495                        filter.appendComma();
2496                        boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull");
2497                        if(check2)
2498                        {
2499                                this.append((GeneralDBSqlNull)expr.getRightArg(), filter);
2500                        }
2501                        else
2502                        {
2503                                if(expr.getRightArg() instanceof GeneralDBStringValue)
2504                                {
2505                                        appendWKT(expr.getRightArg(),filter);
2506                                }
2507                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary)
2508                                {
2509                                        appendConstructFunction(expr.getRightArg(), filter);
2510                                }
2511                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructBinary)
2512                                {
2513                                        appendConstructFunction(expr.getRightArg(), filter);
2514                                }
2515                                else if(expr.getRightArg() instanceof GeneralDBSqlCase)
2516                                {
2517                                        GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getRightArg()).getEntries().get(0).getResult();
2518                                        appendMBB(onlyLabel,filter);                                     
2519                                }
2520                                else if(expr.getRightArg() instanceof GeneralDBDoubleValue) //case met in buffer!
2521                                {
2522                                        append(((GeneralDBDoubleValue)expr.getRightArg()), filter);
2523                                }
2524                                else if(expr.getRightArg() instanceof GeneralDBNumericColumn) //case met in buffer!
2525                                {
2526                                        append(((GeneralDBNumericColumn)expr.getRightArg()), filter);
2527                                }
2528                                //case met in buffer when in select -> buffer(?spatial,?thematic)
2529                                else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial())
2530                                {
2531                                        append(((GeneralDBLabelColumn)expr.getRightArg()),filter);
2532                                        appendCastToDouble(filter);
2533                                }
2534                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricBinary)
2535                                {
2536                                        appendMetricFunction(expr.getRightArg(), filter);
2537                                }
2538                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialMetricUnary)
2539                                {
2540                                        appendMetricFunction(expr.getRightArg(), filter);
2541                                }
2542                                else
2543                                {
2544                                        appendMBB((GeneralDBLabelColumn)(expr.getRightArg()),filter);
2545                                }
2546
2547                        }
2548                        //3rd arg
2549                        filter.appendComma();
2550
2551                        //must turn the table of characters I have to a valid sql value!
2552                        filter.append("'");
2553                        for(int i = 0; i< intersectionPattern.length; i++)
2554                        {
2555                                filter.append(intersectionPattern[i]+"");
2556                        }
2557                        filter.append("'");
2558
2559                        filter.closeBracket();
2560                }
2561
2562                filter.closeBracket();
2563                        }
2564
2565       
2566
2567}
Note: See TracBrowser for help on using the repository browser.