Changeset 55:6ac1b8837a6a


Ignore:
Timestamp:
03/15/12 18:33:05 (6 years ago)
Author:
Manos Karpathiotakis <mk@…>
Branch:
default
Message:

Added strdf:transform. Currently supports user-input value as second argument. will extend in order to allow uri retrieved from db

Files:
15 edited

Legend:

Unmodified
Added
Removed
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/StrabonPolyhedron.java

    r51 r55  
    2929import org.opengis.referencing.operation.MathTransform; 
    3030import org.opengis.referencing.operation.TransformException; 
     31import org.openrdf.model.URI; 
    3132import org.openrdf.model.Value;  
    3233 
     
    6970        public static final String difference="http://strdf.di.uoa.gr/ontology#difference"; 
    7071        public static final String symDifference="http://strdf.di.uoa.gr/ontology#symDifference"; 
     72        public static final String transform="http://strdf.di.uoa.gr/ontology#transform"; 
    7173        //Spatial Metric Functions 
    7274        public static final String distance="http://strdf.di.uoa.gr/ontology#distance"; 
     
    800802                return poly; 
    801803        } 
     804         
     805        public static StrabonPolyhedron transform(StrabonPolyhedron A, URI srid) throws Exception { 
     806                 
     807                int parsedSRID = Integer.parseInt(srid.toString().substring(srid.toString().lastIndexOf('/')+1)); 
     808                Geometry converted = StrabonPolyhedron.convertSRID(A.getGeometry(),A.getGeometry().getSRID(), parsedSRID); 
     809                return new StrabonPolyhedron(converted); 
     810        } 
    802811 
    803812        /** 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/iterator/StSPARQLGroupIterator.java

    r53 r55  
    6161import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.IntersectionFunc; 
    6262import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.SymDifferenceFunc; 
     63import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.TransformFunc; 
    6364import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.UnionFunc; 
    6465import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.metric.AreaFunc; 
     
    423424                                        LiteralImpl lit = (LiteralImpl) radius; 
    424425                                        return StrabonPolyhedron.buffer(leftArg,lit.doubleValue()); 
     426                                } 
     427                                else if(function instanceof TransformFunc) 
     428                                { 
     429                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
     430                                        Value sridCoarse = strategy.evaluate(((FunctionCall) expr).getArgs().get(1),prototype); 
     431                                        URIImpl srid = (URIImpl) sridCoarse; 
     432                                        return StrabonPolyhedron.transform(leftArg,srid); 
    425433                                } 
    426434                                else if(function instanceof EnvelopeFunc) 
  • evaluation/src/main/resources/META-INF/services/org.openrdf.query.algebra.evaluation.function.Function

    r0 r55  
    2121org.openrdf.query.algebra.evaluation.function.spatial.stsparql.relation.BelowFunc 
    2222org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.BufferFunc 
     23org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.TransformFunc 
    2324org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.UnionFunc 
    2425org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.IntersectionFunc 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/algebra/base/GeneralDBExprSupport.java

    r0 r55  
    4343import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid; 
    4444import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference; 
     45import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform; 
    4546import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion; 
    4647import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside; 
     
    338339        } 
    339340         
     341        public static GeneralDBSqlExpr geoTransform(GeneralDBSqlExpr left, GeneralDBSqlExpr right) { 
     342 
     343                return new GeneralDBSqlGeoTransform(left, right); 
     344        } 
     345         
    340346        public static GeneralDBSqlExpr geoEnvelope(GeneralDBSqlExpr expr) { 
    341347 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/algebra/factories/GeneralDBBooleanExprFactory.java

    r0 r55  
    6666import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.ConvexHullFunc; 
    6767import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.EnvelopeFunc; 
     68import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.TransformFunc; 
    6869import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.UnionFunc; 
    6970import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.metric.AreaFunc; 
     
    124125import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoUnion; 
    125126import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoBuffer; 
     127import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoTransform; 
    126128import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoEnvelope; 
    127129import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoConvexHull; 
     
    642644                                                rightArg = numeric(right); 
    643645                                        } 
    644                                         //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
    645                                         //thus the special treatment 
     646                                        else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     647                                        { 
     648                                                //Another special case -> Second argument of this function is a URI 
     649                                                rightArg = uri(right); 
     650                                        } 
    646651                                        else  
    647652                                        { 
     653                                                //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
     654                                                //thus the special treatment 
    648655                                                rightArg = label(right); 
    649656                                        } 
     
    855862                                        rightArg = numeric(right); 
    856863                                } 
    857                                 //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
    858                                 //thus the special treatment 
     864                                else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     865                                { 
     866                                        //Another special case -> Second argument of this function is a URI 
     867                                        rightArg = uri(right); 
     868                                } 
    859869                                else  
    860870                                { 
     871                                        //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
     872                                        //thus the special treatment 
    861873                                        rightArg = label(right); 
    862874                                } 
     
    11021114                { 
    11031115                        return geoBuffer(leftArg,rightArg); 
     1116                } 
     1117                else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     1118                { 
     1119                        return geoTransform(leftArg,rightArg); 
    11041120                } 
    11051121                else if(function.getURI().equals(StrabonPolyhedron.envelope)) 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/algebra/factories/GeneralDBNumericExprFactory.java

    r0 r55  
    1717import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoBoundary; 
    1818import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoBuffer; 
     19import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoTransform; 
    1920import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoConvexHull; 
    2021import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.geoDifference; 
     
    8384        /** 
    8485         * Addition in order to be able to transform the metric expressions I need 
     86         * I also needed to create uri expressions 
    8587         */ 
    8688        private GeneralDBLabelExprFactory labelsPeek; 
     89        private GeneralDBURIExprFactory urisPeek; 
    8790 
    8891        public GeneralDBLabelExprFactory getLabelsPeek() { 
     
    9295        public void setLabelsPeek(GeneralDBLabelExprFactory labelsPeek) { 
    9396                this.labelsPeek = labelsPeek; 
     97        } 
     98 
     99        public GeneralDBURIExprFactory getUrisPeek() { 
     100                return urisPeek; 
     101        } 
     102 
     103        public void setUrisPeek(GeneralDBURIExprFactory labelsPeek) { 
     104                this.urisPeek = urisPeek; 
    94105        } 
    95106        /** 
     
    98109 
    99110        public GeneralDBSqlExpr createNumericExpr(ValueExpr expr) 
    100         throws UnsupportedRdbmsOperatorException 
    101         { 
     111                        throws UnsupportedRdbmsOperatorException 
     112                        { 
    102113                result = null; 
    103114                if (expr == null) 
     
    107118                        return new GeneralDBSqlNull(); 
    108119                return result; 
    109         } 
     120                        } 
    110121 
    111122        @Override 
     
    116127        @Override 
    117128        public void meet(Lang node) 
    118         throws UnsupportedRdbmsOperatorException 
    119         { 
     129                        throws UnsupportedRdbmsOperatorException 
     130                        { 
    120131                result = sqlNull(); 
    121         } 
     132                        } 
    122133 
    123134        /** 
     
    126137        @Override 
    127138        public void meet(MathExpr node) 
    128         throws UnsupportedRdbmsOperatorException 
    129         { 
     139                        throws UnsupportedRdbmsOperatorException 
     140                        { 
    130141                GeneralDBSqlExpr left;// = createNumericExpr(node.getLeftArg()); 
    131142                GeneralDBSqlExpr right;// = createNumericExpr(node.getRightArg()); 
     
    162173                MathOp op = node.getOperator(); 
    163174                result = new GeneralDBSqlMathExpr(left, op, right); 
    164         } 
     175                        } 
    165176 
    166177        @Override 
     
    186197        @Override 
    187198        protected void meetNode(QueryModelNode arg) 
    188         throws UnsupportedRdbmsOperatorException 
    189         { 
     199                        throws UnsupportedRdbmsOperatorException 
     200                        { 
    190201                throw unsupported(arg); 
    191         } 
     202                        } 
    192203 
    193204        private GeneralDBSqlExpr valueOf(Value value) { 
     
    307318                                        rightArg = this.createNumericExpr(right); 
    308319                                } 
    309                                 //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
    310                                 //thus the special treatment 
     320                                else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     321                                { 
     322                                        //Another special case -> Second argument of this function is a URI 
     323                                        rightArg = uri(right); 
     324                                } 
    311325                                else  
    312                                 { 
     326                                {        
     327                                        //DEFAULT behavior for constructs! buffer's second argument is a ValueConstant or a Var, 
     328                                        //thus the special treatment 
    313329                                        rightArg = label(right); 
    314330                                } 
     331 
     332 
     333 
     334 
    315335                        } 
    316336                } 
     
    386406                { 
    387407                        return geoBuffer(leftArg,rightArg); 
     408                } 
     409                else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     410                { 
     411                        return geoTransform(leftArg,rightArg); 
    388412                } 
    389413                else if(function.getURI().equals(StrabonPolyhedron.envelope)) 
     
    494518 
    495519        protected GeneralDBSqlExpr label(ValueExpr arg) 
    496         throws UnsupportedRdbmsOperatorException 
    497         { 
     520                        throws UnsupportedRdbmsOperatorException 
     521                        { 
    498522                return labelsPeek.createLabelExpr(arg); 
    499         } 
     523                        } 
     524 
     525        protected GeneralDBSqlExpr uri(ValueExpr arg) 
     526                        throws UnsupportedRdbmsOperatorException 
     527                        { 
     528                return urisPeek.createUriExpr(arg); 
     529                        } 
    500530 
    501531        //      protected GeneralDBSqlExpr numeric(ValueExpr arg) 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/algebra/factories/GeneralDBSqlExprFactory.java

    r0 r55  
    7979                //XXX don't like the way I get access to what I need, but it seems it is the only choice 
    8080                //Extra note: This setter must FOLLOW the one for the LabelExprFactory!!!  
     81                //* and the one of the URIExprFactory as well 
    8182                //Otherwise an exception will be thrown  
    8283                numeric.setLabelsPeek(label); 
    83                  
     84                numeric.setUrisPeek(uri); 
    8485        } 
    8586 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r50 r55  
    3737import org.openrdf.model.impl.BooleanLiteralImpl; 
    3838import org.openrdf.model.impl.LiteralImpl; 
     39import org.openrdf.model.impl.URIImpl; 
    3940import org.openrdf.query.BindingSet; 
    4041import org.openrdf.query.Dataset; 
     
    8384import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.relation.TouchFunc; 
    8485import org.openrdf.query.algebra.evaluation.impl.EvaluationStrategyImpl; 
    85 import org.openrdf.query.algebra.evaluation.iterator.ExtensionIterator; 
    8686import org.openrdf.query.algebra.evaluation.iterator.StSPARQLGroupIterator; 
    8787import org.openrdf.query.algebra.evaluation.iterator.OrderIterator; 
     
    115115import org.openrdf.sail.generaldb.algebra.GeneralDBSelectQuery.OrderElem; 
    116116import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialConstructBinary; 
     117import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn; 
    117118import org.openrdf.sail.generaldb.algebra.base.GeneralDBSqlExpr; 
    118119import org.openrdf.sail.generaldb.model.GeneralDBPolyhedron; 
     
    121122import org.openrdf.sail.rdbms.exceptions.UnsupportedRdbmsOperatorException; 
    122123import org.openrdf.sail.rdbms.model.RdbmsLiteral; 
     124import org.openrdf.sail.rdbms.model.RdbmsURI; 
    123125import org.openrdf.sail.generaldb.schema.IdSequence; 
    124126 
     
    293295                Value rightResult = null; 
    294296 
    295 //              try { 
    296                         leftResult = evaluate(left,bindings); 
    297 //              } catch (ValueExprEvaluationException e) { 
    298 //                      e.printStackTrace(); 
    299 //              } catch (QueryEvaluationException e) { 
    300 //                      e.printStackTrace(); 
    301 //              } 
     297                //              try { 
     298                leftResult = evaluate(left,bindings); 
     299                //              } catch (ValueExprEvaluationException e) { 
     300                //                      e.printStackTrace(); 
     301                //              } catch (QueryEvaluationException e) { 
     302                //                      e.printStackTrace(); 
     303                //              } 
    302304 
    303305 
     
    308310                { 
    309311                        ValueExpr right = fc.getArgs().get(1); 
    310 //                      try { 
    311                                 rightResult = evaluate(right,bindings); 
    312 //                      } catch (ValueExprEvaluationException e) { 
    313 //                              e.printStackTrace(); 
    314 //                      } catch (QueryEvaluationException e) { 
    315 //                              e.printStackTrace(); 
    316 //                      } 
     312                        //                      try { 
     313                        rightResult = evaluate(right,bindings); 
     314                        //                      } catch (ValueExprEvaluationException e) { 
     315                        //                              e.printStackTrace(); 
     316                        //                      } catch (QueryEvaluationException e) { 
     317                        //                              e.printStackTrace(); 
     318                        //                      } 
    317319                } 
    318320 
     
    504506                                RdbmsLiteral radius = (RdbmsLiteral) right; 
    505507                                return StrabonPolyhedron.buffer(leftArg,radius.doubleValue()); 
     508                        } 
     509 
     510                } 
     511                else if(function.getURI().equals(StrabonPolyhedron.transform)) 
     512                { 
     513                        if(right instanceof URIImpl) 
     514                        { 
     515                                URIImpl srid = (URIImpl) right; 
     516                                return StrabonPolyhedron.transform(leftArg,srid); 
     517                        } 
     518                        else if(right instanceof RdbmsURI) 
     519                        { 
     520                                RdbmsURI srid = (RdbmsURI) right; 
     521                                int parsedSRID = Integer.parseInt(srid.toString().substring(srid.toString().lastIndexOf('/')+1)); 
     522                                Geometry converted = StrabonPolyhedron.convertSRID(leftArg.getGeometry(),leftArg.getGeometry().getSRID(), parsedSRID); 
     523                                return new StrabonPolyhedron(converted); 
    506524                        } 
    507525 
     
    887905                        //System.out.println("stopper"); 
    888906                } 
     907                else if(expr instanceof GeneralDBURIColumn)//Used for 2nd argument of Transform 
     908                { 
     909                        boolean found = false; 
     910                        String name = ((GeneralDBURIColumn) expr).getVarName(); 
     911 
     912                        for(GeneralDBColumnVar reference: allKnown) 
     913                        { 
     914                                if(name.equals(reference.getName())) 
     915                                { 
     916                                        GeneralDBSqlExpr exprCopy = new GeneralDBURIColumn(reference); 
     917                                        expr.replaceWith(exprCopy); 
     918                                        found = true; 
     919                                } 
     920                        } 
     921 
     922                } 
    889923                else if(expr instanceof GeneralDBSqlMathExpr)//Case when I have calculations in select 
    890924                { 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBQueryBuilder.java

    r0 r55  
    5757import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid; 
    5858import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference; 
     59import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform; 
    5960import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion; 
    6061import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside; 
     
    119120public abstract class GeneralDBQueryBuilder { 
    120121 
    121          
     122 
    122123        protected GeneralDBSqlQueryBuilder query; 
    123124 
     
    127128 
    128129        public GeneralDBQueryBuilder() {} 
    129          
     130 
    130131        public GeneralDBQueryBuilder(GeneralDBSqlQueryBuilder builder) { 
    131132                super(); 
     
    146147 
    147148        public GeneralDBQueryBuilder filter(GeneralDBColumnVar var, Value val) 
    148         throws RdbmsException 
    149         { 
     149                        throws RdbmsException 
     150                        { 
    150151                String alias = var.getAlias(); 
    151152                String column = var.getColumn(); 
    152153                query.filter().and().columnEquals(alias, column, vf.getInternalId(val)); 
    153154                return this; 
    154         } 
     155                        } 
    155156 
    156157        public void from(GeneralDBFromItem from) 
    157         throws RdbmsException, UnsupportedRdbmsOperatorException 
    158         { 
     158                        throws RdbmsException, UnsupportedRdbmsOperatorException 
     159                        { 
    159160                from(query, from); 
    160         } 
     161                        } 
    161162 
    162163        public List<?> getParameters() { 
     
    173174 
    174175        public void orderBy(GeneralDBSqlExpr expr, boolean isAscending) 
    175         throws UnsupportedRdbmsOperatorException 
    176         { 
     176                        throws UnsupportedRdbmsOperatorException 
     177                        { 
    177178                GeneralDBSqlExprBuilder orderBy = query.orderBy(); 
    178179                dispatch(expr, orderBy); 
     
    180181                        orderBy.append(" DESC"); 
    181182                } 
    182         } 
     183                        } 
    183184 
    184185        public GeneralDBQueryBuilder select(GeneralDBSqlExpr expr) 
    185         throws UnsupportedRdbmsOperatorException 
    186         { 
     186                        throws UnsupportedRdbmsOperatorException 
     187                        { 
    187188                dispatch(expr, query.select()); 
    188189 
    189190                return this; 
    190         } 
     191                        } 
    191192 
    192193        @Override 
     
    234235                return sb.toString(); 
    235236        }        
    236          
     237 
    237238        protected void append(GeneralDBBNodeColumn var, GeneralDBSqlExprBuilder filter) { 
    238239                String alias = getBNodeAlias(var.getRdbmsVar()); 
     
    329330 
    330331        protected void append(GeneralDBSqlAbs expr, GeneralDBSqlExprBuilder filter) 
    331         throws UnsupportedRdbmsOperatorException 
    332         { 
     332                        throws UnsupportedRdbmsOperatorException 
     333                        { 
    333334                GeneralDBSqlBracketBuilder abs = filter.abs(); 
    334335                dispatch(expr.getArg(), (GeneralDBSqlExprBuilder) abs); 
    335336                abs.close(); 
    336         } 
     337                        } 
    337338 
    338339        protected void append(GeneralDBSqlAnd expr, GeneralDBSqlExprBuilder filter) 
    339         throws UnsupportedRdbmsOperatorException 
    340         { 
     340                        throws UnsupportedRdbmsOperatorException 
     341                        { 
    341342                dispatch(expr.getLeftArg(), filter); 
    342343                filter.and(); 
    343344                dispatch(expr.getRightArg(), filter); 
    344         }        
     345                        }        
    345346 
    346347        protected void append(GeneralDBSqlCase expr, GeneralDBSqlExprBuilder filter) 
    347         throws UnsupportedRdbmsOperatorException 
    348         { 
     348                        throws UnsupportedRdbmsOperatorException 
     349                        { 
    349350                GeneralDBSqlCaseBuilder caseExpr = filter.caseBegin(); 
    350351                for (GeneralDBSqlCase.Entry e : expr.getEntries()) { 
     
    355356                } 
    356357                caseExpr.end(); 
    357         } 
     358                        } 
    358359 
    359360        protected void append(GeneralDBSqlCast expr, GeneralDBSqlExprBuilder filter) 
    360         throws UnsupportedRdbmsOperatorException 
    361         { 
     361                        throws UnsupportedRdbmsOperatorException 
     362                        { 
    362363                GeneralDBSqlCastBuilder cast = filter.cast(expr.getType()); 
    363364                dispatch(expr.getArg(), (GeneralDBSqlExprBuilder) cast); 
    364365                cast.close(); 
    365         } 
     366                        } 
    366367 
    367368        protected void append(GeneralDBSqlCompare expr, GeneralDBSqlExprBuilder filter) 
    368         throws UnsupportedRdbmsOperatorException 
    369         { 
     369                        throws UnsupportedRdbmsOperatorException 
     370                        { 
    370371                dispatch(expr.getLeftArg(), filter); 
    371372                filter.appendOperator(expr.getOperator()); 
    372373                dispatch(expr.getRightArg(), filter); 
    373         } 
     374                        } 
    374375 
    375376        protected void append(GeneralDBSqlConcat expr, GeneralDBSqlExprBuilder filter) 
    376         throws UnsupportedRdbmsOperatorException 
    377         { 
     377                        throws UnsupportedRdbmsOperatorException 
     378                        { 
    378379                GeneralDBSqlBracketBuilder open = filter.open(); 
    379380                dispatch(expr.getLeftArg(), (GeneralDBSqlExprBuilder) open); 
     
    381382                dispatch(expr.getRightArg(), (GeneralDBSqlExprBuilder) open); 
    382383                open.close(); 
    383         } 
     384                        } 
    384385 
    385386        protected void append(GeneralDBSqlEq expr, GeneralDBSqlExprBuilder filter) 
    386         throws UnsupportedRdbmsOperatorException 
    387         { 
     387                        throws UnsupportedRdbmsOperatorException 
     388                        { 
    388389                dispatch(expr.getLeftArg(), filter); 
    389390                filter.eq(); 
    390391                dispatch(expr.getRightArg(), filter); 
    391         } 
     392                        } 
    392393 
    393394        protected abstract void append(GeneralDBSqlIsNull expr, GeneralDBSqlExprBuilder filter) 
    394                 throws UnsupportedRdbmsOperatorException; 
     395                        throws UnsupportedRdbmsOperatorException; 
    395396 
    396397        protected void append(GeneralDBSqlLike expr, GeneralDBSqlExprBuilder filter) 
    397         throws UnsupportedRdbmsOperatorException 
    398         { 
     398                        throws UnsupportedRdbmsOperatorException 
     399                        { 
    399400                dispatch(expr.getLeftArg(), filter); 
    400401                filter.like(); 
    401402                dispatch(expr.getRightArg(), filter); 
    402         } 
     403                        } 
    403404 
    404405        protected void append(GeneralDBSqlLowerCase expr, GeneralDBSqlExprBuilder filter) 
    405         throws UnsupportedRdbmsOperatorException 
    406         { 
     406                        throws UnsupportedRdbmsOperatorException 
     407                        { 
    407408                GeneralDBSqlBracketBuilder lower = filter.lowerCase(); 
    408409                dispatch(expr.getArg(), (GeneralDBSqlExprBuilder) lower); 
    409410                lower.close(); 
    410         } 
     411                        } 
    411412 
    412413        protected void append(GeneralDBSqlMathExpr expr, GeneralDBSqlExprBuilder filter) 
    413         throws UnsupportedRdbmsOperatorException 
    414         { 
     414                        throws UnsupportedRdbmsOperatorException 
     415                        { 
    415416                dispatch(expr.getLeftArg(), filter); 
    416417                filter.math(expr.getOperator()); 
    417418                dispatch(expr.getRightArg(), filter); 
    418         } 
     419                        } 
    419420 
    420421        protected abstract void append(GeneralDBSqlNot expr, GeneralDBSqlExprBuilder filter) 
    421                 throws UnsupportedRdbmsOperatorException; 
     422                        throws UnsupportedRdbmsOperatorException; 
    422423 
    423424        protected abstract void append(GeneralDBSqlNull expr, GeneralDBSqlExprBuilder filter); 
    424          
     425 
    425426        protected void append(GeneralDBSqlOr expr, GeneralDBSqlExprBuilder filter) 
    426         throws UnsupportedRdbmsOperatorException 
    427         { 
     427                        throws UnsupportedRdbmsOperatorException 
     428                        { 
    428429                GeneralDBSqlBracketBuilder open = filter.open(); 
    429430                dispatch(expr.getLeftArg(), (GeneralDBSqlExprBuilder) open); 
     
    431432                dispatch(expr.getRightArg(), (GeneralDBSqlExprBuilder) open); 
    432433                open.close(); 
    433         } 
    434          
     434                        } 
     435 
    435436        protected void append(GeneralDBSqlRegex expr, GeneralDBSqlExprBuilder filter) 
    436         throws UnsupportedRdbmsOperatorException 
    437         { 
     437                        throws UnsupportedRdbmsOperatorException 
     438                        { 
    438439                GeneralDBSqlRegexBuilder regex = filter.regex(); 
    439440                dispatch(expr.getArg(), regex.value()); 
     
    444445                } 
    445446                regex.close(); 
    446         } 
     447                        } 
    447448 
    448449        protected void append(GeneralDBSqlShift expr, GeneralDBSqlExprBuilder filter) 
    449         throws UnsupportedRdbmsOperatorException 
    450         { 
     450                        throws UnsupportedRdbmsOperatorException 
     451                        { 
    451452                GeneralDBSqlBracketBuilder mod = filter.mod(expr.getRange()); 
    452453                GeneralDBSqlBracketBuilder open = mod.open(); 
     
    456457                mod.plus(expr.getRange()); 
    457458                mod.close(); 
    458         } 
     459                        } 
    459460 
    460461        protected void append(GeneralDBStringValue expr, GeneralDBSqlExprBuilder filter) { 
     
    473474 
    474475        protected void dispatch(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 
    475         throws UnsupportedRdbmsOperatorException 
    476         { 
     476                        throws UnsupportedRdbmsOperatorException 
     477                        { 
    477478                if (expr instanceof GeneralDBValueColumnBase) { 
    478479                        dispatchValueColumnBase((GeneralDBValueColumnBase)expr, filter); 
     
    497498                        dispatchOther(expr, filter); 
    498499                } 
    499         } 
     500                        } 
    500501 
    501502        protected void dispatchBinarySqlOperator(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter) 
    502         throws UnsupportedRdbmsOperatorException 
    503         { 
     503                        throws UnsupportedRdbmsOperatorException 
     504                        { 
    504505                if (expr instanceof GeneralDBSqlAnd) { 
    505506                        append((GeneralDBSqlAnd)expr, filter); 
     
    653654                        append((GeneralDBSqlGeoBuffer)expr, filter); 
    654655                } 
     656                else if (expr instanceof GeneralDBSqlGeoTransform) { 
     657                        append((GeneralDBSqlGeoTransform)expr, filter); 
     658                } 
    655659                else if (expr instanceof GeneralDBSqlGeoIntersection) { 
    656660                        append((GeneralDBSqlGeoIntersection)expr, filter); 
     
    673677                        throw unsupported(expr); 
    674678                } 
    675         } 
     679                        } 
    676680 
    677681        protected void dispatchTripleSqlOperator(TripleGeneralDBOperator expr, GeneralDBSqlExprBuilder filter) 
    678         throws UnsupportedRdbmsOperatorException 
    679         { 
     682                        throws UnsupportedRdbmsOperatorException 
     683                        { 
    680684                if (expr instanceof GeneralDBSqlRelate) { 
    681685                        append((GeneralDBSqlRelate)expr, filter); 
     
    685689                        throw unsupported(expr); 
    686690                } 
    687         } 
     691                        } 
    688692 
    689693 
    690694 
    691695        protected void dispatchOther(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 
    692         throws UnsupportedRdbmsOperatorException 
    693         { 
     696                        throws UnsupportedRdbmsOperatorException 
     697                        { 
    694698                if (expr instanceof GeneralDBSqlCase) { 
    695699                        append((GeneralDBSqlCase)expr, filter); 
     
    698702                        throw unsupported(expr); 
    699703                } 
    700         } 
     704                        } 
    701705 
    702706        protected void dispatchSqlConstant(GeneralDBSqlConstant<?> expr, GeneralDBSqlExprBuilder filter) 
    703         throws UnsupportedRdbmsOperatorException 
    704         { 
     707                        throws UnsupportedRdbmsOperatorException 
     708                        { 
    705709                if (expr instanceof GeneralDBDoubleValue) { 
    706710                        append((GeneralDBDoubleValue)expr, filter); 
     
    724728                        throw unsupported(expr); 
    725729                } 
    726         } 
     730                        } 
    727731 
    728732        protected void dispatchUnarySqlOperator(UnaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter) 
    729         throws UnsupportedRdbmsOperatorException 
    730         { 
     733                        throws UnsupportedRdbmsOperatorException 
     734                        { 
    731735                if (expr instanceof GeneralDBSqlAbs) { 
    732736                        append((GeneralDBSqlAbs)expr, filter); 
     
    784788                        throw unsupported(expr); 
    785789                } 
    786         } 
     790                        } 
    787791 
    788792        protected void dispatchValueColumnBase(GeneralDBValueColumnBase expr, GeneralDBSqlExprBuilder filter) 
    789         throws UnsupportedRdbmsOperatorException 
    790         { 
     793                        throws UnsupportedRdbmsOperatorException 
     794                        { 
    791795                if (expr instanceof GeneralDBBNodeColumn) { 
    792796                        append((GeneralDBBNodeColumn)expr, filter); 
     
    825829                        throw unsupported(expr); 
    826830                } 
    827         } 
     831                        } 
    828832 
    829833        protected void from(GeneralDBSqlQueryBuilder subquery, GeneralDBFromItem item) 
    830         throws RdbmsException, UnsupportedRdbmsOperatorException 
    831         { 
     834                        throws RdbmsException, UnsupportedRdbmsOperatorException 
     835                        { 
    832836                assert !item.isLeft() : item; 
    833837                String alias = item.getAlias(); 
     
    839843                        subJoinAndFilter(subquery.from(alias), item); 
    840844                } 
    841         } 
     845                        } 
    842846 
    843847        protected String getBNodeAlias(GeneralDBColumnVar var) { 
     
    889893 
    890894        protected void join(GeneralDBSqlJoinBuilder query, GeneralDBFromItem join) 
    891         throws RdbmsException, UnsupportedRdbmsOperatorException 
    892         { 
     895                        throws RdbmsException, UnsupportedRdbmsOperatorException 
     896                        { 
    893897                String alias = join.getAlias(); 
    894898                if (join instanceof GeneralDBJoinItem) { 
     
    909913                        } 
    910914                } 
    911         } 
     915                        } 
    912916 
    913917        protected abstract GeneralDBSqlJoinBuilder subJoinAndFilter(GeneralDBSqlJoinBuilder query, GeneralDBFromItem from) 
    914         throws RdbmsException, UnsupportedRdbmsOperatorException; 
    915          
     918                        throws RdbmsException, UnsupportedRdbmsOperatorException; 
     919 
    916920        protected UnsupportedRdbmsOperatorException unsupported(Object object) 
    917         throws UnsupportedRdbmsOperatorException 
    918         { 
     921                        throws UnsupportedRdbmsOperatorException 
     922                        { 
    919923                return new UnsupportedRdbmsOperatorException(object.toString()); 
    920         } 
     924                        } 
    921925 
    922926        //FIXME my addition from here on 
    923927        public abstract GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) 
    924         throws UnsupportedRdbmsOperatorException; 
     928                        throws UnsupportedRdbmsOperatorException; 
    925929 
    926930        //Spatial Relationship Functions 
    927931        protected abstract void append(GeneralDBSqlAnyInteract expr, GeneralDBSqlExprBuilder filter) 
    928         throws UnsupportedRdbmsOperatorException; 
     932                        throws UnsupportedRdbmsOperatorException; 
    929933 
    930934        protected abstract void append(GeneralDBSqlContains expr, GeneralDBSqlExprBuilder filter) 
    931         throws UnsupportedRdbmsOperatorException; 
     935                        throws UnsupportedRdbmsOperatorException; 
    932936 
    933937        protected abstract void append(GeneralDBSqlEqualsSpatial expr, GeneralDBSqlExprBuilder filter) 
    934         throws UnsupportedRdbmsOperatorException; 
     938                        throws UnsupportedRdbmsOperatorException; 
    935939 
    936940        protected abstract void append(GeneralDBSqlInside expr, GeneralDBSqlExprBuilder filter) 
    937         throws UnsupportedRdbmsOperatorException; 
     941                        throws UnsupportedRdbmsOperatorException; 
    938942 
    939943        protected abstract void append(GeneralDBSqlCovers expr, GeneralDBSqlExprBuilder filter) 
    940         throws UnsupportedRdbmsOperatorException; 
     944                        throws UnsupportedRdbmsOperatorException; 
    941945 
    942946        protected abstract void append(GeneralDBSqlCoveredBy expr, GeneralDBSqlExprBuilder filter) 
    943         throws UnsupportedRdbmsOperatorException; 
     947                        throws UnsupportedRdbmsOperatorException; 
    944948 
    945949        protected abstract void append(GeneralDBSqlTouch expr, GeneralDBSqlExprBuilder filter) 
    946         throws UnsupportedRdbmsOperatorException; 
     950                        throws UnsupportedRdbmsOperatorException; 
    947951 
    948952        protected abstract void append(GeneralDBSqlOverlap expr, GeneralDBSqlExprBuilder filter) 
    949         throws UnsupportedRdbmsOperatorException; 
     953                        throws UnsupportedRdbmsOperatorException; 
    950954 
    951955        protected abstract void append(GeneralDBSqlDisjoint expr, GeneralDBSqlExprBuilder filter) 
    952         throws UnsupportedRdbmsOperatorException; 
     956                        throws UnsupportedRdbmsOperatorException; 
    953957 
    954958        protected abstract void append(GeneralDBSqlRelate expr, GeneralDBSqlExprBuilder filter) 
    955         throws UnsupportedRdbmsOperatorException; 
    956          
     959                        throws UnsupportedRdbmsOperatorException; 
     960 
    957961        protected abstract void append(GeneralDBSqlLeft expr, GeneralDBSqlExprBuilder filter) 
    958         throws UnsupportedRdbmsOperatorException; 
    959          
     962                        throws UnsupportedRdbmsOperatorException; 
     963 
    960964        protected abstract void append(GeneralDBSqlRight expr, GeneralDBSqlExprBuilder filter) 
    961         throws UnsupportedRdbmsOperatorException; 
    962          
     965                        throws UnsupportedRdbmsOperatorException; 
     966 
    963967        protected abstract void append(GeneralDBSqlAbove expr, GeneralDBSqlExprBuilder filter) 
    964         throws UnsupportedRdbmsOperatorException; 
    965          
     968                        throws UnsupportedRdbmsOperatorException; 
     969 
    966970        protected abstract void append(GeneralDBSqlBelow expr, GeneralDBSqlExprBuilder filter) 
    967         throws UnsupportedRdbmsOperatorException; 
     971                        throws UnsupportedRdbmsOperatorException; 
    968972 
    969973        //GeoSPARQL - Spatial Relationship Functions  
    970974        //Simple Features 
    971975        protected abstract void append(GeneralDBSqlSF_Contains expr, GeneralDBSqlExprBuilder filter) 
    972         throws UnsupportedRdbmsOperatorException; 
     976                        throws UnsupportedRdbmsOperatorException; 
    973977 
    974978        protected abstract void append(GeneralDBSqlSF_Crosses expr, GeneralDBSqlExprBuilder filter) 
    975         throws UnsupportedRdbmsOperatorException; 
     979                        throws UnsupportedRdbmsOperatorException; 
    976980 
    977981        protected abstract void append(GeneralDBSqlSF_Disjoint expr, GeneralDBSqlExprBuilder filter) 
    978         throws UnsupportedRdbmsOperatorException; 
     982                        throws UnsupportedRdbmsOperatorException; 
    979983 
    980984        protected abstract void append(GeneralDBSqlSF_Equals expr, GeneralDBSqlExprBuilder filter) 
    981         throws UnsupportedRdbmsOperatorException; 
     985                        throws UnsupportedRdbmsOperatorException; 
    982986 
    983987        protected abstract void append(GeneralDBSqlSF_Intersects expr, GeneralDBSqlExprBuilder filter) 
    984         throws UnsupportedRdbmsOperatorException; 
     988                        throws UnsupportedRdbmsOperatorException; 
    985989 
    986990        protected abstract void append(GeneralDBSqlSF_Overlaps expr, GeneralDBSqlExprBuilder filter) 
    987         throws UnsupportedRdbmsOperatorException; 
     991                        throws UnsupportedRdbmsOperatorException; 
    988992 
    989993        protected abstract void append(GeneralDBSqlSF_Touches expr, GeneralDBSqlExprBuilder filter) 
    990         throws UnsupportedRdbmsOperatorException; 
     994                        throws UnsupportedRdbmsOperatorException; 
    991995 
    992996        protected abstract void append(GeneralDBSqlSF_Within expr, GeneralDBSqlExprBuilder filter) 
    993         throws UnsupportedRdbmsOperatorException; 
     997                        throws UnsupportedRdbmsOperatorException; 
    994998 
    995999        //Egenhofer 
    9961000        protected abstract void append(GeneralDBSqlEgenhofer_CoveredBy expr, GeneralDBSqlExprBuilder filter) 
    997         throws UnsupportedRdbmsOperatorException; 
    998          
     1001                        throws UnsupportedRdbmsOperatorException; 
     1002 
    9991003        protected abstract void append(GeneralDBSqlEgenhofer_Covers expr, GeneralDBSqlExprBuilder filter) 
    1000         throws UnsupportedRdbmsOperatorException; 
    1001          
     1004                        throws UnsupportedRdbmsOperatorException; 
     1005 
    10021006        protected abstract void append(GeneralDBSqlEgenhofer_Contains expr, GeneralDBSqlExprBuilder filter) 
    1003         throws UnsupportedRdbmsOperatorException; 
    1004          
     1007                        throws UnsupportedRdbmsOperatorException; 
     1008 
    10051009        protected abstract void append(GeneralDBSqlEgenhofer_Disjoint expr, GeneralDBSqlExprBuilder filter) 
    1006         throws UnsupportedRdbmsOperatorException; 
    1007          
     1010                        throws UnsupportedRdbmsOperatorException; 
     1011 
    10081012        protected abstract void append(GeneralDBSqlEgenhofer_Equals expr, GeneralDBSqlExprBuilder filter) 
    1009         throws UnsupportedRdbmsOperatorException; 
    1010          
     1013                        throws UnsupportedRdbmsOperatorException; 
     1014 
    10111015        protected abstract void append(GeneralDBSqlEgenhofer_Inside expr, GeneralDBSqlExprBuilder filter) 
    1012         throws UnsupportedRdbmsOperatorException; 
    1013          
     1016                        throws UnsupportedRdbmsOperatorException; 
     1017 
    10141018        protected abstract void append(GeneralDBSqlEgenhofer_Meet expr, GeneralDBSqlExprBuilder filter) 
    1015         throws UnsupportedRdbmsOperatorException; 
    1016          
     1019                        throws UnsupportedRdbmsOperatorException; 
     1020 
    10171021        protected abstract void append(GeneralDBSqlEgenhofer_Overlap expr, GeneralDBSqlExprBuilder filter) 
    1018         throws UnsupportedRdbmsOperatorException; 
    1019          
     1022                        throws UnsupportedRdbmsOperatorException; 
     1023 
    10201024        //RCC8 
    10211025        protected abstract void append(GeneralDBSqlRCC8_Dc expr, GeneralDBSqlExprBuilder filter) 
    1022         throws UnsupportedRdbmsOperatorException; 
    1023          
     1026                        throws UnsupportedRdbmsOperatorException; 
     1027 
    10241028        protected abstract void append(GeneralDBSqlRCC8_Eq expr, GeneralDBSqlExprBuilder filter) 
    1025         throws UnsupportedRdbmsOperatorException; 
    1026          
     1029                        throws UnsupportedRdbmsOperatorException; 
     1030 
    10271031        protected abstract void append(GeneralDBSqlRCC8_Ec expr, GeneralDBSqlExprBuilder filter) 
    1028         throws UnsupportedRdbmsOperatorException; 
    1029          
     1032                        throws UnsupportedRdbmsOperatorException; 
     1033 
    10301034        protected abstract void append(GeneralDBSqlRCC8_Po expr, GeneralDBSqlExprBuilder filter) 
    1031         throws UnsupportedRdbmsOperatorException; 
    1032          
     1035                        throws UnsupportedRdbmsOperatorException; 
     1036 
    10331037        protected abstract void append(GeneralDBSqlRCC8_Tppi expr, GeneralDBSqlExprBuilder filter) 
    1034         throws UnsupportedRdbmsOperatorException; 
    1035          
     1038                        throws UnsupportedRdbmsOperatorException; 
     1039 
    10361040        protected abstract void append(GeneralDBSqlRCC8_Tpp expr, GeneralDBSqlExprBuilder filter) 
    1037         throws UnsupportedRdbmsOperatorException; 
    1038          
     1041                        throws UnsupportedRdbmsOperatorException; 
     1042 
    10391043        protected abstract void append(GeneralDBSqlRCC8_Ntpp expr, GeneralDBSqlExprBuilder filter) 
    1040         throws UnsupportedRdbmsOperatorException; 
    1041          
     1044                        throws UnsupportedRdbmsOperatorException; 
     1045 
    10421046        protected abstract void append(GeneralDBSqlRCC8_Ntppi expr, GeneralDBSqlExprBuilder filter) 
    1043         throws UnsupportedRdbmsOperatorException; 
     1047                        throws UnsupportedRdbmsOperatorException; 
    10441048 
    10451049        //Spatial Construct Functions 
    10461050        protected abstract void append(GeneralDBSqlGeoUnion expr, GeneralDBSqlExprBuilder filter) 
    1047         throws UnsupportedRdbmsOperatorException; 
     1051                        throws UnsupportedRdbmsOperatorException; 
    10481052 
    10491053        protected abstract void append(GeneralDBSqlGeoBuffer expr, GeneralDBSqlExprBuilder filter) 
    1050         throws UnsupportedRdbmsOperatorException; 
     1054                        throws UnsupportedRdbmsOperatorException; 
     1055 
     1056        protected abstract void append(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     1057                        throws UnsupportedRdbmsOperatorException; 
    10511058 
    10521059        protected abstract void append(GeneralDBSqlGeoEnvelope expr, GeneralDBSqlExprBuilder filter) 
    1053         throws UnsupportedRdbmsOperatorException; 
     1060                        throws UnsupportedRdbmsOperatorException; 
    10541061 
    10551062        protected abstract void append(GeneralDBSqlGeoConvexHull expr, GeneralDBSqlExprBuilder filter) 
    1056         throws UnsupportedRdbmsOperatorException; 
     1063                        throws UnsupportedRdbmsOperatorException; 
    10571064 
    10581065        protected abstract void append(GeneralDBSqlGeoBoundary expr, GeneralDBSqlExprBuilder filter) 
    1059         throws UnsupportedRdbmsOperatorException; 
     1066                        throws UnsupportedRdbmsOperatorException; 
    10601067 
    10611068        protected abstract void append(GeneralDBSqlGeoIntersection expr, GeneralDBSqlExprBuilder filter) 
    1062         throws UnsupportedRdbmsOperatorException; 
     1069                        throws UnsupportedRdbmsOperatorException; 
    10631070 
    10641071        protected abstract void append(GeneralDBSqlGeoDifference expr, GeneralDBSqlExprBuilder filter) 
    1065         throws UnsupportedRdbmsOperatorException; 
     1072                        throws UnsupportedRdbmsOperatorException; 
    10661073 
    10671074        protected abstract void append(GeneralDBSqlGeoSymDifference expr, GeneralDBSqlExprBuilder filter) 
    1068         throws UnsupportedRdbmsOperatorException; 
     1075                        throws UnsupportedRdbmsOperatorException; 
    10691076 
    10701077        //Spatial Metric Functions 
    10711078        protected abstract void append(GeneralDBSqlGeoDistance expr, GeneralDBSqlExprBuilder filter) 
    1072         throws UnsupportedRdbmsOperatorException; 
     1079                        throws UnsupportedRdbmsOperatorException; 
    10731080 
    10741081        protected abstract void append(GeneralDBSqlGeoArea expr, GeneralDBSqlExprBuilder filter) 
    1075         throws UnsupportedRdbmsOperatorException; 
     1082                        throws UnsupportedRdbmsOperatorException; 
    10761083 
    10771084        //Spatial Property Functions 
    10781085        protected abstract void append(GeneralDBSqlGeoDimension expr, GeneralDBSqlExprBuilder filter) 
    1079         throws UnsupportedRdbmsOperatorException; 
     1086                        throws UnsupportedRdbmsOperatorException; 
    10801087 
    10811088        protected abstract void append(GeneralDBSqlGeoGeometryType expr, GeneralDBSqlExprBuilder filter) 
    1082         throws UnsupportedRdbmsOperatorException; 
     1089                        throws UnsupportedRdbmsOperatorException; 
    10831090 
    10841091        protected abstract void append(GeneralDBSqlGeoAsText expr, GeneralDBSqlExprBuilder filter) 
    1085         throws UnsupportedRdbmsOperatorException; 
     1092                        throws UnsupportedRdbmsOperatorException; 
    10861093 
    10871094        protected abstract void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter) 
    1088         throws UnsupportedRdbmsOperatorException; 
     1095                        throws UnsupportedRdbmsOperatorException; 
    10891096 
    10901097        protected abstract void append(GeneralDBSqlGeoIsSimple expr, GeneralDBSqlExprBuilder filter) 
    1091         throws UnsupportedRdbmsOperatorException; 
     1098                        throws UnsupportedRdbmsOperatorException; 
    10921099 
    10931100        protected abstract void append(GeneralDBSqlGeoIsEmpty expr, GeneralDBSqlExprBuilder filter) 
    1094         throws UnsupportedRdbmsOperatorException; 
     1101                        throws UnsupportedRdbmsOperatorException; 
    10951102 
    10961103 
     
    11181125 
    11191126        protected void appendConstructFunction(GeneralDBSqlExpr constr, GeneralDBSqlExprBuilder filter)  
    1120         throws UnsupportedRdbmsOperatorException 
    1121         { 
     1127                        throws UnsupportedRdbmsOperatorException 
     1128                        { 
    11221129                if(constr instanceof GeneralDBSqlGeoUnion) 
    11231130                { 
     
    11281135                        append((GeneralDBSqlGeoBuffer)constr, filter); 
    11291136                } 
     1137                else if(constr instanceof GeneralDBSqlGeoTransform) 
     1138                { 
     1139                        append((GeneralDBSqlGeoTransform)constr, filter); 
     1140                } 
    11301141                else if(constr instanceof GeneralDBSqlGeoEnvelope) 
    11311142                { 
     
    11531164                } 
    11541165 
    1155         } 
     1166                        } 
    11561167 
    11571168        protected void appendMetricFunction(GeneralDBSqlExpr constr, GeneralDBSqlExprBuilder filter)  
    1158         throws UnsupportedRdbmsOperatorException 
    1159         { 
     1169                        throws UnsupportedRdbmsOperatorException 
     1170                        { 
    11601171                if(constr instanceof GeneralDBSqlGeoDistance) 
    11611172                { 
     
    11681179 
    11691180 
    1170         } 
     1181                        } 
    11711182 
    11721183        protected void appendCastToDouble(GeneralDBSqlExprBuilder filter) 
     
    11741185                filter.doubleCast(); 
    11751186        } 
    1176  
    1177  
     1187         
     1188         
    11781189 
    11791190        //GeoSPARQL 
    11801191        //XXX 
    1181          
     1192 
    11821193        protected abstract void appendRelate(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, char[] intersectionPattern) 
    1183         throws UnsupportedRdbmsOperatorException; 
    1184          
     1194                        throws UnsupportedRdbmsOperatorException; 
     1195 
    11851196} 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBSqlExprBuilder.java

    r25 r55  
    311311                where.append(" :: DOUBLE PRECISION "); 
    312312        } 
     313         
     314        public void keepSRID_part1() { 
     315                where.append(" SUBSTRING("); 
     316        } 
     317         
     318        public void keepSRID_part2() { 
     319                where.append(" , position('0' in "); 
     320        } 
     321         
     322        public void keepSRID_part3() { 
     323                where.append(" ) + 2) "); 
     324        } 
    313325 
    314326        //      public void overlap() { 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/model/GeneralDBPolyhedron.java

    r47 r55  
    3434        } 
    3535 
    36 //      public GeneralDBPolyhedron(Number id, Integer version, URI datatype, String polyhedron) throws IOException, ClassNotFoundException { 
    37 //              super(id, version); 
    38 // 
    39 //              try { 
    40 //                      this.polyhedron = new StrabonPolyhedron(polyhedron); 
    41 //              } catch (ParseException e) { 
    42 // 
    43 //                      e.printStackTrace(); 
    44 //              } catch (Exception e) { 
    45 // 
    46 //                      e.printStackTrace(); 
    47 //              } 
    48 //              setPolyhedronStringRep(this.polyhedron); 
    49 //              this.datatype = datatype; 
    50 //      } 
     36        //      public GeneralDBPolyhedron(Number id, Integer version, URI datatype, String polyhedron) throws IOException, ClassNotFoundException { 
     37        //              super(id, version); 
     38        // 
     39        //              try { 
     40        //                      this.polyhedron = new StrabonPolyhedron(polyhedron); 
     41        //              } catch (ParseException e) { 
     42        // 
     43        //                      e.printStackTrace(); 
     44        //              } catch (Exception e) { 
     45        // 
     46        //                      e.printStackTrace(); 
     47        //              } 
     48        //              setPolyhedronStringRep(this.polyhedron); 
     49        //              this.datatype = datatype; 
     50        //      } 
    5151        /** 
    5252         * METHODS 
     
    9191        @Override 
    9292        public String toString() { 
    93                 return new String("\""+this.polyhedronStringRep+"\"" + "^^<" +  
     93                return new String("\""+this.polyhedronStringRep+";http://www.opengis.net/def/crs/EPSG/0/" 
     94                                +this.getPolyhedron().getGeometry().getSRID()+"\"" + "^^<" +  
    9495                                ((StrabonPolyhedron.EnableConstraintRepresentation)  ?  
    9596                                                StrabonPolyhedron.stRDFSemiLinearPointset : StrabonPolyhedron.ogcGeometry) 
    9697                                                +">"); 
    9798        } 
    98          
     99 
    99100        @Override 
    100101        public int hashCode() { 
    101102                return polyhedronStringRep.hashCode(); 
    102103        } 
    103          
     104 
    104105        @Override 
    105106        public boolean equals(Object other) { 
     
    111112                                return true; 
    112113                        } 
    113                          
     114 
    114115                } 
    115116                return false; 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizer.java

    r43 r55  
    7272import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.BufferFunc; 
    7373import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.EnvelopeFunc; 
     74import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.TransformFunc; 
    7475import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.UnionFunc; 
    7576import org.openrdf.query.algebra.evaluation.iterator.SPARQLMinusIteration; 
     
    892893                                if(arg instanceof Var) 
    893894                                { 
    894                                         if(!(function instanceof BufferFunc) || argNo!=2 ) 
     895                                        if((!(function instanceof BufferFunc)&&!(function instanceof TransformFunc)) || argNo!=2 ) 
    895896                                        { 
    896897                                                //The variable's name is not in the list yet 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizerFactory.java

    r0 r55  
    6060                sql.setLabelExprFactory(label); 
    6161                sql.setLanguageExprFactory(language); 
     62                sql.setURIExprFactory(uri); 
     63                 
    6264                sql.setNumericExprFactory(new GeneralDBNumericExprFactory()); 
    6365                sql.setTimeExprFactory(new GeneralDBTimeExprFactory()); 
    6466                sql.setZonedExprFactory(new GeneralDBZonedExprFactory(ids)); 
    6567                sql.setHashExprFactory(new GeneralDBHashExprFactory(vf)); 
    66                 sql.setURIExprFactory(uri); 
     68                 
    6769                label.setSqlExprFactory(sql); 
    6870                uri.setSqlExprFactory(sql); 
  • monetdb/src/main/java/org/openrdf/sail/monetdb/evaluation/MonetDBQueryBuilder.java

    r0 r55  
    4040import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid; 
    4141import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference; 
     42import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform; 
    4243import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion; 
    4344import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside; 
     
    123124                ST_Difference, 
    124125                ST_Buffer, 
     126                ST_Transform, 
    125127                ST_SymDifference, 
    126128                //Spatial Constructs - Unary 
     
    640642                appendMonetDBSpatialFunctionBinary(expr, filter, SpatialFunctionsMonetDB.ST_Buffer); 
    641643        } 
     644         
     645        @Override 
     646        protected void append(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     647        throws UnsupportedRdbmsOperatorException 
     648        { 
     649                appendMonetDBSpatialFunctionBinary(expr, filter, SpatialFunctionsMonetDB.ST_Transform); 
     650        } 
    642651 
    643652        @Override 
     
    765774 
    766775        //Used in all the generaldb boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
     776         
    767777        protected void appendMonetDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsMonetDB func) 
    768778        throws UnsupportedRdbmsOperatorException 
     
    780790                        switch(func) 
    781791                        { 
     792                        //XXX Careful: ST_Transform support MISSING!!! 
    782793                        case ST_Difference: filter.appendFunction("Difference"); break; 
    783794                        case ST_Intersection: filter.appendFunction("Intersection"); break; 
  • postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java

    r46 r55  
    3939import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSrid; 
    4040import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoSymDifference; 
     41import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoTransform; 
    4142import org.openrdf.sail.generaldb.algebra.GeneralDBSqlGeoUnion; 
    4243import org.openrdf.sail.generaldb.algebra.GeneralDBSqlInside; 
     
    5657import org.openrdf.sail.generaldb.algebra.GeneralDBSqlTouch; 
    5758import org.openrdf.sail.generaldb.algebra.GeneralDBStringValue; 
     59import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn; 
    5860import org.openrdf.sail.generaldb.algebra.GeneralDBUnionItem; 
    5961import org.openrdf.sail.generaldb.algebra.base.BinaryGeneralDBOperator; 
     
    120122                ST_Difference, 
    121123                ST_Buffer, 
     124                ST_Transform, 
    122125                ST_SymDifference, 
    123126                //Spatial Constructs - Unary 
     
    602605                        { 
    603606                appendGeneralDBSpatialFunctionBinary(expr, filter, SpatialFunctionsPostGIS.ST_Buffer); 
     607                        } 
     608 
     609        //XXX Different Behavior 
     610        @Override 
     611        protected void append(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     612                        throws UnsupportedRdbmsOperatorException 
     613                        { 
     614                appendTransformFunc(expr, filter); 
    604615                        } 
    605616 
     
    10161027        } 
    10171028        //       
     1029 
    10181030        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
    1019         protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 
    1020                         throws UnsupportedRdbmsOperatorException 
    1021         { 
     1031        protected void appendTransformFunc(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     1032                        throws UnsupportedRdbmsOperatorException 
     1033                        { 
    10221034                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))") 
    10231035                boolean sridNeeded = true; 
    10241036                //XXX Incorporating SRID 
    10251037                String sridExpr = null; 
    1026                  
     1038 
     1039                filter.openBracket(); 
     1040                filter.appendFunction("ST_Transform"); 
    10271041                filter.openBracket(); 
    10281042 
     
    10411055                else 
    10421056                { 
    1043                          
    10441057                        GeneralDBSqlExpr tmp = expr; 
    10451058                        if(tmp instanceof GeneralDBSqlSpatialConstructBinary && tmp.getParentNode() == null) 
     
    10811094                                } 
    10821095                        } 
     1096 
     1097                        if(expr.getLeftArg() instanceof GeneralDBStringValue) 
     1098                        { 
     1099                                appendWKT(expr.getLeftArg(),filter); 
     1100                        } 
     1101                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 
     1102                        { 
     1103                                appendConstructFunction(expr.getLeftArg(), filter); 
     1104                        } 
     1105                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 
     1106                        { 
     1107                                appendConstructFunction(expr.getLeftArg(), filter); 
     1108                        } 
     1109                        else if(expr.getLeftArg() instanceof GeneralDBSqlCase) 
     1110                        { 
     1111                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 
     1112                                appendMBB(onlyLabel,filter);  
     1113                        } 
     1114                        else 
     1115                        { 
     1116                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 
     1117                        } 
     1118                         
     1119                        //SRID Support 
     1120                        if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null) 
     1121                        { 
     1122                                filter.appendComma(); 
     1123                                //filter.append(((GeneralDBSqlSpatialConstructBinary)expr).getSrid()); 
     1124                                filter.append(sridExpr); 
     1125                                filter.closeBracket(); 
     1126                        } 
     1127                         
     1128                        filter.appendComma(); 
     1129 
     1130                        if(expr.getRightArg() instanceof GeneralDBURIColumn) //case met in transform! 
     1131                        { 
     1132                                //XXX This case would be met if we recovered the SRID URI from the db!!! 
     1133                                //Need to set sridExpr to the value of this new URI, otherwise the appended uri 
     1134                                //to the spatial object will be the wrong one!!!! (Seee following case) 
     1135                                filter.keepSRID_part1(); 
     1136                                append(((GeneralDBURIColumn)expr.getRightArg()), filter); 
     1137                                filter.keepSRID_part2(); 
     1138                                append(((GeneralDBURIColumn)expr.getRightArg()), filter); 
     1139                                filter.keepSRID_part3(); 
     1140                        } 
     1141                        else if(expr.getRightArg() instanceof GeneralDBStringValue) 
     1142                        { 
     1143                                String unparsedSRID = ((GeneralDBStringValue)expr.getRightArg()).getValue(); 
     1144//                              int srid = Integer.parseInt(unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1)); 
     1145                                sridExpr = unparsedSRID.substring(unparsedSRID.lastIndexOf('/')+1); 
     1146                                filter.append(sridExpr); 
     1147                                filter.closeBracket(); 
     1148                        } 
     1149 
     1150                         
     1151                } 
     1152                filter.closeBracket(); 
     1153                //In this case, SRID is the one that has been provided by the user!! 
     1154                if(expr instanceof GeneralDBSqlSpatialConstructBinary && expr.getParentNode() == null) 
     1155                { 
     1156                        filter.appendComma(); 
     1157                        filter.append(sridExpr); 
     1158                } 
     1159 
     1160                        } 
     1161 
     1162 
     1163 
     1164        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
     1165        //EXCEPT ST_Transform!!! 
     1166        protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 
     1167                        throws UnsupportedRdbmsOperatorException 
     1168                        { 
     1169                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))") 
     1170                boolean sridNeeded = true; 
     1171                //XXX Incorporating SRID 
     1172                String sridExpr = null; 
     1173 
     1174                filter.openBracket(); 
     1175 
     1176                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 
     1177                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 
     1178 
     1179                if(check1) 
     1180                { 
     1181                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 
     1182 
     1183                } 
     1184                else if(check2) 
     1185                { 
     1186                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 
     1187                } 
     1188                else 
     1189                { 
     1190 
     1191                        GeneralDBSqlExpr tmp = expr; 
     1192                        if(tmp instanceof GeneralDBSqlSpatialConstructBinary && tmp.getParentNode() == null) 
     1193                        { 
     1194                                while(true) 
     1195                                { 
     1196                                        GeneralDBSqlExpr child; 
     1197 
     1198                                        if(tmp instanceof BinaryGeneralDBOperator) 
     1199                                        { 
     1200                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 
     1201                                        } 
     1202                                        else //(tmp instanceof UnaryGeneralDBOperator) 
     1203                                        { 
     1204                                                child = ((UnaryGeneralDBOperator) tmp).getArg(); 
     1205                                        } 
     1206 
     1207                                        tmp = child; 
     1208                                        if(tmp instanceof GeneralDBLabelColumn) 
     1209                                        { 
     1210                                                //Reached the innermost left var -> need to capture its SRID 
     1211                                                String alias = getLabelAlias(((GeneralDBLabelColumn) tmp).getRdbmsVar()); 
     1212                                                alias=alias+".srid"; 
     1213                                                sridExpr = alias; 
     1214                                                //                                              ((GeneralDBSqlSpatialConstructBinary)expr).setSrid(alias); 
     1215                                                break; 
     1216                                        } 
     1217                                        else if (tmp instanceof GeneralDBStringValue) //Constant!! 
     1218                                        { 
     1219                                                sridNeeded  = false; 
     1220                                                break; 
     1221                                        } 
     1222 
     1223                                } 
     1224                                if(sridNeeded) 
     1225                                { 
     1226                                        filter.appendFunction("ST_Transform"); 
     1227                                        filter.openBracket(); 
     1228                                } 
     1229                        } 
    10831230                        ///// 
    10841231 
     
    11511298                                append(((GeneralDBNumericColumn)expr.getRightArg()), filter); 
    11521299                        } 
     1300                        else if(expr.getRightArg() instanceof GeneralDBURIColumn) //case met in transform! 
     1301                        { 
     1302                                filter.keepSRID_part1(); 
     1303                                append(((GeneralDBURIColumn)expr.getRightArg()), filter); 
     1304                                filter.keepSRID_part2(); 
     1305                                append(((GeneralDBURIColumn)expr.getRightArg()), filter); 
     1306                                filter.keepSRID_part3(); 
     1307                        } 
    11531308                        //case met in buffer when in select -> buffer(?spatial,?thematic) 
    11541309                        else if(expr.getRightArg() instanceof GeneralDBLabelColumn && !((GeneralDBLabelColumn)expr.getRightArg()).isSpatial()) 
     
    11891344                        filter.append(sridExpr); 
    11901345                } 
    1191                  
     1346 
    11921347                        } 
    11931348 
     
    13081463 
    13091464                        filter.closeBracket(); 
    1310 //                      //SRID Support 
     1465                        //                      //SRID Support 
    13111466                        if(sridNeeded) 
    13121467                        { 
     
    13291484                        filter.append(sridExpr); 
    13301485                } 
    1331                  
     1486 
    13321487                        } 
    13331488 
Note: See TracChangeset for help on using the changeset viewer.