Changeset 1527:ba8fb069b2ca


Ignore:
Timestamp:
11/11/15 15:28:26 (23 months ago)
Author:
Panayiotis Smeros <psmeros@…>
Branch:
temporals
Parents:
1526:1b37b53e9065 (diff), 1525:c18b84e14117 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merged with default branch.

Files:
53 deleted
42 edited

Legend:

Unmodified
Added
Removed
  • .hgtags

    r1504 r1527  
    1919389213ce7843a9c490be447400c1a5c46d44cc96 v3.2.8 
    202092b90ac06d39f8fcf76de046f22bb64526d5ff28 v3.2.9 
     210ed49ee3eb94c6bfc122254342e86bfd097c1200 v3.2.9-temporals 
    2122e453684f594f568079ec28733e0a4a6df8be0e37 v3.2.10 
    2223fb3821b625fda9a2041e8ce662680328087398c6 v3.3.1 
  • .hgtags

    r1427 r1527  
    21210ed49ee3eb94c6bfc122254342e86bfd097c1200 v3.2.9-temporals 
    2222e453684f594f568079ec28733e0a4a6df8be0e37 v3.2.10 
    23 0ed49ee3eb94c6bfc122254342e86bfd097c1200 v3.2.9-temporals 
    24 0000000000000000000000000000000000000000 v3.2.9-temporals 
    25 0000000000000000000000000000000000000000 v3.2.9-temporals 
    26 391c74ff7dc007b836a57812c280402534213a02 v3.2.9-temporals 
     23fb3821b625fda9a2041e8ce662680328087398c6 v3.3.1 
  • ChangeLog

    r1520 r1527  
    8282          expressed. 
    8383          (bug #32:  http://bug.strabon.di.uoa.gr/ticket/32) 
    84  
    8584        * Fixed a bug that would raise an exception for queries involving two 
    8685          UNION graph patterns and a projection to a predicate or a URI in 
     
    201200        geo:wktLiteral. 
    202201        (bug #33: http://bug.strabon.di.uoa.gr/ticket/33) 
    203  
     202         
    204203        * Endpoint Client now supports querying of Virtuoso and Parliament endpoints. 
    205204 
    206205        * Endpoint Client now supports store and update operations, but only 
    207206        for Strabon Endpoints. 
     207 
     208        *Modified the NQUADSTranslator so that the rewritten triples are  
     209        immediately flushed to the database once they are created.  
     210         
     211        *In the N-Quads format, the fourth element is *optional*. Made proper 
     212        modification to the storage manager to coply to the specification  
     213        described here: http://sw.deri.org/2008/07/n-quads/. Now files in 
     214        NQUADS format can contain quads *or* triples in order to be stored 
     215        successfully in Strabon. 
     216         
     217        *Fixed bug that occurs when storing periods having "UC" as ending  
     218        point.  
     219         
     220        *Added an initial set of tests on temporal operations in the  
     221        testsuite module. 
     222         
     223        *Completed support for temporal updates 
     224         
     225        *Moved vocabulary related to the temporal features of Strabon to the 
     226        respective "vocabulary" project 
     227 
     228        *The evaluation of temporal joins in the database does not produce 
     229        cartesian products in the database 
    208230 
    209231        * GeoSPARQL functions sfCrosses, sfOverlaps, ehOverlaps do not use the  
     
    264286        the GeoSPARQL specification. 
    265287        (bug #25: http://bug.strabon.di.uoa.gr/ticket/25) 
     288         
     289        *Added preliminary tests on temporal functions in the respective 
     290        "test" package of the runtime module. 
     291         
     292        *Added option to strabon and endpoint scripts to support storing 
     293        files in NQUADS format. 
     294         
     295        *When a large file in NQUADS format is going to be stored, it is  
     296        partitioned and stored in parts. This happens because the translation 
     297        of quads to triples is a memory intensive job, so, translating and  
     298        storing the file in batches increases performance. 
     299 
    266300 
    267301Wed Jan 09 18:06:41 2013   Pyravlos Team 
     
    288322        * Modified the names of the stSPARQL extension functions that 
    289323        utilize the minimum bounding boxes of the involved geometries. 
     324         
     325        *Fixed bug in the evaluation of temporal constructs.  
     326         
     327        *Fixed a major bug that occured when a temporal variable that also took part 
     328        in a temporal join was projected. 
     329         
     330        *Renamed temporal extension functions to comply with the respective 
     331        functions of Allen's temporal relations.  
     332         
     333        *Modified the implementation of the temporal relation functions 
     334        "meets", "starts", "finishes", to comply with the semantics of the 
     335        respective functions of Allen. These functions are not supported by 
     336        PostgreSQL Temporal, so, in order to be evaluated in the database  
     337        level,  we implemented them as PostgreSQL extension functions.  
     338        ATTENTION: In order to use these functions, the respective sql script 
     339        that includes them should be loaded to the the temporally (and spa- 
     340        tially) enabled database.  
     341         
    290342 
    291343Tue Dec 11 19:33:45 2012   Pyravlos Team 
     
    300352        * Version 3.2.5 released. 
    301353 
    302         * Added support for querying temporal information. This functionality 
    303         may be found in the `temporals' branch.  
    304          
    305                 The datatypes <http://strdf.di.uoa.gr/ontology#period> and 
     354        * Added support for storing and querying temporal information.  
     355        This functionality may be found in the `temporals' branch.  
     356         
     357                 *The datatypes <http://strdf.di.uoa.gr/ontology#period> and 
    306358                <http://www.w3.org/2001/XMLSchema#dateTime> are used to 
    307                 represent periods and instants respectively. 
    308          
    309                 The valid time time of triples is represented using quadtruples, 
     359                represent periods and instants respectively.  
     360         
     361                *The valid time time of triples is represented using quadtruples, 
    310362                with the valid time annotation(instant or period) being the 
    311                 fourth element of the quad. In the same way, temporal triple 
    312                 patterns are used in queries to retrieve the valid time of 
    313                 triples. 
    314                  
    315                 Some functions have been renamed (their URIs have changed) to 
    316                 follow the names of the respective relations of Allen's 
    317                 interval algebra and other functions have been added.  
    318                  
    319                 The following temporal functions are supported: 
    320                 during, periodOverlaps, equalsPeriod, nequalsPeriod, adjacent, 
    321                 before, after, overleft, overright, meets, starts, finishes,  
    322                 period_intersect, period_union, preceding_period, and 
    323                 succeeding_period. 
    324          
     363                fourth element of the quad. Into this direction: 
     364                        *Strabon has been extended to support the NQUADS format. The 
     365                        respective Sesame packages (of version 2.6.9) that support 
     366                        this format are used.  
     367                         
     368                        *NQuadTranslator class has been created. This class uses the 
     369                        NQUADS parser which is available here: https://github.com/joshsh/sesametools/tree/develop/nquads. 
     370                        The initial version of this parser did not include support  
     371                        for literals as the fourth element of the quad. We exteded 
     372                        it to support the valid time representations described above. 
     373                         
     374                        *The NQUADSTranslator translates quads into triples using the 
     375                        named graph approach, similar to the one proposed by Tappolet 
     376                        et al. and described in http://dl.acm.org/citation.cfm?id=1561565.  
     377                         
     378                        *The rdbms level of Strabon has been extended to (i) support 
     379                        tha period datatype (ii) store the period values in the table 
     380                        period_values(id, period). The period column is of the period 
     381                        datatype, offered by the PostgreSQL Temporal extension (http://sourceforge.net/projects/pgsql-temporal/).  
     382                        Also, a GiST index is created on this column. 
     383                         
     384                        *A rewriting mechanism that converts quad graph patterns into 
     385                         triple partners using the named graphs approach has been 
     386                         implemented as a method of the runtime.generaldb.Strabon  
     387                         class.  
     388                         
     389                        *A big part of the temporal functions of stSPARQL has been 
     390                        imlemented. These functions include: 
     391                                *The temporal relation functions during, periodOverlaps,  
     392                                equalsPeriod, nequalsPeriod, adjacent, before, after,  
     393                                overleft, overright, meets, starts, finishes. 
     394                                 
     395                                *The period constructors period_intersect, period_union, 
     396                                 preceding_period, and succeeding_period. The last two 
     397                                 constructors are implemented using the jtemporal library. 
     398                                 The other functions are implemented in the database, 
     399                                 being mapped into the respective functions of PostgreSQL 
     400                                 Temporal. A complete reference of PostgreSQL Temporal  
     401                                 can be found here: http://temporal.projects.pgfoundry.org/reference.html. 
     402                                  
     403                                 *The temporal constants "NOW" and "UC" (Until Changed)  
     404                                 are supported. 
     405                                  
     406                        *The vocabulary of the valid time dimension of stSPARQL can 
     407                        be found at the TemporalConstants class of the evaluation  
     408                        module. 
     409                                                 
    325410        * Changed behaviour of Strabon and Strabon Endpoint for connecting to 
    326411        a spatially-enabled database. Only one instance of Strabon is allowed 
  • ChangeLog

    r1455 r1527  
    1         * Completed implementation of the period function, that constructs 
    2           a period with start and end points the given arguments 
     1Wed Mar 11 21:02:48 2015   Pyravlos Team 
     2         
     3        * Bug #73, modified appendBuffer function to take the srid into 
     4          consideration even if the argument is a constant (wktLiteral 
     5          or strdf literal) 
     6 
     7        * Update jar references on scripts used by the debian packaging. 
     8          Previously these references pointed only (incorrectly) to 
     9          SNAPSHOTs. 
     10 
     11        * Updated package names (since repositories cannot include capital 
     12          letters + runtime and endpoint-exec must have different names 
     13 
     14        * Version 3.3.1 released. 
     15 
     16        * Bug #58, added script that is invoked my maven to also update the 
     17          version described in the deb/control file of the runtime and 
     18          endpoint-exec components. 
     19 
     20        * Related to bug #58, but it generally enhances Strabon; The runtime 
     21          component has also been debianized. Dependencies are added to 
     22          /usr/share/jdeb/lib/strabon-runtime. ClassPath and strabon script 
     23          have also been updated accordingly (strabon-cmd) 
     24 
     25        * Bug #58: Maven creates the debian package conditionally. Use 
     26          -Ddebian=true in the mvn package command.  
     27 
     28        * Bug #58: Added dependencies - java, postgresql, tomcat. Also, added 
     29          a strabon-init script that detects the postgis installation path 
     30          and sets up the template_postgis. Finally the script creates a db 
     31          called "endpoint" (assuming it does not already exist) that is used 
     32          for the strabon-endpoint command. 
     33         
     34        * Fixed an issue that returned null SRID when unmarshalling GML geometries if 
     35          the SRID did not follow one of the supported formats by GML-JTS. To fix that 
     36          we added a function that handles these cases by reading the userData variable 
     37          that JTS provides. 
     38 
     39        * Fixed a bug that would return no results when a variable that results  
     40          from a BIND clause appears in the FILTER or in the projection of a 
     41          query and is inside a spatial function. 
     42          (bug #78: http://bug.strabon.di.uoa.gr/ticket/78) 
     43 
     44        * Fixed the precision of the geometry literals in GeoJSON writer. Now, 
     45          this defaults to the precision model of JTS (equals to 16). Prior to 
     46          this it was fixed to 4. 
     47 
     48        * Now the GeoJSON writer is aware of the kind of typed literals (e.g., 
     49          numeric, boolean, calendar, etc.) and prints the corresponding 
     50          values according to these types.  
     51 
     52        * Fixed a bug that would not return the correct result or would fail  
     53          when a spatial function involved a constant and a variable. 
     54          (bug #74: http://bug.strabon.di.uoa.gr/ticket/74) 
     55 
    356        * Fixed a bug that would not return the correct spatial datatype of a 
    457          projected geometry literal stored in the database. 
  • endpoint-client/pom.xml

    r1427 r1527  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • endpoint-exec/pom.xml

    r1427 r1527  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
     
    9494                                </executions> 
    9595                        </plugin> 
    96                     <plugin> 
    97                                 <artifactId>jdeb</artifactId> 
    98                                 <groupId>org.vafer</groupId> 
    99                                 <version>1.3</version> 
    100                                 <executions> 
    101                                         <execution> 
    102                                                 <phase>package</phase> 
    103                                                 <goals> 
    104                                                         <goal>jdeb</goal> 
    105                                                 </goals> 
    106                                         <configuration> 
    107                                                 <skipPOMs>false</skipPOMs> 
    108                                                 <dataSet> 
    109                                                         <data> 
    110                                                                 <src>${project.build.directory}/strabon-endpoint-executable-${project.version}.jar</src> 
    111                                                                 <type>file</type> 
    112                                                                 <mapper> 
    113                                                                         <type>perm</type> 
    114                                                                         <prefix>/usr/share/jdeb/lib</prefix> 
    115                                                                 </mapper> 
    116                                                         </data> 
    117                                                         <data> 
    118                                                                 <src>${basedir}/strabon-endpoint</src> 
    119                                                                 <type>file</type> 
    120                                                                 <mapper> 
    121                                                                         <type>perm</type> 
    122                                                                         <prefix>/usr/local/bin</prefix> 
    123                                                                         <user>root</user> 
    124                                                                         <group>root</group> 
    125                                                                         <filemode>755</filemode> 
    126                                                                 </mapper> 
    127                                                         </data> 
    128                                                 </dataSet> 
    129                                         </configuration> 
    130                                 </execution> 
    131                         </executions> 
    132                         </plugin> 
    133  
    134  
     96                         
     97                     
    13598                </plugins> 
    13699        </build> 
     100 
     101<profiles> 
     102                <profile> 
     103                        <id>create-debian</id> 
     104                        <activation> 
     105                                <activeByDefault>false</activeByDefault> 
     106                                <property> 
     107                                        <name>debian</name> 
     108                                        <value>true</value> 
     109                                </property> 
     110                        </activation> 
     111                                <build> 
     112                                        <plugins> 
     113                                                <plugin> 
     114                                                    <groupId>org.codehaus.mojo</groupId> 
     115                                                    <artifactId>exec-maven-plugin</artifactId> 
     116                                                    <version>1.1.1</version> 
     117                                                    <executions> 
     118                                                      <execution> 
     119                                                        <!-- 
     120                                                        <id>some-execution</id> 
     121                                                        --> 
     122                                                        <phase>package</phase> 
     123                                                        <goals> 
     124                                                          <goal>exec</goal> 
     125                                                        </goals> 
     126                                                      </execution> 
     127                                                    </executions> 
     128                                                    <configuration> 
     129                                                      <executable>${basedir}/../scripts/update-debian-version.sh</executable> 
     130                                                    </configuration> 
     131                                                  </plugin> 
     132 
     133                                                <plugin> 
     134                                                        <artifactId>jdeb</artifactId> 
     135                                                        <groupId>org.vafer</groupId> 
     136                                                        <version>1.3</version> 
     137                                                        <executions> 
     138                                                                <execution> 
     139                                                                        <phase>package</phase> 
     140                                                                        <goals> 
     141                                                                                <goal>jdeb</goal> 
     142                                                                        </goals> 
     143                                                                <configuration> 
     144                                                                        <skipPOMs>false</skipPOMs> 
     145                                                                        <dataSet> 
     146                                                                                <data> 
     147                                                                                        <src>${project.build.directory}/strabon-endpoint-executable-${project.version}.jar</src> 
     148                                                                                        <type>file</type> 
     149                                                                                        <mapper> 
     150                                                                                                <type>perm</type> 
     151                                                                                                <prefix>/usr/share/jdeb/lib</prefix> 
     152                                                                                        </mapper> 
     153                                                                                </data> 
     154                                                                                <data> 
     155                                                                                        <src>${basedir}/strabon-endpoint</src> 
     156                                                                                        <type>file</type> 
     157                                                                                        <mapper> 
     158                                                                                                <type>perm</type> 
     159                                                                                                <prefix>/usr/local/bin</prefix> 
     160                                                                                                <user>root</user> 
     161                                                                                                <group>root</group> 
     162                                                                                                <filemode>755</filemode> 
     163                                                                                        </mapper> 
     164                                                                                </data> 
     165                                                                                <data> 
     166                                                                                        <src>${basedir}/strabon-init</src> 
     167                                                                                        <type>file</type> 
     168                                                                                        <mapper> 
     169                                                                                                <type>perm</type> 
     170                                                                                                <prefix>/usr/local/bin</prefix> 
     171                                                                                                <user>root</user> 
     172                                                                                                <group>root</group> 
     173                                                                                                <filemode>755</filemode> 
     174                                                                                        </mapper> 
     175                                                                                </data> 
     176                                                                        </dataSet> 
     177                                                                </configuration> 
     178                                                        </execution> 
     179                                                </executions> 
     180                                        </plugin> 
     181                                </plugins> 
     182                        </build> 
     183                </profile> 
     184        </profiles> 
    137185</project> 
  • endpoint/pom.xml

    r1427 r1527  
    55                <groupId>eu.earthobservatory</groupId> 
    66                <artifactId>strabon</artifactId> 
    7                 <version>3.2.10-temporals-SNAPSHOT</version> 
     7                <version>3.3.2-SNAPSHOT</version> 
    88        </parent> 
    99 
  • evaluation/pom.xml

    r1519 r1527  
    7373        <artifactId>jaxb-impl</artifactId> 
    7474</dependency> 
     75                <dependency> 
     76                        <groupId>jtemporal</groupId> 
     77                        <artifactId>jtemporal</artifactId> 
     78                        <version>1.0</version> 
     79                        <scope>system</scope> 
     80                        <systemPath>${basedir}/lib/jtemporal.jar</systemPath> 
     81                </dependency> 
    7582        </dependencies> 
    7683        <modules> 
  • evaluation/pom.xml

    r1427 r1527  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java

    r1480 r1527  
    1212import java.net.URI; 
    1313 
     14import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 
    1415import org.slf4j.Logger; 
    1516import org.slf4j.LoggerFactory; 
     
    206207                 
    207208                return srid; 
    208         } 
     209        }*/ 
    209210        */ 
    210211} 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java

    r1482 r1527  
    195195         * @return 
    196196          
    197         protected int getEPSG_SRID(String wkt) { 
     197        protected Integer getEPSG_SRID(String wkt) { 
    198198                int srid = GeoConstants.defaultSRID; 
    199199                 
    200200                try { 
    201201                        srid = Integer.parseInt(wkt.substring(wkt.lastIndexOf('/') + 1).replace(">", "")); 
    202                          
     202 
    203203                } catch (NumberFormatException e) { 
    204204                        logger.warn("[Strabon.AbstractWKT] Was expecting an integer. The URL of the EPSG SRID was {}. Continuing with the default SRID, {}", wkt, srid); 
     
    208208                return srid; 
    209209        }*/ 
     210        */ 
    210211} 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/util/JTSWrapper.java

    r1480 r1527  
    235235                        return geometry; 
    236236                }                
     237                }                
    237238        } 
    238239         
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/util/JTSWrapper.java

    r1482 r1527  
    2424import org.opengis.referencing.operation.MathTransform; 
    2525import org.opengis.referencing.operation.TransformException; 
     26import org.openrdf.query.algebra.evaluation.function.spatial.AbstractWKT; 
    2627import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 
    2728import org.slf4j.Logger; 
     
    2930 
    3031import com.vividsolutions.jts.geom.Geometry; 
     32import com.vividsolutions.jts.geom.PrecisionModel; 
    3133import com.vividsolutions.jts.io.ParseException; 
    3234import com.vividsolutions.jts.io.WKBReader; 
     
    3739import com.vividsolutions.jts.io.gml2.GMLWriter; 
    3840 
     41import eu.earthobservatory.constants.GeoConstants; 
     42 
    3943/** 
    4044 * This class is a singleton and provides access to the readers/writers 
     
    7781        private GMLWriter gmlw; 
    7882         
     83        /** 
     84         * Stores the number of decimal places for the 
     85         * default precision model of JTS.  
     86         */ 
     87        private int numDecimalPlaces; 
     88 
    7989        private JTSWrapper() { 
    8090                // use a private constructor to force call of getInstance method and forbid subclassing 
     
    8595//              wkbw = new WKBWriter(2, WKBConstants.wkbXDR); // MonetDB 
    8696                gmlw = new GMLWriter(); 
     97 
     98                numDecimalPlaces = (new PrecisionModel()).getMaximumSignificantDigits(); 
    8799        } 
    88100         
     
    223235                        return geometry; 
    224236                }                
     237                }                
    225238        } 
    226239         
     
    228241                return gmlw.write(geom); 
    229242        } 
     243 
     244        /** 
     245         * Returns the number of decimal places corresponding to the 
     246         * precision model that is used by default by the JTS library. 
     247         *  
     248         * @return 
     249         */ 
     250        public int getPrecision() { 
     251                return numDecimalPlaces; 
     252        } 
    230253} 
  • generaldb/pom.xml

    r1427 r1527  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.2.10-temporals-SNAPSHOT</version> 
     9                <version>3.3.2-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r1447 r1527  
    5454import org.openrdf.query.algebra.evaluation.function.spatial.SpatialPropertyFunc; 
    5555import org.openrdf.query.algebra.evaluation.function.spatial.SpatialRelationshipFunc; 
     56import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPeriod; 
    5657import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron; 
     58import org.openrdf.query.algebra.evaluation.function.spatial.StrabonTemporalElement; 
    5759import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 
    5860import org.openrdf.query.algebra.evaluation.function.spatial.geosparql.nontopological.GeoSparqlConvexHullFunc; 
     
    8688import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.relation.mbb.MbbIntersectsFunc; 
    8789import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.relation.mbb.MbbWithinFunc; 
     90import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.TemporalConstructFunc; 
     91import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.relation.TemporalRelationFunc; 
    8892import org.openrdf.query.algebra.evaluation.impl.EvaluationStrategyImpl; 
    8993import org.openrdf.query.algebra.evaluation.iterator.FilterIterator; 
     
    127131import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn; 
    128132import org.openrdf.sail.generaldb.algebra.base.GeneralDBSqlExpr; 
     133import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlTemporalConstructBinary; 
     134import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlTemporalConstructUnary; 
    129135import org.openrdf.sail.generaldb.exceptions.UnsupportedExtensionFunctionException; 
    130136import org.openrdf.sail.generaldb.model.GeneralDBPolyhedron; 
     
    144150import eu.earthobservatory.constants.GeoConstants; 
    145151import eu.earthobservatory.constants.OGCConstants; 
     152import eu.earthobservatory.constants.TemporalConstants; 
    146153 
    147154/** 
     
    166173 
    167174        protected HashMap<String, Integer> geoNames = new HashMap<String, Integer>(); 
    168  
     175         
    169176        protected List<GeneralDBSqlExpr> thematicExpressions = new ArrayList<GeneralDBSqlExpr>(5); 
    170177         
     
    173180         * A <tt>NULL</tt> result type is to be interpreted as error.    
    174181         */  
    175         public enum ResultType { INTEGER, STRING, BOOLEAN, WKT, WKTLITERAL, DOUBLE, URI, NULL}; 
    176  
     182        public enum ResultType { INTEGER, STRING, BOOLEAN, WKB, DOUBLE, URI, PERIOD, INSTANT, NULL,  WKT, WKTLITERAL}; 
     183 
     184         
    177185        //used to retrieve the appropriate column in the Binding Iteration 
    178186        protected HashMap<GeneralDBSpatialFuncInfo, Integer> constructIndexesAndNames = new HashMap<GeneralDBSpatialFuncInfo, Integer>(); 
     
    181189        //      private HashMap<String, Integer> intPropertiesIndexesAndNames = new HashMap<String, Integer>(); 
    182190        //      private HashMap<String, Integer> boolPropertiesIndexesAndNames = new HashMap<String, Integer>(); 
    183         //      private HashMap<String, Integer> stringPropertiesIndexesAndNames = new HashMap<String, Integer>(); 
    184  
     191 
     192        protected HashMap<Integer,String> temporalVars = new HashMap<Integer,String>(); 
     193 
     194         
    185195        public GeneralDBEvaluation(GeneralDBQueryBuilderFactory factory, GeneralDBTripleRepository triples, Dataset dataset, IdSequence ids) 
    186196        { 
     
    237247                        var.setName(var.getName().replace("?spatial","")); 
    238248                } 
    239  
     249                else if(var.getName().endsWith("?temporal")) 
     250                { 
     251                        var.setName(var.getName().replace("?temporal","")); 
     252                } 
    240253                if(var.getName().endsWith("?forGroupBy")) 
    241254                { 
     
    304317                        // get the first argument of the function call 
    305318                        ValueExpr left = fc.getArgs().get(0); 
    306                  
     319 
    307320                        // evaluated first argument of function 
    308321                        Value leftResult = null; 
     
    465478 
    466479                                return funcResult ? BooleanLiteralImpl.TRUE : BooleanLiteralImpl.FALSE; 
     480                        } 
     481                        else if(function instanceof TemporalConstructFunc) { 
     482                                return temporalConstructPicker(function, leftResult, rightResult); 
     483                        } 
     484                        else if(function instanceof TemporalRelationFunc){ 
     485                                Boolean temporalFuncResult =  temporalRelationshipPicker(function, leftResult, rightResult); 
     486                                return temporalFuncResult ? BooleanLiteralImpl.TRUE : BooleanLiteralImpl.FALSE; 
    467487                        } 
    468488                         
     
    577597        } 
    578598 
     599        public StrabonTemporalElement temporalConstructPicker(Function function, Value left, Value right) throws ParseException 
     600        { 
     601                //temporarily commented out the following so that they will be evaluated in postgres temporal and not in Java 
     602                /* 
     603                if(function.getURI().equals(TemporalConstants.periodUnion)) 
     604                { 
     605 
     606                        StrabonTemporalElement rightArg= null; 
     607                        StrabonTemporalElement leftArg= null; 
     608                         
     609                        if(left.toString().contains(",")) 
     610                        { 
     611                                 leftArg= new StrabonPeriod(left.toString()); 
     612                        } 
     613                        else 
     614                        { 
     615                                 leftArg = StrabonInstant.read(left.toString()); 
     616                        } 
     617                        if(right.toString().contains(",")) 
     618                        { 
     619                                 rightArg= new StrabonPeriod(right.toString()); 
     620                        } 
     621                        else 
     622                        { 
     623                                 rightArg = StrabonInstant.read(right.toString()); 
     624                        } 
     625                         
     626                        return StrabonPeriod.union(rightArg, leftArg); 
     627                         
     628                } 
     629                /*else if(function.getURI().equals(TemporalConstants.periodIntersection)) 
     630                {                        
     631 
     632                        StrabonTemporalElement rightArg= null; 
     633                        StrabonTemporalElement leftArg= null; 
     634                         
     635                        if(left.toString().contains(",")) 
     636                        { 
     637                                 leftArg= new StrabonPeriod(left.toString()); 
     638                        } 
     639                        else 
     640                        { 
     641                                 leftArg = StrabonInstant.read(left.toString()); 
     642                        } 
     643                        if(right.toString().contains(",")) 
     644                        { 
     645                                 rightArg= new StrabonPeriod(right.toString()); 
     646                        } 
     647                        else 
     648                        { 
     649                                 rightArg = StrabonInstant.read(right.toString()); 
     650                        } 
     651                        return StrabonPeriod.intersection(rightArg, leftArg); 
     652                } 
     653                else if(function.getURI().equals(TemporalConstants.minusPeriod)) 
     654                { //this functions takes only periods as arguments 
     655                        if(!right.toString().contains(",") || !left.toString().contains(",")) 
     656                                return null; 
     657                        return StrabonPeriod.except(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     658                } 
     659                else if(function.getURI().equals(TemporalConstants.precedingPeriod)) 
     660                { 
     661                        if(!right.toString().contains(",") || !left.toString().contains(",")) 
     662                                return null; 
     663                        return StrabonPeriod.precedingPeriod(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     664                } 
     665                else if(function.getURI().equals(TemporalConstants.succedingPeriod)) 
     666                { 
     667                        if(!right.toString().contains(",") || !left.toString().contains(",")) 
     668                                return null; 
     669                        return StrabonPeriod.succedingPeriod(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     670                } 
     671                else if(function.getURI().equals(TemporalConstants.PERIOD)) 
     672                { //constracting a new period given two dateTime values 
     673                        if(left.toString().contains(",") || right.toString().contains(",")) 
     674                                return null; 
     675                        return new StrabonPeriod(left.toString(), right.toString()); 
     676                } 
     677                else 
     678                { 
     679                        return null;                     
     680                }*/ 
     681                return null; 
     682        } 
     683         
     684        public boolean temporalRelationshipPicker (Function function, Value left, Value right) throws ParseException, java.text.ParseException 
     685        { 
     686                if(function.getURI().equals(TemporalConstants.adjacent)) 
     687                { 
     688                        return StrabonPeriod.meets(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     689                } 
     690                else if(function.getURI().equals(TemporalConstants.after)) 
     691                { 
     692                        return StrabonPeriod.succedes(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     693                } 
     694                else if(function.getURI().equals(TemporalConstants.meetsBefore)) 
     695                { 
     696                        return StrabonPeriod.meetsBefore(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     697                } 
     698                else if(function.getURI().equals(TemporalConstants.meetsAfter)) 
     699                { 
     700                        return StrabonPeriod.meetsAfter(new StrabonPeriod(left.toString()), new StrabonPeriod(right.toString())); 
     701                } 
     702                else 
     703                { 
     704                        return false; 
     705                } 
     706        } 
     707         
    579708        /** 
    580709         * FIXME don't check function using getURI(); use instanceof instead  
     
    827956                                                        index++; 
    828957                                                } 
     958                                                if(var.isTemporal())  
     959                                                { 
     960                                                        this.temporalVars.put(var.getIndex()+1,var.getName()); 
     961                                                } 
    829962                                                query.select(proj.getId()); 
    830963                                                query.select(proj.getStringValue()); 
     
    8861019                                         
    8871020                                } 
    888  
    8891021                                constructIndexesAndNames.put(info, index++); 
    8901022                                if(increaseIndex) 
     
    8961028                        } 
    8971029                } 
    898                 // 
     1030                Iterator iter = qb.getTemporalConstructs().entrySet().iterator(); 
     1031                while (iter.hasNext()) { 
     1032                        @SuppressWarnings("rawtypes") 
     1033                        Map.Entry pairs = (Map.Entry)iter.next(); 
     1034                        //System.out.println(pairs.getKey() + " = " + pairs.getValue()); 
     1035 
     1036                        //Trying to fill what's missing 
     1037                        GeneralDBSqlExpr expr = (GeneralDBSqlExpr) pairs.getValue(); 
     1038                        locateColumnVars(expr,qb.getVars()); 
     1039 
     1040                        //Assuming thematic aggregates and spatial expressions won't be combined 
     1041                        if(!this.thematicExpressions.contains(expr)) 
     1042                        { 
     1043                                query.construct(expr); 
     1044                                boolean increaseIndex = false; 
     1045 
     1046                                GeneralDBSpatialFuncInfo info = null; 
     1047                                 
     1048                                ResultType type = getResultType(expr); 
     1049                                if (type == ResultType.NULL) { 
     1050                                        throw new UnsupportedRdbmsOperatorException("No such temporal expression exists!"); 
     1051                                         
     1052                                } else { 
     1053                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), type, false);               
     1054                                } 
     1055 
     1056                                constructIndexesAndNames.put(info, index++); 
     1057                        } 
     1058                } 
    8991059 
    9001060                for (OrderElem by : qb.getOrderElems()) { 
     
    9111071                } 
    9121072                parameters.addAll(query.getParameters()); 
    913  
    9141073                return query.toString(); 
    9151074        } 
     
    9781137                        //                      for(GeneralDBColumnVar reference: allKnown) 
    9791138                        //                      { 
    980                         //                              if(var.getName().equals(reference.getName())) 
     1139                        //                              if(var.getName()-.equals(reference.getName())) 
    9811140                        //                              { 
    9821141                        //                                      var = reference; 
     
    10601219                        locateColumnVars(((GeneralDBSqlGeoSpatial)expr).getLeftArg(),allKnown);  
    10611220                        locateColumnVars(((GeneralDBSqlGeoSpatial)expr).getRightArg(),allKnown); 
     1221                } 
     1222                else if(expr instanceof GeneralDBSqlTemporalConstructBinary) 
     1223                { 
     1224                        locateColumnVars(((GeneralDBSqlTemporalConstructBinary)expr).getLeftArg(),allKnown); 
     1225                        locateColumnVars(((GeneralDBSqlTemporalConstructBinary)expr).getRightArg(),allKnown);            
     1226                } 
     1227                else if(expr instanceof GeneralDBSqlTemporalConstructUnary) 
     1228                { 
     1229                        locateColumnVars(((GeneralDBSqlTemporalConstructUnary)expr).getArg(),allKnown); 
    10621230                } 
    10631231                else 
     
    11081276         *                      when the supplied value is a constant ({@link Literal}) and is not 
    11091277         *                      a valid WKT literal 
     1278         * @throws ParseException 
    11101279         */ 
    11111280        public String getSRIDFromValue(Value value) throws ParseException { 
     
    12161385        /** 
    12171386         * Given an expression get the type of the result.  
     1387         * Extended it to take into account the temporal constructs 
    12181388         *  
    12191389         * @param expr 
     
    12851455                        return ResultType.DOUBLE; 
    12861456                } 
     1457                else if(expr instanceof GeneralDBSqlTemporalConstructBinary) 
     1458                { 
     1459                        return ResultType.PERIOD; 
     1460                } 
    12871461                else if(expr instanceof GeneralDBSqlGeoSpatial) 
    12881462                { 
    1289                         return ResultType.BOOLEAN; 
    1290                 } 
    1291                  
     1463                        return ResultType.BOOLEAN;               
     1464                } 
     1465         
     1466                else if(expr instanceof GeneralDBSqlTemporalConstructUnary) 
     1467                { 
     1468                        return ResultType.INSTANT; 
     1469                } 
     1470                System.out.println("NOT SUPPORTED OPERATOR!!!"); 
    12921471                return ResultType.NULL;//SHOULD NEVER REACH THIS CASE 
    12931472        } 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r1427 r1527  
    1515import java.util.Collection; 
    1616import java.util.HashMap; 
     17import java.util.HashSet; 
    1718import java.util.Iterator; 
    1819import java.util.List; 
    1920import java.util.Map; 
     21import java.util.Set; 
    2022 
    2123import org.openrdf.model.Literal; 
     
    3133import org.openrdf.query.algebra.Avg; 
    3234import org.openrdf.query.algebra.Distinct; 
     35import org.openrdf.query.algebra.Filter; 
    3336import org.openrdf.query.algebra.FunctionCall; 
    3437import org.openrdf.query.algebra.Group; 
     
    8891import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.relation.TemporalRelationFunc; 
    8992import org.openrdf.query.algebra.evaluation.impl.EvaluationStrategyImpl; 
     93import org.openrdf.query.algebra.evaluation.iterator.FilterIterator; 
    9094import org.openrdf.query.algebra.evaluation.iterator.OrderIterator; 
     95import org.openrdf.query.algebra.evaluation.iterator.StSPARQLFilterIterator; 
    9196import org.openrdf.query.algebra.evaluation.iterator.StSPARQLGroupIterator; 
    9297import org.openrdf.query.algebra.evaluation.util.JTSWrapper; 
     
    350355                                if(function instanceof AreaFunc) 
    351356                                { 
     357                                        // check required number of arguments 
     358                                        checkArgs(leftResult, rightResult, thirdResult, 1); 
     359                                         
    352360                                        funcResult = leftGeom.getArea(); 
    353361                                }  
     
    532540                        return null; 
    533541                } 
     542        } 
     543 
     544        /*Evaluation of Filter*/ 
     545        public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(Filter filter, BindingSet bindings) 
     546                        throws QueryEvaluationException 
     547        { 
     548                        CloseableIteration<BindingSet, QueryEvaluationException> result; 
     549                        result = this.evaluate(filter.getArg(), bindings); 
     550 
     551                        Set <String> spatialConstructs = new HashSet<String>(); 
     552                        for(GeneralDBSpatialFuncInfo construct : constructIndexesAndNames.keySet()) { 
     553                                spatialConstructs.add(construct.getFieldName()); 
     554                        } 
     555                        //add the spatial constructs to the scope of the FILTER (case of a BIND clause 
     556                        //that contains a spatial construct)     
     557                        result = new StSPARQLFilterIterator(filter, result, spatialConstructs, this); 
     558                        return result; 
    534559        } 
    535560 
     
    558583                                 
    559584                        } 
    560                          
     585 
    561586                        if (size > 3) { 
     587                                throw new NoSuchMethodException("too many arguments."); 
     588                        } 
     589 
     590                        if (size == 1 && (rightResult !=null || thirdResult != null) ) { 
     591                                throw new NoSuchMethodException("too many arguments."); 
     592                        } 
     593                        if (size == 2 && thirdResult != null) { 
    562594                                throw new NoSuchMethodException("too many arguments."); 
    563595                        } 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/model/XMLGSDatatypeUtil.java

    r1441 r1527  
    1010 
    1111import eu.earthobservatory.constants.GeoConstants; 
     12import eu.earthobservatory.constants.MiscConstants; 
    1213import eu.earthobservatory.constants.WKTConstants; 
     14import eu.earthobservatory.constants.TemporalConstants; 
    1315 
    1416 
     
    2325         * @return 
    2426         * @author Charalampos Nikolaou <charniK@di.uoa.gr> 
     27         *  
     28         * @author Konstantina Bereta <Konstantina.Bereta@di.uoa.gr> 
     29         * added period datatype validator as well for storing valid time period literals 
    2530         */ 
    2631        public static boolean isGeometryValue(Value value) { 
     
    107112         
    108113                return GeoConstants.GML.equals(datatype.stringValue()); 
     114        } 
     115         
     116        /** 
     117         * Checks whether the supplied datatype is actually a color literal. 
     118         *  
     119         * @param datatype 
     120         * @return 
     121         * @author George Garbis <ggarbis@di.uoa.gr> 
     122         */ 
     123        public static boolean isColorDatatype(URI datatype) 
     124        { 
     125                if(datatype == null) { 
     126                        return false; 
     127                } 
     128         
     129                return MiscConstants.color.equals(datatype.stringValue()); 
     130        } 
     131         
     132        /** 
     133         * Checks whether the supplied datatype is actually a Period literal. 
     134         *  
     135         * @param datatype 
     136         * @return 
     137         */ 
     138        public static boolean isPeriodDatatype(URI datatype) 
     139        { 
     140                if(datatype == null) { 
     141                        return false; 
     142                } 
     143         
     144                return TemporalConstants.PERIOD.equals(datatype.stringValue()); 
    109145        } 
    110146         
  • generaldb/src/main/java/org/openrdf/sail/generaldb/model/XMLGSDatatypeUtil.java

    r1427 r1527  
    11package org.openrdf.sail.generaldb.model; 
    22 
    3 import java.math.BigDecimal; 
    4 import java.math.BigInteger; 
    5 import java.util.StringTokenizer; 
    6  
    7 import javax.xml.datatype.DatatypeConfigurationException; 
    8 import javax.xml.datatype.DatatypeConstants; 
    9 import javax.xml.datatype.DatatypeFactory; 
    103import javax.xml.datatype.XMLGregorianCalendar; 
    11 import javax.xml.namespace.QName; 
    124 
    135import org.openrdf.model.Literal; 
    146import org.openrdf.model.URI; 
    157import org.openrdf.model.Value; 
    16 import org.openrdf.model.datatypes.XMLDateTime; 
    178import org.openrdf.model.vocabulary.XMLSchema; 
    189import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron; 
     
    2415 
    2516 
    26  
    2717public class XMLGSDatatypeUtil { 
    2818         
    29         private static DatatypeFactory dtFactory; 
    30  
    31         static { 
    32                 try { 
    33                         dtFactory = DatatypeFactory.newInstance(); 
    34                 } 
    35                 catch (DatatypeConfigurationException e) { 
    36                         throw new RuntimeException(e); 
    37                 } 
    38         } 
    39  
    40         /*-------------------* 
    41          * Datatype checking * 
    42          *-------------------*/ 
    43  
    4419        /** 
    4520         * Returns true when the given value is an instance of class @{link GeneralDBPolyhedron}  
     
    190165        public static boolean isPrimitiveDatatype(URI datatype) { 
    191166                return 
    192                 datatype.equals(XMLSchema.DURATION) || 
    193                 datatype.equals(XMLSchema.DATETIME) || 
    194                 datatype.equals(XMLSchema.TIME) || 
    195                 datatype.equals(XMLSchema.DATE) || 
    196                 datatype.equals(XMLSchema.GYEARMONTH) || 
    197                 datatype.equals(XMLSchema.GYEAR) || 
    198                 datatype.equals(XMLSchema.GMONTHDAY) || 
    199                 datatype.equals(XMLSchema.GDAY) || 
    200                 datatype.equals(XMLSchema.GMONTH) || 
    201                 datatype.equals(XMLSchema.STRING) || 
    202                 datatype.equals(XMLSchema.BOOLEAN) || 
    203                 datatype.equals(XMLSchema.BASE64BINARY) || 
    204                 datatype.equals(XMLSchema.HEXBINARY) || 
    205                 datatype.equals(XMLSchema.FLOAT) || 
    206                 datatype.equals(XMLSchema.DECIMAL) || 
    207                 datatype.equals(XMLSchema.DOUBLE) || 
    208                 datatype.equals(XMLSchema.ANYURI) || 
    209                 datatype.equals(XMLSchema.QNAME) || 
    210                 datatype.equals(XMLSchema.NOTATION); 
     167                XMLSchema.DURATION.equals(datatype)|| 
     168                XMLSchema.DATETIME.equals(datatype) || 
     169                XMLSchema.TIME.equals(datatype) || 
     170                XMLSchema.DATE.equals(datatype) || 
     171                XMLSchema.GYEARMONTH.equals(datatype) || 
     172                XMLSchema.GYEAR.equals(datatype) || 
     173                XMLSchema.GMONTHDAY.equals(datatype) || 
     174                XMLSchema.GDAY.equals(datatype) || 
     175                XMLSchema.GMONTH.equals(datatype) || 
     176                XMLSchema.STRING.equals(datatype) || 
     177                XMLSchema.BOOLEAN.equals(datatype) || 
     178                XMLSchema.BASE64BINARY.equals(datatype) || 
     179                XMLSchema.HEXBINARY.equals(datatype) || 
     180                XMLSchema.FLOAT.equals(datatype) || 
     181                XMLSchema.DECIMAL.equals(datatype) || 
     182                XMLSchema.DOUBLE.equals(datatype) || 
     183                XMLSchema.ANYURI.equals(datatype) || 
     184                XMLSchema.QNAME.equals(datatype) || 
     185                XMLSchema.NOTATION.equals(datatype); 
    211186        } 
    212187 
     
    216191        public static boolean isDerivedDatatype(URI datatype) { 
    217192                return 
    218                 datatype.equals(XMLSchema.NORMALIZEDSTRING) || 
    219                 datatype.equals(XMLSchema.TOKEN) || 
    220                 datatype.equals(XMLSchema.LANGUAGE) || 
    221                 datatype.equals(XMLSchema.NMTOKEN) || 
    222                 datatype.equals(XMLSchema.NMTOKENS) || 
    223                 datatype.equals(XMLSchema.NAME) || 
    224                 datatype.equals(XMLSchema.NCNAME) || 
    225                 datatype.equals(XMLSchema.ID) || 
    226                 datatype.equals(XMLSchema.IDREF) || 
    227                 datatype.equals(XMLSchema.IDREFS) || 
    228                 datatype.equals(XMLSchema.ENTITY) || 
    229                 datatype.equals(XMLSchema.ENTITIES) || 
    230                 datatype.equals(XMLSchema.INTEGER) || 
    231                 datatype.equals(XMLSchema.LONG) || 
    232                 datatype.equals(XMLSchema.INT) || 
    233                 datatype.equals(XMLSchema.SHORT) || 
    234                 datatype.equals(XMLSchema.BYTE) || 
    235                 datatype.equals(XMLSchema.NON_POSITIVE_INTEGER) || 
    236                 datatype.equals(XMLSchema.NEGATIVE_INTEGER) || 
    237                 datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER) || 
    238                 datatype.equals(XMLSchema.POSITIVE_INTEGER) || 
    239                 datatype.equals(XMLSchema.UNSIGNED_LONG) || 
    240                 datatype.equals(XMLSchema.UNSIGNED_INT) || 
    241                 datatype.equals(XMLSchema.UNSIGNED_SHORT) || 
    242                 datatype.equals(XMLSchema.UNSIGNED_BYTE); 
     193                XMLSchema.NORMALIZEDSTRING.equals(datatype) || 
     194                XMLSchema.TOKEN.equals(datatype) || 
     195                XMLSchema.LANGUAGE.equals(datatype) || 
     196                XMLSchema.NMTOKEN.equals(datatype) || 
     197                XMLSchema.NMTOKENS.equals(datatype) || 
     198                XMLSchema.NAME.equals(datatype) || 
     199                XMLSchema.NCNAME.equals(datatype) || 
     200                XMLSchema.ID.equals(datatype) || 
     201                XMLSchema.IDREF.equals(datatype) || 
     202                XMLSchema.IDREFS.equals(datatype) || 
     203                XMLSchema.ENTITY.equals(datatype) || 
     204                XMLSchema.ENTITIES.equals(datatype) || 
     205                XMLSchema.INTEGER.equals(datatype) || 
     206                XMLSchema.LONG.equals(datatype) || 
     207                XMLSchema.INT.equals(datatype) || 
     208                XMLSchema.SHORT.equals(datatype) || 
     209                XMLSchema.BYTE.equals(datatype) || 
     210                XMLSchema.NON_POSITIVE_INTEGER.equals(datatype) || 
     211                XMLSchema.NEGATIVE_INTEGER.equals(datatype) || 
     212                XMLSchema.NON_NEGATIVE_INTEGER.equals(datatype) || 
     213                XMLSchema.POSITIVE_INTEGER.equals(datatype) || 
     214                XMLSchema.UNSIGNED_LONG.equals(datatype) || 
     215                XMLSchema.UNSIGNED_INT.equals(datatype) || 
     216                XMLSchema.UNSIGNED_SHORT.equals(datatype) || 
     217                XMLSchema.UNSIGNED_BYTE.equals(datatype); 
    243218        } 
    244219 
     
    265240        public static boolean isDecimalDatatype(URI datatype) { 
    266241                return 
    267                 datatype.equals(XMLSchema.DECIMAL) || 
     242                XMLSchema.DECIMAL.equals(datatype) || 
    268243                isIntegerDatatype(datatype); 
    269244        } 
     
    275250        public static boolean isIntegerDatatype(URI datatype) { 
    276251                return 
    277                 datatype.equals(XMLSchema.INTEGER) || 
    278                 datatype.equals(XMLSchema.LONG) || 
    279                 datatype.equals(XMLSchema.INT) || 
    280                 datatype.equals(XMLSchema.SHORT) || 
    281                 datatype.equals(XMLSchema.BYTE) || 
    282                 datatype.equals(XMLSchema.NON_POSITIVE_INTEGER) || 
    283                 datatype.equals(XMLSchema.NEGATIVE_INTEGER) || 
    284                 datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER) || 
    285                 datatype.equals(XMLSchema.POSITIVE_INTEGER) || 
    286                 datatype.equals(XMLSchema.UNSIGNED_LONG) || 
    287                 datatype.equals(XMLSchema.UNSIGNED_INT) || 
    288                 datatype.equals(XMLSchema.UNSIGNED_SHORT) || 
    289                 datatype.equals(XMLSchema.UNSIGNED_BYTE); 
     252                XMLSchema.INTEGER.equals(datatype) || 
     253                XMLSchema.LONG.equals(datatype) || 
     254                XMLSchema.INT.equals(datatype) || 
     255                XMLSchema.SHORT.equals(datatype) || 
     256                XMLSchema.BYTE.equals(datatype) || 
     257                XMLSchema.NON_POSITIVE_INTEGER.equals(datatype) || 
     258                XMLSchema.NEGATIVE_INTEGER.equals(datatype) || 
     259                XMLSchema.NON_NEGATIVE_INTEGER.equals(datatype) || 
     260                XMLSchema.POSITIVE_INTEGER.equals(datatype) || 
     261                XMLSchema.UNSIGNED_LONG.equals(datatype) || 
     262                XMLSchema.UNSIGNED_INT.equals(datatype) || 
     263                XMLSchema.UNSIGNED_SHORT.equals(datatype) || 
     264                XMLSchema.UNSIGNED_BYTE.equals(datatype); 
    290265        } 
    291266 
     
    295270        public static boolean isFloatingPointDatatype(URI datatype) { 
    296271                return  
    297                 datatype.equals(XMLSchema.FLOAT) ||  
    298                 datatype.equals(XMLSchema.DOUBLE); 
     272                XMLSchema.FLOAT.equals(datatype) ||  
     273                XMLSchema.DOUBLE.equals(datatype); 
    299274        } 
    300275 
     
    309284        public static boolean isCalendarDatatype(URI datatype) { 
    310285                return 
    311                 datatype.equals(XMLSchema.DATETIME) || 
    312                 datatype.equals(XMLSchema.DATE)|| 
    313                 datatype.equals(XMLSchema.TIME) || 
    314                 datatype.equals(XMLSchema.GYEARMONTH) || 
    315                 datatype.equals(XMLSchema.GMONTHDAY) || 
    316                 datatype.equals(XMLSchema.GYEAR) || 
    317                 datatype.equals(XMLSchema.GMONTH) || 
    318                 datatype.equals(XMLSchema.GDAY); 
    319  
    320         } 
    321  
    322         /** 
    323          * Checks whether the supplied datatype is ordered. The values of an ordered 
    324          * datatype can be compared to eachother using operators like <tt>&lt;</tt> 
    325          * and <tt>&gt;</tt>. 
    326          */ 
    327         public static boolean isOrderedDatatype(URI datatype) { 
    328                 return isNumericDatatype(datatype) || isCalendarDatatype(datatype); 
    329         } 
    330  
    331         /*----------------* 
    332          * Value checking * 
    333          *----------------*/ 
    334  
    335         public static boolean isValidValue(String value, URI datatype) { 
    336                 boolean result = true; 
    337  
    338                 if (datatype.equals(XMLSchema.DECIMAL)) { 
    339                         result = isValidDecimal(value); 
    340                 } 
    341                 else if (datatype.equals(XMLSchema.INTEGER)) { 
    342                         result = isValidInteger(value); 
    343                 } 
    344                 else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
    345                         result = isValidNegativeInteger(value); 
    346                 } 
    347                 else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
    348                         result = isValidNonPositiveInteger(value); 
    349                 } 
    350                 else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
    351                         result = isValidNonNegativeInteger(value); 
    352                 } 
    353                 else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
    354                         result = isValidPositiveInteger(value); 
    355                 } 
    356                 else if (datatype.equals(XMLSchema.LONG)) { 
    357                         result = isValidLong(value); 
    358                 } 
    359                 else if (datatype.equals(XMLSchema.INT)) { 
    360                         result = isValidInt(value); 
    361                 } 
    362                 else if (datatype.equals(XMLSchema.SHORT)) { 
    363                         result = isValidShort(value); 
    364                 } 
    365                 else if (datatype.equals(XMLSchema.BYTE)) { 
    366                         result = isValidByte(value); 
    367                 } 
    368                 else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
    369                         result = isValidUnsignedLong(value); 
    370                 } 
    371                 else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
    372                         result = isValidUnsignedInt(value); 
    373                 } 
    374                 else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
    375                         result = isValidUnsignedShort(value); 
    376                 } 
    377                 else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
    378                         result = isValidUnsignedByte(value); 
    379                 } 
    380                 else if (datatype.equals(XMLSchema.FLOAT)) { 
    381                         result = isValidFloat(value); 
    382                 } 
    383                 else if (datatype.equals(XMLSchema.DOUBLE)) { 
    384                         result = isValidDouble(value); 
    385                 } 
    386                 else if (datatype.equals(XMLSchema.BOOLEAN)) { 
    387                         result = isValidBoolean(value); 
    388                 } 
    389                 else if (datatype.equals(XMLSchema.DATETIME)) { 
    390                         result = isValidDateTime(value); 
    391                 } 
    392  
    393                 return result; 
    394         } 
    395  
    396         public static boolean isValidDecimal(String value) { 
    397                 try { 
    398                         normalizeDecimal(value); 
    399                         return true; 
    400                 } 
    401                 catch (IllegalArgumentException e) { 
    402                         return false; 
    403                 } 
    404         } 
    405  
    406         public static boolean isValidInteger(String value) { 
    407                 try { 
    408                         normalizeInteger(value); 
    409                         return true; 
    410                 } 
    411                 catch (IllegalArgumentException e) { 
    412                         return false; 
    413                 } 
    414         } 
    415  
    416         public static boolean isValidNegativeInteger(String value) { 
    417                 try { 
    418                         normalizeNegativeInteger(value); 
    419                         return true; 
    420                 } 
    421                 catch (IllegalArgumentException e) { 
    422                         return false; 
    423                 } 
    424         } 
    425  
    426         public static boolean isValidNonPositiveInteger(String value) { 
    427                 try { 
    428                         normalizeNonPositiveInteger(value); 
    429                         return true; 
    430                 } 
    431                 catch (IllegalArgumentException e) { 
    432                         return false; 
    433                 } 
    434         } 
    435  
    436         public static boolean isValidNonNegativeInteger(String value) { 
    437                 try { 
    438                         normalizeNonNegativeInteger(value); 
    439                         return true; 
    440                 } 
    441                 catch (IllegalArgumentException e) { 
    442                         return false; 
    443                 } 
    444         } 
    445  
    446         public static boolean isValidPositiveInteger(String value) { 
    447                 try { 
    448                         normalizePositiveInteger(value); 
    449                         return true; 
    450                 } 
    451                 catch (IllegalArgumentException e) { 
    452                         return false; 
    453                 } 
    454         } 
    455         public static boolean isValidLong(String value) { 
    456                 try { 
    457                         normalizeLong(value); 
    458                         return true; 
    459                 } 
    460                 catch (IllegalArgumentException e) { 
    461                         return false; 
    462                 } 
    463         } 
    464  
    465         public static boolean isValidInt(String value) { 
    466                 try { 
    467                         normalizeInt(value); 
    468                         return true; 
    469                 } 
    470                 catch (IllegalArgumentException e) { 
    471                         return false; 
    472                 } 
    473         } 
    474  
    475         public static boolean isValidShort(String value) { 
    476                 try { 
    477                         normalizeShort(value); 
    478                         return true; 
    479                 } 
    480                 catch (IllegalArgumentException e) { 
    481                         return false; 
    482                 } 
    483         } 
    484  
    485         public static boolean isValidByte(String value) { 
    486                 try { 
    487                         normalizeByte(value); 
    488                         return true; 
    489                 } 
    490                 catch (IllegalArgumentException e) { 
    491                         return false; 
    492                 } 
    493         } 
    494  
    495         public static boolean isValidUnsignedLong(String value) { 
    496                 try { 
    497                         normalizeUnsignedLong(value); 
    498                         return true; 
    499                 } 
    500                 catch (IllegalArgumentException e) { 
    501                         return false; 
    502                 } 
    503         } 
    504  
    505         public static boolean isValidUnsignedInt(String value) { 
    506                 try { 
    507                         normalizeUnsignedInt(value); 
    508                         return true; 
    509                 } 
    510                 catch (IllegalArgumentException e) { 
    511                         return false; 
    512                 } 
    513         } 
    514  
    515         public static boolean isValidUnsignedShort(String value) { 
    516                 try { 
    517                         normalizeUnsignedShort(value); 
    518                         return true; 
    519                 } 
    520                 catch (IllegalArgumentException e) { 
    521                         return false; 
    522                 } 
    523         } 
    524  
    525         public static boolean isValidUnsignedByte(String value) { 
    526                 try { 
    527                         normalizeUnsignedByte(value); 
    528                         return true; 
    529                 } 
    530                 catch (IllegalArgumentException e) { 
    531                         return false; 
    532                 } 
    533         } 
    534  
    535         public static boolean isValidFloat(String value) { 
    536                 try { 
    537                         normalizeFloat(value); 
    538                         return true; 
    539                 } 
    540                 catch (IllegalArgumentException e) { 
    541                         return false; 
    542                 } 
    543         } 
    544  
    545         public static boolean isValidDouble(String value) { 
    546                 try { 
    547                         normalizeDouble(value); 
    548                         return true; 
    549                 } 
    550                 catch (IllegalArgumentException e) { 
    551                         return false; 
    552                 } 
    553         } 
    554  
    555         public static boolean isValidBoolean(String value) { 
    556                 try { 
    557                         normalizeBoolean(value); 
    558                         return true; 
    559                 } 
    560                 catch (IllegalArgumentException e) { 
    561                         return false; 
    562                 } 
    563         } 
    564  
    565         public static boolean isValidDateTime(String value) { 
    566                 try { 
    567                         @SuppressWarnings("unused") 
    568                         XMLDateTime dt = new XMLDateTime(value); 
    569                         return true; 
    570                 } 
    571                 catch (IllegalArgumentException e) { 
    572                         return false; 
    573                 } 
    574         } 
    575  
    576         /*---------------------* 
    577          * Value normalization * 
    578          *---------------------*/ 
    579  
    580         /** 
    581          * Normalizes the supplied value according to the normalization rules for the 
    582          * supplied datatype. 
    583          *  
    584          * @param value 
    585          *        The value to normalize. 
    586          * @param datatype 
    587          *        The value's datatype. 
    588          * @return The normalized value if there are any (supported) normalization 
    589          *         rules for the supplied datatype, or the original supplied value 
    590          *         otherwise. 
    591          * @throws IllegalArgumentException 
    592          *         If the supplied value is illegal considering the supplied 
    593          *         datatype. 
    594          */ 
    595         public static String normalize(String value, URI datatype) { 
    596                 String result = value; 
    597  
    598                 if (datatype.equals(XMLSchema.DECIMAL)) { 
    599                         result = normalizeDecimal(value); 
    600                 } 
    601                 else if (datatype.equals(XMLSchema.INTEGER)) { 
    602                         result = normalizeInteger(value); 
    603                 } 
    604                 else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
    605                         result = normalizeNegativeInteger(value); 
    606                 } 
    607                 else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
    608                         result = normalizeNonPositiveInteger(value); 
    609                 } 
    610                 else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
    611                         result = normalizeNonNegativeInteger(value); 
    612                 } 
    613                 else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
    614                         result = normalizePositiveInteger(value); 
    615                 } 
    616                 else if (datatype.equals(XMLSchema.LONG)) { 
    617                         result = normalizeLong(value); 
    618                 } 
    619                 else if (datatype.equals(XMLSchema.INT)) { 
    620                         result = normalizeInt(value); 
    621                 } 
    622                 else if (datatype.equals(XMLSchema.SHORT)) { 
    623                         result = normalizeShort(value); 
    624                 } 
    625                 else if (datatype.equals(XMLSchema.BYTE)) { 
    626                         result = normalizeByte(value); 
    627                 } 
    628                 else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
    629                         result = normalizeUnsignedLong(value); 
    630                 } 
    631                 else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
    632                         result = normalizeUnsignedInt(value); 
    633                 } 
    634                 else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
    635                         result = normalizeUnsignedShort(value); 
    636                 } 
    637                 else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
    638                         result = normalizeUnsignedByte(value); 
    639                 } 
    640                 else if (datatype.equals(XMLSchema.FLOAT)) { 
    641                         result = normalizeFloat(value); 
    642                 } 
    643                 else if (datatype.equals(XMLSchema.DOUBLE)) { 
    644                         result = normalizeDouble(value); 
    645                 } 
    646                 else if (datatype.equals(XMLSchema.BOOLEAN)) { 
    647                         result = normalizeBoolean(value); 
    648                 } 
    649                 else if (datatype.equals(XMLSchema.DATETIME)) { 
    650                         result = normalizeDateTime(value); 
    651                 } 
    652  
    653                 return result; 
    654         } 
    655  
    656         /** 
    657          * Normalizes a boolean value to its canonical representation. More 
    658          * specifically, the values <tt>1</tt> and <tt>0</tt> will be normalized 
    659          * to the canonical values <tt>true</tt> and <tt>false</tt>, 
    660          * respectively. Supplied canonical values will remain as is. 
    661          *  
    662          * @param value 
    663          *        The boolean value to normalize. 
    664          * @return The normalized value. 
    665          * @throws IllegalArgumentException 
    666          *         If the supplied value is not a legal boolean. 
    667          */ 
    668         public static String normalizeBoolean(String value) { 
    669                 value = collapseWhiteSpace(value); 
    670  
    671                 if (value.equals("1")) { 
    672                         return "true"; 
    673                 } 
    674                 else if (value.equals("0")) { 
    675                         return "false"; 
    676                 } 
    677                 else if (value.equals("true") || value.equals("false")) { 
    678                         return value; 
    679                 } 
    680                 else { 
    681                         throw new IllegalArgumentException("Not a legal boolean value: " + value); 
    682                 } 
    683         } 
    684  
    685         /** 
    686          * Normalizes a decimal to its canonical representation. For example: 
    687          * <tt>120</tt> becomes <tt>120.0</tt>, <tt>+.3</tt> becomes 
    688          * <tt>0.3</tt>, <tt>00012.45000</tt> becomes <tt>12.45</tt> and 
    689          * <tt>-.0</tt> becomes <tt>0.0</tt>. 
    690          *  
    691          * @param decimal 
    692          *        The decimal to normalize. 
    693          * @return The canonical representation of <tt>decimal</tt>. 
    694          * @throws IllegalArgumentException 
    695          *         If one of the supplied strings is not a legal decimal. 
    696          */ 
    697         public static String normalizeDecimal(String decimal) { 
    698                 decimal = collapseWhiteSpace(decimal); 
    699  
    700                 String errMsg = "Not a legal decimal: " + decimal; 
    701  
    702                 int decLength = decimal.length(); 
    703                 StringBuilder result = new StringBuilder(decLength + 2); 
    704  
    705                 if (decLength == 0) { 
    706                         throwIAE(errMsg); 
    707                 } 
    708  
    709                 boolean isZeroPointZero = true; 
    710  
    711                 // process any sign info 
    712                 int idx = 0; 
    713                 if (decimal.charAt(idx) == '-') { 
    714                         result.append('-'); 
    715                         idx++; 
    716                 } 
    717                 else if (decimal.charAt(idx) == '+') { 
    718                         idx++; 
    719                 } 
    720  
    721                 if (idx == decLength) { 
    722                         throwIAE(errMsg); 
    723                 } 
    724  
    725                 // skip any leading zeros 
    726                 while (idx < decLength && decimal.charAt(idx) == '0') { 
    727                         idx++; 
    728                 } 
    729  
    730                 // Process digits before the dot 
    731                 if (idx == decLength) { 
    732                         // decimal consists of zeros only 
    733                         result.append('0'); 
    734                 } 
    735                 else if (idx < decLength && decimal.charAt(idx) == '.') { 
    736                         // no non-zero digit before the dot 
    737                         result.append('0'); 
    738                 } 
    739                 else { 
    740                         isZeroPointZero = false; 
    741  
    742                         // Copy any digits before the dot 
    743                         while (idx < decLength) { 
    744                                 char c = decimal.charAt(idx); 
    745                                 if (c == '.') { 
    746                                         break; 
    747                                 } 
    748                                 if (!isDigit(c)) { 
    749                                         throwIAE(errMsg); 
    750                                 } 
    751                                 result.append(c); 
    752                                 idx++; 
    753                         } 
    754                 } 
    755  
    756                 result.append('.'); 
    757  
    758                 // Process digits after the dot 
    759                 if (idx == decLength) { 
    760                         // No dot was found in the decimal 
    761                         result.append('0'); 
    762                 } 
    763                 else { 
    764                         idx++; 
    765  
    766                         // search last non-zero digit 
    767                         int lastIdx = decLength - 1; 
    768                         while (lastIdx >= 0 && decimal.charAt(lastIdx) == '0') { 
    769                                 lastIdx--; 
    770                         } 
    771  
    772                         if (idx > lastIdx) { 
    773                                 // No non-zero digits found 
    774                                 result.append('0'); 
    775                         } 
    776                         else { 
    777                                 isZeroPointZero = false; 
    778  
    779                                 while (idx <= lastIdx) { 
    780                                         char c = decimal.charAt(idx); 
    781                                         if (!isDigit(c)) { 
    782                                                 throwIAE(errMsg); 
    783                                         } 
    784                                         result.append(c); 
    785                                         idx++; 
    786                                 } 
    787                         } 
    788                 } 
    789  
    790                 if (isZeroPointZero) { 
    791                         // Make sure we don't return "-0.0" 
    792                         return "0.0"; 
    793                 } 
    794                 else { 
    795                         return result.toString(); 
    796                 } 
    797         } 
    798  
    799         /** 
    800          * Normalizes an integer to its canonical representation. For example: 
    801          * <tt>+120</tt> becomes <tt>120</tt> and <tt>00012</tt> becomes 
    802          * <tt>12</tt>. 
    803          *  
    804          * @param value 
    805          *        The value to normalize. 
    806          * @return The canonical representation of <tt>value</tt>. 
    807          * @throws IllegalArgumentException 
    808          *         If the supplied value is not a legal integer. 
    809          */ 
    810         public static String normalizeInteger(String value) { 
    811                 return normalizeIntegerValue(value, null, null); 
    812         } 
    813  
    814         /** 
    815          * Normalizes an xsd:negativeInteger. 
    816          */ 
    817         public static String normalizeNegativeInteger(String value) { 
    818                 return normalizeIntegerValue(value, null, "-1"); 
    819         } 
    820  
    821         /** 
    822          * Normalizes an xsd:nonPositiveInteger. 
    823          */ 
    824         public static String normalizeNonPositiveInteger(String value) { 
    825                 return normalizeIntegerValue(value, null, "0"); 
    826         } 
    827  
    828         /** 
    829          * Normalizes an xsd:nonNegativeInteger. 
    830          */ 
    831         public static String normalizeNonNegativeInteger(String value) { 
    832                 return normalizeIntegerValue(value, "0", null); 
    833         } 
    834  
    835         /** 
    836          * Normalizes an xsd:positiveInteger. 
    837          */ 
    838         public static String normalizePositiveInteger(String value) { 
    839                 return normalizeIntegerValue(value, "1", null); 
    840         } 
    841  
    842         /** 
    843          * Normalizes an xsd:long. 
    844          */ 
    845         public static String normalizeLong(String value) { 
    846                 return normalizeIntegerValue(value, "-9223372036854775808", "9223372036854775807"); 
    847         } 
    848  
    849         /** 
    850          * Normalizes an xsd:int. 
    851          */ 
    852         public static String normalizeInt(String value) { 
    853                 return normalizeIntegerValue(value, "-2147483648", "2147483647"); 
    854         } 
    855  
    856         /** 
    857          * Normalizes an xsd:short. 
    858          */ 
    859         public static String normalizeShort(String value) { 
    860                 return normalizeIntegerValue(value, "-32768", "32767"); 
    861         } 
    862  
    863         /** 
    864          * Normalizes an xsd:byte. 
    865          */ 
    866         public static String normalizeByte(String value) { 
    867                 return normalizeIntegerValue(value, "-128", "127"); 
    868         } 
    869  
    870         /** 
    871          * Normalizes an xsd:unsignedLong. 
    872          */ 
    873         public static String normalizeUnsignedLong(String value) { 
    874                 return normalizeIntegerValue(value, "0", "18446744073709551615"); 
    875         } 
    876  
    877         /** 
    878          * Normalizes an xsd:unsignedInt. 
    879          */ 
    880         public static String normalizeUnsignedInt(String value) { 
    881                 return normalizeIntegerValue(value, "0", "4294967295"); 
    882         } 
    883  
    884         /** 
    885          * Normalizes an xsd:unsignedShort. 
    886          */ 
    887         public static String normalizeUnsignedShort(String value) { 
    888                 return normalizeIntegerValue(value, "0", "65535"); 
    889         } 
    890  
    891         /** 
    892          * Normalizes an xsd:unsignedByte. 
    893          */ 
    894         public static String normalizeUnsignedByte(String value) { 
    895                 return normalizeIntegerValue(value, "0", "255"); 
    896         } 
    897  
    898         /** 
    899          * Normalizes an integer to its canonical representation and checks that the 
    900          * value is in the range [minValue, maxValue]. 
    901          */ 
    902         private static String normalizeIntegerValue(String integer, String minValue, String maxValue) { 
    903                 integer = collapseWhiteSpace(integer); 
    904  
    905                 String errMsg = "Not a legal integer: " + integer; 
    906  
    907                 int intLength = integer.length(); 
    908  
    909                 if (intLength == 0) { 
    910                         throwIAE(errMsg); 
    911                 } 
    912  
    913                 int idx = 0; 
    914  
    915                 // process any sign info 
    916                 boolean isNegative = false; 
    917                 if (integer.charAt(idx) == '-') { 
    918                         isNegative = true; 
    919                         idx++; 
    920                 } 
    921                 else if (integer.charAt(idx) == '+') { 
    922                         idx++; 
    923                 } 
    924  
    925                 if (idx == intLength) { 
    926                         throwIAE(errMsg); 
    927                 } 
    928  
    929                 if (integer.charAt(idx) == '0' && idx < intLength - 1) { 
    930                         // integer starts with a zero followed by more characters, 
    931                         // skip any leading zeros 
    932                         idx++; 
    933                         while (idx < intLength - 1 && integer.charAt(idx) == '0') { 
    934                                 idx++; 
    935                         } 
    936                 } 
    937  
    938                 String norm = integer.substring(idx); 
    939  
    940                 // Check that all characters in 'norm' are digits 
    941                 for (int i = 0; i < norm.length(); i++) { 
    942                         if (!isDigit(norm.charAt(i))) { 
    943                                 throwIAE(errMsg); 
    944                         } 
    945                 } 
    946  
    947                 if (isNegative && norm.charAt(0) != '0') { 
    948                         norm = "-" + norm; 
    949                 } 
    950  
    951                 // Check lower and upper bounds, if applicable 
    952                 if (minValue != null) { 
    953                         if (compareCanonicalIntegers(norm, minValue) < 0) { 
    954                                 throwIAE("Value smaller than minimum value"); 
    955                         } 
    956                 } 
    957                 if (maxValue != null) { 
    958                         if (compareCanonicalIntegers(norm, maxValue) > 0) { 
    959                                 throwIAE("Value larger than maximum value"); 
    960                         } 
    961                 } 
    962  
    963                 return norm; 
    964         } 
    965  
    966         /** 
    967          * Normalizes a float to its canonical representation. 
    968          *  
    969          * @param value 
    970          *        The value to normalize. 
    971          * @return The canonical representation of <tt>value</tt>. 
    972          * @throws IllegalArgumentException 
    973          *         If the supplied value is not a legal float. 
    974          */ 
    975         public static String normalizeFloat(String value) { 
    976                 return normalizeFPNumber(value, "-16777215.0", "16777215.0", "-149", "104"); 
    977         } 
    978  
    979         /** 
    980          * Normalizes a double to its canonical representation. 
    981          *  
    982          * @param value 
    983          *        The value to normalize. 
    984          * @return The canonical representation of <tt>value</tt>. 
    985          * @throws IllegalArgumentException 
    986          *         If the supplied value is not a legal double. 
    987          */ 
    988         public static String normalizeDouble(String value) { 
    989                 return normalizeFPNumber(value, "-9007199254740991.0", "9007199254740991.0", "-1075", "970"); 
    990         } 
    991  
    992         /** 
    993          * Normalizes a floating point number to its canonical representation. 
    994          *  
    995          * @param value 
    996          *        The value to normalize. 
    997          * @return The canonical representation of <tt>value</tt>. 
    998          * @throws IllegalArgumentException 
    999          *         If the supplied value is not a legal floating point number. 
    1000          */ 
    1001         public static String normalizeFPNumber(String value) { 
    1002                 return normalizeFPNumber(value, null, null, null, null); 
    1003         } 
    1004  
    1005         /** 
    1006          * Normalizes a floating point number to its canonical representation. 
    1007          *  
    1008          * @param value 
    1009          *        The value to normalize. 
    1010          * @param minMantissa 
    1011          *        A normalized decimal indicating the lowest value that the mantissa 
    1012          *        may have. 
    1013          * @param maxMantissa 
    1014          *        A normalized decimal indicating the highest value that the mantissa 
    1015          *        may have. 
    1016          * @param minExponent 
    1017          *        A normalized integer indicating the lowest value that the exponent 
    1018          *        may have. 
    1019          * @param maxExponent 
    1020          *        A normalized integer indicating the highest value that the exponent 
    1021          *        may have. 
    1022          * @return The canonical representation of <tt>value</tt>. 
    1023          * @throws IllegalArgumentException 
    1024          *         If the supplied value is not a legal floating point number. 
    1025          */ 
    1026         private static String normalizeFPNumber( 
    1027                         String value, 
    1028                         String minMantissa, String maxMantissa, 
    1029                         String minExponent, String maxExponent) 
    1030         { 
    1031                 value = collapseWhiteSpace(value); 
    1032  
    1033                 // handle special values 
    1034                 if (value.equals("INF") || value.equals("-INF") || value.equals("NaN")) { 
    1035                         return value; 
    1036                 } 
    1037  
    1038                 // Search for the exponent character E or e 
    1039                 int eIdx = value.indexOf('E'); 
    1040                 if (eIdx == -1) { 
    1041                         // try lower case 
    1042                         eIdx = value.indexOf('e'); 
    1043                 } 
    1044  
    1045                 // Extract mantissa and exponent 
    1046                 String mantissa, exponent; 
    1047                 if (eIdx == -1) { 
    1048                         mantissa = normalizeDecimal(value); 
    1049                         exponent = "0"; 
    1050                 } 
    1051                 else { 
    1052                         mantissa = normalizeDecimal(value.substring(0, eIdx)); 
    1053                         exponent = normalizeInteger(value.substring(eIdx + 1)); 
    1054                 } 
    1055  
    1056                 // Check lower and upper bounds, if applicable 
    1057                 if (minMantissa != null) { 
    1058                         if (compareCanonicalDecimals(mantissa, minMantissa) < 0) { 
    1059                                 throwIAE("Mantissa smaller than minimum value (" + minMantissa + ")"); 
    1060                         } 
    1061                 } 
    1062                 if (maxMantissa != null) { 
    1063                         if (compareCanonicalDecimals(mantissa, maxMantissa) > 0) { 
    1064                                 throwIAE("Mantissa larger than maximum value (" + maxMantissa + ")"); 
    1065                         } 
    1066                 } 
    1067                 if (minExponent != null) { 
    1068                         if (compareCanonicalIntegers(exponent, minExponent) < 0) { 
    1069                                 throwIAE("Exponent smaller than minimum value (" + minExponent + ")"); 
    1070                         } 
    1071                 } 
    1072                 if (maxExponent != null) { 
    1073                         if (compareCanonicalIntegers(exponent, maxExponent) > 0) { 
    1074                                 throwIAE("Exponent larger than maximum value (" + maxExponent + ")"); 
    1075                         } 
    1076                 } 
    1077  
    1078                 // Normalize mantissa to one non-zero digit before the dot 
    1079                 int shift = 0; 
    1080  
    1081                 int dotIdx = mantissa.indexOf('.'); 
    1082                 int digitCount = dotIdx; 
    1083                 if (mantissa.charAt(0) == '-') { 
    1084                         digitCount--; 
    1085                 } 
    1086  
    1087                 if (digitCount > 1) { 
    1088                         // more than one digit before the dot, e.g 123.45, -10.0 or 100.0 
    1089                         StringBuilder sb = new StringBuilder(mantissa.length()); 
    1090                         int firstDigitIdx = 0; 
    1091                         if (mantissa.charAt(0) == '-') { 
    1092                                 sb.append('-'); 
    1093                                 firstDigitIdx = 1; 
    1094                         } 
    1095                         sb.append(mantissa.charAt(firstDigitIdx)); 
    1096                         sb.append('.'); 
    1097                         sb.append(mantissa.substring(firstDigitIdx + 1, dotIdx)); 
    1098                         sb.append(mantissa.substring(dotIdx + 1)); 
    1099  
    1100                         mantissa = sb.toString(); 
    1101  
    1102                         // Check if the mantissa has excessive trailing zeros. 
    1103                         // For example, 100.0 will be normalize to 1.000 and 
    1104                         // -10.0 to -1.00. 
    1105                         int nonZeroIdx = mantissa.length() - 1; 
    1106                         while (nonZeroIdx >= 3 && mantissa.charAt(nonZeroIdx) == '0') { 
    1107                                 nonZeroIdx--; 
    1108                         } 
    1109  
    1110                         if (nonZeroIdx < 3 && mantissa.charAt(0) == '-') { 
    1111                                 nonZeroIdx++; 
    1112                         } 
    1113  
    1114                         if (nonZeroIdx < mantissa.length() - 1) { 
    1115                                 mantissa = mantissa.substring(0, nonZeroIdx + 1); 
    1116                         } 
    1117  
    1118                         shift = 1 - digitCount; 
    1119                 } 
    1120                 else if (mantissa.startsWith("0.") || mantissa.startsWith("-0.")) { 
    1121                         // Example mantissas: 0.0, -0.1, 0.00345 and 0.09 
    1122                         // search first non-zero digit 
    1123                         int nonZeroIdx = 2; 
    1124                         while (nonZeroIdx < mantissa.length() && mantissa.charAt(nonZeroIdx) == '0') { 
    1125                                 nonZeroIdx++; 
    1126                         } 
    1127  
    1128                         // 0.0 does not need any normalization: 
    1129                         if (nonZeroIdx < mantissa.length()) { 
    1130                                 StringBuilder sb = new StringBuilder(mantissa.length()); 
    1131                                 sb.append(mantissa.charAt(nonZeroIdx)); 
    1132                                 sb.append('.'); 
    1133                                 if (nonZeroIdx == mantissa.length() - 1) { 
    1134                                         // There was only one non-zero digit, e.g. as in 0.09 
    1135                                         sb.append('0'); 
    1136                                 } 
    1137                                 else { 
    1138                                         sb.append(mantissa.substring(nonZeroIdx + 1)); 
    1139                                 } 
    1140  
    1141                                 mantissa = sb.toString(); 
    1142                                 shift = nonZeroIdx - 1; 
    1143                         } 
    1144                 } 
    1145  
    1146                 if (shift != 0) { 
    1147                         try { 
    1148                                 int exp = Integer.parseInt(exponent); 
    1149                                 exponent = String.valueOf(exp - shift); 
    1150                         } 
    1151                         catch (NumberFormatException e) { 
    1152                                 throw new RuntimeException("NumberFormatException: " + e.getMessage()); 
    1153                         } 
    1154                 } 
    1155  
    1156                 return mantissa + "E" + exponent; 
    1157         } 
    1158  
    1159         /** 
    1160          * Normalizes an xsd:dateTime. 
    1161          *  
    1162          * @param value 
    1163          *        The value to normalize. 
    1164          * @return The normalized value. 
    1165          * @throws IllegalArgumentException 
    1166          *         If the supplied value is not a legal xsd:dateTime value. 
    1167          */ 
    1168         public static String normalizeDateTime(String value) { 
    1169                 XMLDateTime dt = new XMLDateTime(value); 
    1170                 dt.normalize(); 
    1171                 return dt.toString(); 
    1172         } 
    1173  
    1174         /** 
    1175          * Replaces all occurences of #x9 (tab), #xA (line feed) and #xD (carriage 
    1176          * return) with #x20 (space), as specified for whiteSpace facet 
    1177          * <tt>replace</tt>. 
    1178          */ 
    1179         // private static String replaceWhiteSpace(String s) { 
    1180         // s = StringUtil.gsub("\t", " ", s); 
    1181         // s = StringUtil.gsub("\r", " ", s); 
    1182         // s = StringUtil.gsub("\n", " ", s); 
    1183         // return s; 
    1184         // } 
    1185  
    1186         /** 
    1187          * Replaces all contiguous sequences of #x9 (tab), #xA (line feed) and #xD 
    1188          * (carriage return) with a single #x20 (space) character, and removes any 
    1189          * leading and trailing whitespace characters, as specified for whiteSpace 
    1190          * facet <tt>collapse</tt>. 
    1191          */ 
    1192         public static String collapseWhiteSpace(String s) { 
    1193                 StringBuilder sb = new StringBuilder(s.length()); 
    1194  
    1195                 StringTokenizer st = new StringTokenizer(s, "\t\r\n "); 
    1196  
    1197                 if (st.hasMoreTokens()) { 
    1198                         sb.append(st.nextToken()); 
    1199                 } 
    1200  
    1201                 while (st.hasMoreTokens()) { 
    1202                         sb.append(' ').append(st.nextToken()); 
    1203                 } 
    1204  
    1205                 return sb.toString(); 
    1206         } 
    1207  
    1208         /*------------------* 
    1209          * Value comparison * 
    1210          *------------------*/ 
    1211  
    1212         public static int compare(String value1, String value2, URI datatype) { 
    1213                 if (datatype.equals(XMLSchema.DECIMAL)) { 
    1214                         return compareDecimals(value1, value2); 
    1215                 } 
    1216                 else if (datatype.equals(XMLSchema.INTEGER)) { 
    1217                         return compareIntegers(value1, value2); 
    1218                 } 
    1219                 else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
    1220                         return compareNegativeIntegers(value1, value2); 
    1221                 } 
    1222                 else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
    1223                         return compareNonPositiveIntegers(value1, value2); 
    1224                 } 
    1225                 else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
    1226                         return compareNonNegativeIntegers(value1, value2); 
    1227                 } 
    1228                 else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
    1229                         return comparePositiveIntegers(value1, value2); 
    1230                 } 
    1231                 else if (datatype.equals(XMLSchema.LONG)) { 
    1232                         return compareLongs(value1, value2); 
    1233                 } 
    1234                 else if (datatype.equals(XMLSchema.INT)) { 
    1235                         return compareInts(value1, value2); 
    1236                 } 
    1237                 else if (datatype.equals(XMLSchema.SHORT)) { 
    1238                         return compareShorts(value1, value2); 
    1239                 } 
    1240                 else if (datatype.equals(XMLSchema.BYTE)) { 
    1241                         return compareBytes(value1, value2); 
    1242                 } 
    1243                 else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
    1244                         return compareUnsignedLongs(value1, value2); 
    1245                 } 
    1246                 else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
    1247                         return compareUnsignedInts(value1, value2); 
    1248                 } 
    1249                 else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
    1250                         return compareUnsignedShorts(value1, value2); 
    1251                 } 
    1252                 else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
    1253                         return compareUnsignedBytes(value1, value2); 
    1254                 } 
    1255                 else if (datatype.equals(XMLSchema.FLOAT)) { 
    1256                         return compareFloats(value1, value2); 
    1257                 } 
    1258                 else if (datatype.equals(XMLSchema.DOUBLE)) { 
    1259                         return compareDoubles(value1, value2); 
    1260                 } 
    1261                 else if (datatype.equals(XMLSchema.DATETIME)) { 
    1262                         return compareDateTime(value1, value2); 
    1263                 } 
    1264                 else { 
    1265                         throw new IllegalArgumentException("datatype is not ordered"); 
    1266                 } 
    1267         } 
    1268  
    1269         /** 
    1270          * Compares two decimals to eachother. 
    1271          *  
    1272          * @return A negative number if <tt>dec1</tt> is smaller than <tt>dec2</tt>, 
    1273          *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
    1274          *         <tt>dec1</tt> is larger than <tt>dec2</tt>. 
    1275          * @throws IllegalArgumentException 
    1276          *         If one of the supplied strings is not a legal decimal. 
    1277          */ 
    1278         public static int compareDecimals(String dec1, String dec2) { 
    1279                 dec1 = normalizeDecimal(dec1); 
    1280                 dec2 = normalizeDecimal(dec2); 
    1281  
    1282                 return compareCanonicalDecimals(dec1, dec2); 
    1283         } 
    1284  
    1285         /** 
    1286          * Compares two canonical decimals to eachother. 
    1287          *  
    1288          * @return A negative number if <tt>dec1</tt> is smaller than <tt>dec2</tt>, 
    1289          *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
    1290          *         <tt>dec1</tt> is larger than <tt>dec2</tt>. The result is 
    1291          *         undefined when one or both of the arguments is not a canonical 
    1292          *         decimal. 
    1293          * @throws IllegalArgumentException 
    1294          *         If one of the supplied strings is not a legal decimal. 
    1295          */ 
    1296         public static int compareCanonicalDecimals(String dec1, String dec2) { 
    1297                 if (dec1.equals(dec2)) { 
    1298                         return 0; 
    1299                 } 
    1300  
    1301                 // Check signs 
    1302                 if (dec1.charAt(0) == '-' && dec2.charAt(0) != '-') { 
    1303                         // dec1 is negative, dec2 is not 
    1304                         return -1; 
    1305                 } 
    1306                 if (dec2.charAt(0) == '-' && dec1.charAt(0) != '-') { 
    1307                         // dec2 is negative, dec1 is not 
    1308                         return 1; 
    1309                 } 
    1310  
    1311                 int dotIdx1 = dec1.indexOf('.'); 
    1312                 int dotIdx2 = dec2.indexOf('.'); 
    1313  
    1314                 // The decimal with the most digits before the dot is the largest 
    1315                 int result = dotIdx1 - dotIdx2; 
    1316  
    1317                 if (result == 0) { 
    1318                         // equal number of digits before the dot, compare them 
    1319                         for (int i = 0; result == 0 && i < dotIdx1; i++) { 
    1320                                 result = dec1.charAt(i) - dec2.charAt(i); 
    1321                         } 
    1322  
    1323                         // Continue comparing digits after the dot if necessary 
    1324                         int dec1Length = dec1.length(); 
    1325                         int dec2Length = dec2.length(); 
    1326                         int lastIdx = dec1Length <= dec2Length ? dec1Length : dec2Length; 
    1327  
    1328                         for (int i = dotIdx1 + 1; result == 0 && i < lastIdx; i++) { 
    1329                                 result = dec1.charAt(i) - dec2.charAt(i); 
    1330                         } 
    1331  
    1332                         // Still equal? The decimal with the most digits is the largest 
    1333                         if (result == 0) { 
    1334                                 result = dec1Length - dec2Length; 
    1335                         } 
    1336                 } 
    1337  
    1338                 if (dec1.charAt(0) == '-') { 
    1339                         // reverse result for negative values 
    1340                         result = -result; 
    1341                 } 
    1342  
    1343                 return result; 
    1344         } 
    1345  
    1346         /** 
    1347          * Compares two integers to eachother. 
    1348          *  
    1349          * @return A negative number if <tt>int1</tt> is smaller than <tt>int2</tt>, 
    1350          *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
    1351          *         <tt>int1</tt> is larger than <tt>int2</tt>. 
    1352          * @throws IllegalArgumentException 
    1353          *         If one of the supplied strings is not a legal integer. 
    1354          */ 
    1355         public static int compareIntegers(String int1, String int2) { 
    1356                 int1 = normalizeInteger(int1); 
    1357                 int2 = normalizeInteger(int2); 
    1358  
    1359                 return compareCanonicalIntegers(int1, int2); 
    1360         } 
    1361  
    1362         /** 
    1363          * Compares two canonical integers to eachother. 
    1364          *  
    1365          * @return A negative number if <tt>int1</tt> is smaller than <tt>int2</tt>, 
    1366          *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
    1367          *         <tt>int1</tt> is larger than <tt>int2</tt>. The result is 
    1368          *         undefined when one or both of the arguments is not a canonical 
    1369          *         integer. 
    1370          * @throws IllegalArgumentException 
    1371          *         If one of the supplied strings is not a legal integer. 
    1372          */ 
    1373         public static int compareCanonicalIntegers(String int1, String int2) { 
    1374                 if (int1.equals(int2)) { 
    1375                         return 0; 
    1376                 } 
    1377  
    1378                 // Check signs 
    1379                 if (int1.charAt(0) == '-' && int2.charAt(0) != '-') { 
    1380                         // int1 is negative, int2 is not 
    1381                         return -1; 
    1382                 } 
    1383                 if (int2.charAt(0) == '-' && int1.charAt(0) != '-') { 
    1384                         // int2 is negative, int1 is not 
    1385                         return 1; 
    1386                 } 
    1387  
    1388                 // The integer with the most digits is the largest 
    1389                 int result = int1.length() - int2.length(); 
    1390  
    1391                 if (result == 0) { 
    1392                         // equal number of digits, compare them 
    1393                         for (int i = 0; result == 0 && i < int1.length(); i++) { 
    1394                                 result = int1.charAt(i) - int2.charAt(i); 
    1395                         } 
    1396                 } 
    1397  
    1398                 if (int1.charAt(0) == '-') { 
    1399                         // reverse result for negative values 
    1400                         result = -result; 
    1401                 } 
    1402  
    1403                 return result; 
    1404         } 
    1405  
    1406         public static int compareNegativeIntegers(String int1, String int2) { 
    1407                 int1 = normalizeNegativeInteger(int1); 
    1408                 int2 = normalizeNegativeInteger(int2); 
    1409  
    1410                 return compareCanonicalIntegers(int1, int2); 
    1411         } 
    1412  
    1413         public static int compareNonPositiveIntegers(String int1, String int2) { 
    1414                 int1 = normalizeNonPositiveInteger(int1); 
    1415                 int2 = normalizeNonPositiveInteger(int2); 
    1416  
    1417                 return compareCanonicalIntegers(int1, int2); 
    1418         } 
    1419  
    1420         public static int compareNonNegativeIntegers(String int1, String int2) { 
    1421                 int1 = normalizeNonNegativeInteger(int1); 
    1422                 int2 = normalizeNonNegativeInteger(int2); 
    1423  
    1424                 return compareCanonicalIntegers(int1, int2); 
    1425         } 
    1426  
    1427         public static int comparePositiveIntegers(String int1, String int2) { 
    1428                 int1 = normalizePositiveInteger(int1); 
    1429                 int2 = normalizePositiveInteger(int2); 
    1430  
    1431                 return compareCanonicalIntegers(int1, int2); 
    1432         } 
    1433  
    1434         public static int compareLongs(String int1, String int2) { 
    1435                 int1 = normalizeLong(int1); 
    1436                 int2 = normalizeLong(int2); 
    1437  
    1438                 return compareCanonicalIntegers(int1, int2); 
    1439         } 
    1440  
    1441         public static int compareInts(String int1, String int2) { 
    1442                 int1 = normalizeInt(int1); 
    1443                 int2 = normalizeInt(int2); 
    1444  
    1445                 return compareCanonicalIntegers(int1, int2); 
    1446         } 
    1447  
    1448         public static int compareShorts(String int1, String int2) { 
    1449                 int1 = normalizeShort(int1); 
    1450                 int2 = normalizeShort(int2); 
    1451  
    1452                 return compareCanonicalIntegers(int1, int2); 
    1453         } 
    1454  
    1455         public static int compareBytes(String int1, String int2) { 
    1456                 int1 = normalizeByte(int1); 
    1457                 int2 = normalizeByte(int2); 
    1458  
    1459                 return compareCanonicalIntegers(int1, int2); 
    1460         } 
    1461  
    1462         public static int compareUnsignedLongs(String int1, String int2) { 
    1463                 int1 = normalizeUnsignedLong(int1); 
    1464                 int2 = normalizeUnsignedLong(int2); 
    1465  
    1466                 return compareCanonicalIntegers(int1, int2); 
    1467         } 
    1468  
    1469         public static int compareUnsignedInts(String int1, String int2) { 
    1470                 int1 = normalizeUnsignedInt(int1); 
    1471                 int2 = normalizeUnsignedInt(int2); 
    1472  
    1473                 return compareCanonicalIntegers(int1, int2); 
    1474         } 
    1475  
    1476         public static int compareUnsignedShorts(String int1, String int2) { 
    1477                 int1 = normalizeUnsignedShort(int1); 
    1478                 int2 = normalizeUnsignedShort(int2); 
    1479  
    1480                 return compareCanonicalIntegers(int1, int2); 
    1481         } 
    1482  
    1483         public static int compareUnsignedBytes(String int1, String int2) { 
    1484                 int1 = normalizeUnsignedByte(int1); 
    1485                 int2 = normalizeUnsignedByte(int2); 
    1486  
    1487                 return compareCanonicalIntegers(int1, int2); 
    1488         } 
    1489  
    1490         /** 
    1491          * Compares two floats to eachother. 
    1492          *  
    1493          * @return A negative number if <tt>float1</tt> is smaller than 
    1494          *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
    1495          *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
    1496          * @throws IllegalArgumentException 
    1497          *         If one of the supplied strings is not a legal float or if 
    1498          *         <tt>NaN</tt> is compared to a float other than <tt>NaN</tt>. 
    1499          */ 
    1500         public static int compareFloats(String float1, String float2) { 
    1501                 float1 = normalizeFloat(float1); 
    1502                 float2 = normalizeFloat(float2); 
    1503  
    1504                 return compareCanonicalFloats(float1, float2); 
    1505         } 
    1506  
    1507         /** 
    1508          * Compares two canonical floats to eachother. 
    1509          *  
    1510          * @return A negative number if <tt>float1</tt> is smaller than 
    1511          *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
    1512          *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
    1513          *         The result is undefined when one or both of the arguments is not a 
    1514          *         canonical float. 
    1515          * @throws IllegalArgumentException 
    1516          *         If one of the supplied strings is not a legal float or if 
    1517          *         <tt>NaN</tt> is compared to a float other than <tt>NaN</tt>. 
    1518          */ 
    1519         public static int compareCanonicalFloats(String float1, String float2) { 
    1520                 return compareCanonicalFPNumbers(float1, float2); 
    1521         } 
    1522  
    1523         /** 
    1524          * Compares two doubles to eachother. 
    1525          *  
    1526          * @return A negative number if <tt>double1</tt> is smaller than 
    1527          *         <tt>double2</tt>, <tt>0</tt> if they are equal, or positive 
    1528          *         (&gt;0) if <tt>double1</tt> is larger than <tt>double2</tt>. 
    1529          * @throws IllegalArgumentException 
    1530          *         If one of the supplied strings is not a legal double or if 
    1531          *         <tt>NaN</tt> is compared to a double other than <tt>NaN</tt>. 
    1532          */ 
    1533         public static int compareDoubles(String double1, String double2) { 
    1534                 double1 = normalizeDouble(double1); 
    1535                 double2 = normalizeDouble(double2); 
    1536  
    1537                 return compareCanonicalDoubles(double1, double2); 
    1538         } 
    1539  
    1540         /** 
    1541          * Compares two canonical doubles to eachother. 
    1542          *  
    1543          * @return A negative number if <tt>double1</tt> is smaller than 
    1544          *         <tt>double2</tt>, <tt>0</tt> if they are equal, or positive 
    1545          *         (&gt;0) if <tt>double1</tt> is larger than <tt>double2</tt>. 
    1546          *         The result is undefined when one or both of the arguments is not a 
    1547          *         canonical double. 
    1548          * @throws IllegalArgumentException 
    1549          *         If one of the supplied strings is not a legal double or if 
    1550          *         <tt>NaN</tt> is compared to a double other than <tt>NaN</tt>. 
    1551          */ 
    1552         public static int compareCanonicalDoubles(String double1, String double2) { 
    1553                 return compareCanonicalFPNumbers(double1, double2); 
    1554         } 
    1555  
    1556         /** 
    1557          * Compares two floating point numbers to eachother. 
    1558          *  
    1559          * @return A negative number if <tt>float1</tt> is smaller than 
    1560          *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
    1561          *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
    1562          * @throws IllegalArgumentException 
    1563          *         If one of the supplied strings is not a legal floating point 
    1564          *         number or if <tt>NaN</tt> is compared to a floating point number 
    1565          *         other than <tt>NaN</tt>. 
    1566          */ 
    1567         public static int compareFPNumbers(String fp1, String fp2) { 
    1568                 fp1 = normalizeFPNumber(fp1); 
    1569                 fp2 = normalizeFPNumber(fp2); 
    1570  
    1571                 return compareCanonicalFPNumbers(fp1, fp2); 
    1572         } 
    1573  
    1574         /** 
    1575          * Compares two canonical floating point numbers to eachother. 
    1576          *  
    1577          * @return A negative number if <tt>float1</tt> is smaller than 
    1578          *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
    1579          *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
    1580          *         The result is undefined when one or both of the arguments is not a 
    1581          *         canonical floating point number. 
    1582          * @throws IllegalArgumentException 
    1583          *         If one of the supplied strings is not a legal floating point 
    1584          *         number or if <tt>NaN</tt> is compared to a floating point number 
    1585          *         other than <tt>NaN</tt>. 
    1586          */ 
    1587         public static int compareCanonicalFPNumbers(String float1, String float2) { 
    1588                 // Handle special case NaN 
    1589                 if (float1.equals("NaN") || float2.equals("NaN")) { 
    1590                         if (float1.equals(float2)) { 
    1591                                 // NaN is equal to itself 
    1592                                 return 0; 
    1593                         } 
    1594                         else { 
    1595                                 throwIAE("NaN cannot be compared to other floats"); 
    1596                         } 
    1597                 } 
    1598  
    1599                 // Handle special case INF 
    1600                 if (float1.equals("INF")) { 
    1601                         return (float2.equals("INF")) ? 0 : 1; 
    1602                 } 
    1603                 else if (float2.equals("INF")) { 
    1604                         return -1; 
    1605                 } 
    1606  
    1607                 // Handle special case -INF 
    1608                 if (float1.equals("-INF")) { 
    1609                         return (float2.equals("-INF")) ? 0 : -1; 
    1610                 } 
    1611                 else if (float2.equals("-INF")) { 
    1612                         return 1; 
    1613                 } 
    1614  
    1615                 // Check signs 
    1616                 if (float1.charAt(0) == '-' && float2.charAt(0) != '-') { 
    1617                         // float1 is negative, float2 is not 
    1618                         return -1; 
    1619                 } 
    1620                 if (float2.charAt(0) == '-' && float1.charAt(0) != '-') { 
    1621                         // float2 is negative, float1 is not 
    1622                         return 1; 
    1623                 } 
    1624  
    1625                 int eIdx1 = float1.indexOf('E'); 
    1626                 String mantissa1 = float1.substring(0, eIdx1); 
    1627                 String exponent1 = float1.substring(eIdx1 + 1); 
    1628  
    1629                 int eIdx2 = float2.indexOf('E'); 
    1630                 String mantissa2 = float2.substring(0, eIdx2); 
    1631                 String exponent2 = float2.substring(eIdx2 + 1); 
    1632  
    1633                 // Compare exponents 
    1634                 int result = compareCanonicalIntegers(exponent1, exponent2); 
    1635  
    1636                 if (result != 0 && float1.charAt(0) == '-') { 
    1637                         // reverse result for negative values 
    1638                         result = -result; 
    1639                 } 
    1640  
    1641                 if (result == 0) { 
    1642                         // Equal exponents, compare mantissas 
    1643                         result = compareCanonicalDecimals(mantissa1, mantissa2); 
    1644                 } 
    1645  
    1646                 return result; 
    1647         } 
    1648  
    1649         /** 
    1650          * Compares two dateTime objects. <b>Important:</b> The comparison only 
    1651          * works if both values have, or both values don't have specified a valid 
    1652          * value for the timezone. 
    1653          *  
    1654          * @param value1 
    1655          *        An xsd:dateTime value. 
    1656          * @param value2 
    1657          *        An xsd:dateTime value. 
    1658          * @return <tt>-1</tt> if <tt>value1</tt> is before <tt>value2</tt> 
    1659          *         (i.e. if the dateTime object represented by value1 is before the 
    1660          *         dateTime object represented by value2), <tt>0</tt> if both are 
    1661          *         equal and <tt>1</tt> if <tt>value2</tt> is before 
    1662          *         <tt>value1</tt><br>. 
    1663          */ 
    1664         public static int compareDateTime(String value1, String value2) { 
    1665                 XMLDateTime dateTime1 = new XMLDateTime(value1); 
    1666                 XMLDateTime dateTime2 = new XMLDateTime(value2); 
    1667  
    1668                 dateTime1.normalize(); 
    1669                 dateTime2.normalize(); 
    1670  
    1671                 return dateTime1.compareTo(dateTime2); 
    1672         } 
    1673  
    1674         /*---------------* 
    1675          * Value parsing * 
    1676          *---------------*/ 
    1677  
    1678         /** 
    1679          * Parses the supplied xsd:boolean string and returns its value. 
    1680          *  
    1681          * @param s 
    1682          *        A string representation of an xsd:boolean value. 
    1683          * @return The <tt>boolean</tt> value represented by the supplied string 
    1684          *         argument. 
    1685          * @throws NumberFormatException 
    1686          *         If the supplied string is not a valid xsd:boolean value. 
    1687          */ 
    1688         public static boolean parseBoolean(String s) { 
    1689                 return normalizeBoolean(s).equals("true"); 
    1690         } 
    1691  
    1692         /** 
    1693          * Parses the supplied xsd:byte string and returns its value. 
    1694          *  
    1695          * @param s 
    1696          *        A string representation of an xsd:byte value. 
    1697          * @return The <tt>byte</tt> value represented by the supplied string 
    1698          *         argument. 
    1699          * @throws NumberFormatException 
    1700          *         If the supplied string is not a valid xsd:byte value. 
    1701          */ 
    1702         public static byte parseByte(String s) { 
    1703                 s = trimPlusSign(s); 
    1704                 return Byte.parseByte(s); 
    1705         } 
    1706  
    1707         /** 
    1708          * Parses the supplied xsd:short string and returns its value. 
    1709          *  
    1710          * @param s 
    1711          *        A string representation of an xsd:short value. 
    1712          * @return The <tt>short</tt> value represented by the supplied string 
    1713          *         argument. 
    1714          * @throws NumberFormatException 
    1715          *         If the supplied string is not a valid xsd:short value. 
    1716          */ 
    1717         public static short parseShort(String s) { 
    1718                 s = trimPlusSign(s); 
    1719                 return Short.parseShort(s); 
    1720         } 
    1721  
    1722         /** 
    1723          * Parses the supplied xsd:int strings and returns its value. 
    1724          *  
    1725          * @param s 
    1726          *        A string representation of an xsd:int value. 
    1727          * @return The <tt>int</tt> value represented by the supplied string 
    1728          *         argument. 
    1729          * @throws NumberFormatException 
    1730          *         If the supplied string is not a valid xsd:int value. 
    1731          */ 
    1732         public static int parseInt(String s) { 
    1733                 s = trimPlusSign(s); 
    1734                 return Integer.parseInt(s); 
    1735         } 
    1736  
    1737         /** 
    1738          * Parses the supplied xsd:long string and returns its value. 
    1739          *  
    1740          * @param s 
    1741          *        A string representation of an xsd:long value. 
    1742          * @return The <tt>long</tt> value represented by the supplied string 
    1743          *         argument. 
    1744          * @throws NumberFormatException 
    1745          *         If the supplied string is not a valid xsd:long value. 
    1746          */ 
    1747         public static long parseLong(String s) { 
    1748                 s = trimPlusSign(s); 
    1749                 return Long.parseLong(s); 
    1750         } 
    1751  
    1752         /** 
    1753          * Parses the supplied xsd:float string and returns its value. 
    1754          *  
    1755          * @param s 
    1756          *        A string representation of an xsd:float value. 
    1757          * @return The <tt>float</tt> value represented by the supplied string 
    1758          *         argument. 
    1759          * @throws NumberFormatException 
    1760          *         If the supplied string is not a valid xsd:float value. 
    1761          */ 
    1762         public static float parseFloat(String s) { 
    1763                 s = trimPlusSign(s); 
    1764                 return Float.parseFloat(s); 
    1765         } 
    1766  
    1767         /** 
    1768          * Parses the supplied xsd:double string and returns its value. 
    1769          *  
    1770          * @param s 
    1771          *        A string representation of an xsd:double value. 
    1772          * @return The <tt>double</tt> value represented by the supplied string 
    1773          *         argument. 
    1774          * @throws NumberFormatException 
    1775          *         If the supplied string is not a valid xsd:double value. 
    1776          */ 
    1777         public static double parseDouble(String s) { 
    1778                 s = trimPlusSign(s); 
    1779                 return Double.parseDouble(s); 
    1780         } 
    1781  
    1782         /** 
    1783          * Parses the supplied xsd:integer string and returns its value. 
    1784          *  
    1785          * @param s 
    1786          *        A string representation of an xsd:integer value. 
    1787          * @return The integer value represented by the supplied string argument. 
    1788          * @throws NumberFormatException 
    1789          *         If the supplied string is not a valid xsd:integer value. 
    1790          */ 
    1791         public static BigInteger parseInteger(String s) { 
    1792                 s = trimPlusSign(s); 
    1793                 return new BigInteger(s); 
    1794         } 
    1795  
    1796         /** 
    1797          * Parses the supplied decimal/floating point string and returns its value. 
    1798          *  
    1799          * @param s 
    1800          *        A string representation of an xsd:decimal or xsd:double value. 
    1801          * @return The decimal/floating point value represented by the supplied 
    1802          *         string argument. 
    1803          * @throws NumberFormatException 
    1804          *         If the supplied string is not a valid xsd:decimal or xsd:double 
    1805          *         value. 
    1806          */ 
    1807         public static BigDecimal parseDecimal(String s) { 
    1808                 // Note: BigDecimal can handle leading plus signs itself 
    1809                 return new BigDecimal(s); 
    1810         } 
    1811  
    1812         /** 
    1813          * Parses the supplied calendar value string and returns its value. 
    1814          *  
    1815          * @param s 
    1816          *        A string representation of an xsd:dateTime, xsd:time, xsd:date, 
    1817          *        xsd:gYearMonth, xsd:gMonthDay, xsd:gYear, xsd:gMonth or xsd:gDay 
    1818          *        value. 
    1819          * @return The calendar value represented by the supplied string argument. 
    1820          * @throws NumberFormatException 
    1821          *         If the supplied string is not a valid calendar value. 
    1822          */ 
    1823         public static XMLGregorianCalendar parseCalendar(String s) { 
    1824                 return dtFactory.newXMLGregorianCalendar(s); 
    1825         } 
    1826  
    1827         /** 
    1828          * Removes the first character from the supplied string if this is a plus 
    1829          * sign ('+'). Number strings with leading plus signs cannot be parsed by 
    1830          * methods such as {@link Integer#parseInt(String)}. 
    1831          */ 
    1832         private static String trimPlusSign(String s) { 
    1833                 if (s.length() > 0 && s.charAt(0) == '+') { 
    1834                         return s.substring(1); 
    1835                 } 
    1836                 else { 
    1837                         return s; 
    1838                 } 
    1839         } 
    1840  
    1841         /** 
    1842          * Maps a datatype QName from the javax.xml.namespace package to an XML 
    1843          * Schema URI for the corresponding datatype. This method recognizes the XML 
    1844          * Schema qname mentioned in {@link DatatypeConstants}. 
    1845          *  
    1846          * @param qname 
    1847          *        One of the XML Schema qnames from {@link DatatypeConstants}. 
    1848          * @return A URI for the specified datatype. 
    1849          * @throws IllegalArgumentException 
    1850          *         If the supplied qname was not recognized by this method. 
    1851          * @see DatatypeConstants 
    1852          */ 
    1853         public static URI qnameToURI(QName qname) { 
    1854                 if (DatatypeConstants.DATETIME.equals(qname)) { 
    1855                         return XMLSchema.DATETIME; 
    1856                 } 
    1857                 else if (DatatypeConstants.DATE.equals(qname)) { 
    1858                         return XMLSchema.DATE; 
    1859                 } 
    1860                 else if (DatatypeConstants.TIME.equals(qname)) { 
    1861                         return XMLSchema.TIME; 
    1862                 } 
    1863                 else if (DatatypeConstants.GYEARMONTH.equals(qname)) { 
    1864                         return XMLSchema.GYEARMONTH; 
    1865                 } 
    1866                 else if (DatatypeConstants.GMONTHDAY.equals(qname)) { 
    1867                         return XMLSchema.GMONTHDAY; 
    1868                 } 
    1869                 else if (DatatypeConstants.GYEAR.equals(qname)) { 
    1870                         return XMLSchema.GYEAR; 
    1871                 } 
    1872                 else if (DatatypeConstants.GMONTH.equals(qname)) { 
    1873                         return XMLSchema.GMONTH; 
    1874                 } 
    1875                 else if (DatatypeConstants.GDAY.equals(qname)) { 
    1876                         return XMLSchema.GDAY; 
    1877                 } 
    1878                 else if (DatatypeConstants.DURATION.equals(qname)) { 
    1879                         return XMLSchema.DURATION; 
    1880                 } 
    1881                 else { 
    1882                         throw new IllegalArgumentException("QName cannot be mapped to an XML Schema URI: " + qname.toString()); 
    1883                 } 
    1884         } 
    1885  
    1886         /*-----------------* 
    1887          * Utility methods * 
    1888          *-----------------*/ 
    1889  
    1890         /** 
    1891          * Checks whether the supplied character is a digit. 
    1892          */ 
    1893         private static final boolean isDigit(char c) { 
    1894                 return c >= '0' && c <= '9'; 
    1895         } 
    1896  
    1897         /** 
    1898          * Throws an IllegalArgumentException that contains the supplied message. 
    1899          */ 
    1900         private static final void throwIAE(String msg) { 
    1901                 throw new IllegalArgumentException(msg); 
    1902         } 
    1903  
     286                XMLSchema.DATETIME.equals(datatype) || 
     287                XMLSchema.DATE.equals(datatype) || 
     288                XMLSchema.TIME.equals(datatype) || 
     289                XMLSchema.GYEARMONTH.equals(datatype) || 
     290                XMLSchema.GMONTHDAY.equals(datatype) || 
     291                XMLSchema.GYEAR.equals(datatype) || 
     292                XMLSchema.GMONTH.equals(datatype) || 
     293                XMLSchema.GDAY.equals(datatype); 
     294 
     295        } 
     296 
     297        /** 
     298         * Checks whether the supplied datatype is equal to xsd:boolean. 
     299         *  
     300         * @param datatype 
     301         * @return 
     302         */ 
     303        public static boolean isBooleanDatatype(URI datatype) { 
     304                return XMLSchema.BOOLEAN.equals(datatype); 
     305        } 
    1904306} 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizer.java

    r1448 r1527  
    1010import static org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar.createPred; 
    1111import static org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar.createSpatialColumn; 
     12import static org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar.createTemporalColumn; 
    1213import static org.openrdf.sail.generaldb.algebra.GeneralDBColumnVar.createSubj; 
    1314import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.coalesce; 
     
    1516import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.isNull; 
    1617import static org.openrdf.sail.generaldb.algebra.base.GeneralDBExprSupport.or; 
     18 
     19import info.aduna.lang.service.ServiceRegistry; 
    1720 
    1821import java.sql.SQLException; 
     
    7275import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.TransformFunc; 
    7376import org.openrdf.query.algebra.evaluation.function.spatial.stsparql.construct.UnionFunc; 
     77import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.PeriodEndsFunc; 
     78import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.PeriodMinusFunc; 
     79import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.PeriodPrecedingFunc; 
     80import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.PeriodStartsFunc; 
     81import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.PeriodSucceedingFunc; 
     82import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.construct.TemporalConstructFunc; 
     83import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.relation.TemporalRelationFunc; 
    7484import org.openrdf.sail.generaldb.GeneralDBValueFactory; 
    7585import org.openrdf.sail.generaldb.algebra.GeneralDBBNodeColumn; 
     
    106116 *  
    107117 * @author Charalampos Nikolaou <charnik@di.uoa.gr> 
    108  * @author Manos Karpathiotakis <mk@di.uoa.gr. 
     118 * @author Manos Karpathiotakis <mk@di.uoa.gr> 
     119 * @author Konstantina Bereta   <Konstantina.Bereta@di.uoa.gr> 
     120 *  
    109121 */ 
    110122public class GeneralDBSelectQueryOptimizer extends GeneralDBQueryModelVisitorBase<RuntimeException>  
     
    147159        private int havingID = 1; 
    148160 
     161        /* 
     162         * addition by constant 
     163         */ 
     164        private List<String> temporalVars = new ArrayList<String>(15); 
     165        private GeneralDBColumnVar previousTemporalArg = null; 
     166        private GeneralDBColumnVar previousTemporalAlias; 
     167 
     168        private List<Var> existingTemporalJoins = new ArrayList<Var>(); 
     169 
     170 
    149171        private static final String ALIAS = "t"; 
    150172 
     
    162184 
    163185        private IdSequence ids; 
     186 
     187        private List<TupleExpr> temporalJoins; 
    164188 
    165189        public void setSqlExprFactory(GeneralDBSqlExprFactory sql) { 
     
    179203        } 
    180204 
    181         public void optimize(TupleExpr tupleExpr, Dataset dataset, BindingSet bindings, List<TupleExpr> spatialJoins) { 
     205        public void optimize(TupleExpr tupleExpr, Dataset dataset, BindingSet bindings, List<TupleExpr> spatialJoins, List<TupleExpr> temporalJoins) { 
    182206                this.dataset = dataset; 
    183207                this.bindings = bindings; 
    184208                this.spatialJoins = spatialJoins; 
     209                this.temporalJoins = temporalJoins; 
    185210                tupleExpr.visit(this); 
    186211        } 
     
    384409                GeneralDBColumnVar p = createPred(alias, predVar, (URI)predValue, !present); 
    385410                /** 
    386                  * XXX enabled spatial objects 
     411                 * XXX enabled spatial or temporal objects 
    387412                 */ 
    388                 boolean spatialObj = false; 
    389  
     413                //boolean spatialObj = false; 
     414 
     415 
     416                GeneralDBColumnVar o = createObj(alias, objVar, objValue); 
    390417                if(geoNames.contains(objVar.getName())) 
    391418                { 
    392                         spatialObj = true; 
    393                 } 
    394                 GeneralDBColumnVar o = createObj(alias, objVar, objValue, spatialObj); 
     419                        o.setSpatial(true); 
     420                } 
     421                else if(temporalVars.contains(objVar.getName())) 
     422                { 
     423                        o.setTemporal(true); 
     424                 
     425                } 
    395426 
    396427                GeneralDBColumnVar c = createCtx(alias, ctxVar, (Resource)ctxValue); 
     
    432463                                        previousSpatialArg = null; 
    433464                                } 
     465                                else if(var.getColumn().equals("obj")&&previousTemporalArg!=null) //do the same for the temporal case 
     466                                { 
     467                                        from.addFilter(new GeneralDBSqlEq(new GeneralDBIdColumn(var), new GeneralDBIdColumn(previousTemporalArg))); 
     468                                        previousTemporalArg = null; 
     469                                } 
    434470                        } 
    435471 
     
    448484                                        // add the corresponding datatype (see {@link GeneralDBValueJoinOptimizer.GeneralDBLabelColumn}) 
    449485                                        proj.setDatatype(new GeneralDBDatatypeColumn(var)); 
     486                                } 
     487                                else if(temporalVars.contains(var.getName())) 
     488                                { 
     489                                        proj.setStringValue(new GeneralDBLabelColumn(var)); 
     490                                        previousTemporalAlias = var; 
    450491                                } 
    451492                                else 
     
    533574                                                        //                                                      { 
    534575 
     576                                                        existingSpatialJoins.add(var); 
     577                                                        queries[count] = new GeneralDBSelectQuery(); 
     578                                                        Value objValue = getVarValue(var,bindings); 
     579 
     580                                                        //any changes in these two lines could cause problems 
     581                                                        GeneralDBColumnVar colVar = createSpatialColumn("l_"+var.getName(), var, objValue); 
     582                                                        GeneralDBJoinItem from = new GeneralDBJoinItem("l_"+var.getName(), "geo_values"); 
     583 
     584                                                        queries[count].setFrom(from); 
     585 
     586                                                        //assuming that only one var will reach this case 
     587                                                        from.addFilter(new GeneralDBSqlEq(new GeneralDBIdColumn(colVar), new GeneralDBIdColumn(previousAlias))); 
     588 
     589                                                        //Copying functionality from meet(StatementPattern) 
     590                                                        GeneralDBSelectProjection proj = new GeneralDBSelectProjection(); 
     591                                                        proj.setVar(colVar); 
     592                                                        proj.setId(new GeneralDBRefIdColumn(var)); 
     593                                                        break; 
     594                                                        //                                                      } 
     595                                                } 
     596                                                else if(var.getName().equals(previousAlias.getName())) 
     597                                                { 
    535598                                                        existingSpatialJoins.add(var); 
    536599                                                        queries[count] = new GeneralDBSelectQuery(); 
     
    686749 
    687750                        } 
     751                        else if(st.getSubjectVar().getName().equals("-dummy-temporal")) 
     752                        { 
     753 
     754                                //Spatial join 
     755 
     756                                //                              List<Var> allVars = retrieveVars(node.getCondition()); 
     757                                List<Var> allVars = new ArrayList<Var>(retrieveVars(node.getCondition())); 
     758                                GeneralDBSelectQuery queries[] = new GeneralDBSelectQuery[allVars.size()]; 
     759 
     760                                int count = 0; 
     761 
     762                                //will probably be TWO contents at most in all cases concerning spatial filters here - have to make sure of that 
     763                                //Don't know which one of the spatial variables is bound with the upper join! Therefore, I altered the code to check  
     764                                //for the possibility any of them is the one. 
     765                                int mark = 0; 
     766                                //FIXME remove the list after consulting Kostis for certainty, and replace with table[2] 
     767                                if(allVars.size()>1) 
     768                                { 
     769                                        for(Var var : allVars) 
     770                                        { 
     771                                                if(var.getName().equals(previousTemporalAlias.getName())) 
     772                                                { 
     773 
     774                                                        //                                                      if(var.getName().endsWith("?-buffer-")) 
     775                                                        //                                                      { 
     776                                                        //                                                              bufferCase = true; 
     777                                                        //                                                              fixVarName(var); 
     778                                                        //                                                               
     779                                                        //                                                              existingSpatialJoins.add(var); 
     780                                                        //                                                              queries[count] = new GeneralDBSelectQuery(); 
     781                                                        //                                                              Value objValue = getVarValue(var,bindings); 
     782                                                        //                                                               
     783                                                        //                                                              GeneralDBColumnVar colVar = createObj("l_"+var.getName(), var, objValue); 
     784 
     785 
     786                                                        //                                                      } 
     787                                                        //                                                      else //DEFAULT CASE. The only case differentiating from this one is buffer(?spatialVar,?thematicVar) 
     788                                                        //                                                      { 
     789 
     790                                                        existingTemporalJoins.add(var); 
     791                                                        queries[count] = new GeneralDBSelectQuery(); 
     792                                                        Value objValue = getVarValue(var,bindings); 
     793 
     794                                                        //any changes in these two lines could cause problems 
     795                                                        GeneralDBColumnVar colVar = createSpatialColumn("l_"+var.getName(), var, objValue); 
     796                                                        GeneralDBJoinItem from = new GeneralDBJoinItem("l_"+var.getName(), "period_values"); 
     797 
     798                                                        queries[count].setFrom(from); 
     799 
     800                                                        //assuming that only one var will reach this case 
     801                                                        from.addFilter(new GeneralDBSqlEq(new GeneralDBIdColumn(colVar), new GeneralDBIdColumn(previousTemporalAlias))); 
     802 
     803                                                        //Copying functionality from meet(StatementPattern) 
     804                                                        GeneralDBSelectProjection proj = new GeneralDBSelectProjection(); 
     805                                                        proj.setVar(colVar); 
     806                                                        proj.setId(new GeneralDBRefIdColumn(var)); 
     807                                                        break; 
     808                                                        //                                                      } 
     809                                                } 
     810                                                else if(var.getName().equals(previousTemporalAlias.getName())) 
     811                                                { 
     812                                                        existingTemporalJoins.add(var); 
     813                                                        queries[count] = new GeneralDBSelectQuery(); 
     814                                                        Value objValue = getVarValue(var,bindings); 
     815 
     816                                                        //any changes in these two lines could cause problems 
     817                                                        GeneralDBColumnVar colVar = createTemporalColumn("l_"+var.getName(), var, objValue); 
     818                                                        GeneralDBJoinItem from = new GeneralDBJoinItem("l_"+var.getName(), "period_values"); 
     819 
     820                                                        queries[count].setFrom(from); 
     821 
     822                                                        //assuming that only one var will reach this case 
     823                                                        from.addFilter(new GeneralDBSqlEq(new GeneralDBIdColumn(colVar), new GeneralDBIdColumn(previousTemporalAlias))); 
     824 
     825                                                        //Copying functionality from meet(StatementPattern) 
     826                                                        GeneralDBSelectProjection proj = new GeneralDBSelectProjection(); 
     827                                                        proj.setVar(colVar); 
     828                                                        proj.setId(new GeneralDBRefIdColumn(var)); 
     829                                                        break; 
     830                                                        //                                                      } 
     831                                                } 
     832                                                count++; 
     833                                        } 
     834                                        mark = (count+1)%2; 
     835                                } 
     836                                //The second var of the spatial join -> must incorporate the spatial filter here 
     837 
     838 
     839                                Var var = allVars.get(mark); 
     840                                existingTemporalJoins.add(var); 
     841                                queries[mark] = new GeneralDBSelectQuery(); 
     842                                Value objValue = getVarValue(var,bindings); 
     843 
     844                                //any changes in these two lines could cause problems 
     845                                GeneralDBColumnVar colVar = createTemporalColumn("l_"+var.getName(), var, objValue); 
     846                                GeneralDBJoinItem from = new GeneralDBJoinItem("l_"+var.getName(), "period_values"); 
     847                                queries[mark].setFrom(from); 
     848 
     849                                previousTemporalArg = colVar; 
     850 
     851 
     852                                super.meet(node); 
     853 
     854 
     855                                //Incorporating temporal filter 
     856                                ValueExpr condition = null; 
     857                                for (ValueExpr expr : flatten(node.getCondition()))  
     858                                { 
     859                                        try  
     860                                        { 
     861                                                GeneralDBSqlExpr sqlFilter = sql.createBooleanExpr(expr); 
     862 
     863                                                queries[mark].addFilter(sqlFilter); 
     864                                        } 
     865                                        catch (UnsupportedRdbmsOperatorException e) 
     866                                        { 
     867                                                if (condition == null)  
     868                                                { 
     869                                                        condition = expr; 
     870                                                } 
     871                                                else  
     872                                                { 
     873                                                        condition = new And(condition, expr); 
     874                                                } 
     875                                        } 
     876                                } 
     877 
     878                                queries[count].setParentNode(node.getParentNode()); 
     879 
     880                                node.replaceWith(queries[mark]); 
     881                         
     882 
     883                         
     884                        } 
    688885                        else 
    689886                        { 
     
    757954                                        //                                      return; 
    758955                                        dup = true; 
     956                                        break; 
     957                                } 
     958                        } 
     959                        for(TupleExpr sfilter : this.temporalJoins) 
     960                        { 
     961                                ValueExpr tmpExpr = ((Filter)sfilter).getCondition(); 
     962                                if(tmpExpr.equals(dupFunctionCall)) 
     963                                { 
     964                                dup = true; 
    759965                                        break; 
    760966                                } 
     
    9521158                        //                      } 
    9531159                } 
    954                 /** 
    955                  * Addition for datetime metric functions 
    956                  *  
    957                  * @author George Garbis <ggarbis@di.uoa.gr> 
    958                  *  
    959                  */ 
    960                 else if (function instanceof DateTimeMetricFunc) 
    961                 { 
     1160                else if(function instanceof TemporalConstructFunc || function instanceof TemporalRelationFunc) 
     1161                { 
     1162 
    9621163                        List<ValueExpr> allArgs = node.getArgs(); 
    9631164 
    964                         int argNo = 0;  
    965                         //Used so that the second argument of buffer func is not  
    966                         //mistakenly confused with a spatial variable 
    9671165                        for(ValueExpr arg : allArgs) 
    9681166                        {        
    969                                 argNo++; 
    970                                 if(arg instanceof Var && argNo!=2) 
    971                                 { 
    972                                         String originalName = ((Var)arg).getName(); 
    973                                         ((Var)arg).setName(originalName); 
    974                                 } 
    975                         } 
    976                 } 
    977                 /***/ 
     1167                         
     1168                                if(arg instanceof Var) 
     1169                                { 
     1170                                                //The variable's name is not in the list yet 
     1171                                                if(!temporalVars.contains(((Var) arg).getName())) 
     1172                                                { 
     1173                                                        temporalVars.add(((Var) arg).getName()); 
     1174 
     1175                                                } 
     1176                                                /** 
     1177                                                 * XXX FOLLOWED THE SAME TRICK BY MANOLEE 
     1178                                                 */ 
     1179 
     1180                                                String originalName = ((Var)arg).getName(); 
     1181                                                ((Var)arg).setName(originalName+"?temporal"); 
     1182                                        } 
     1183                                } 
     1184                        } 
     1185//                      System.out.println("NOT SPATIAL NOR TEMPORAL FUNCTION- SIMPLE VALUE"); 
     1186                 
     1187                 
     1188 
     1189                /** 
     1190                                 * Addition for datetime metric functions 
     1191                                 * @author George Garbis <ggarbis@di.uoa.gr> 
     1192                                 *  
     1193                                 */ 
     1194                                else if (function instanceof DateTimeMetricFunc) 
     1195                                { 
     1196                                        List<ValueExpr> allArgs = node.getArgs(); 
     1197                     
     1198                                        int argNo = 0;  
     1199                                        //Used so that the second argument of buffer func is not  
     1200                                        //mistakenly confused with a spatial variable 
     1201                                        for(ValueExpr arg : allArgs) 
     1202                                        {        
     1203                                                argNo++; 
     1204                                                if(arg instanceof Var && argNo!=2) 
     1205                                                { 
     1206                                                        String originalName = ((Var)arg).getName(); 
     1207                                                        ((Var)arg).setName(originalName); 
     1208                                                } 
     1209                                        } 
     1210                                } 
     1211                  
    9781212        } 
    9791213 
     
    10141248                                                iter.remove(); 
    10151249                                        } 
     1250                                        else if(function instanceof TemporalConstructFunc || function instanceof TemporalRelationFunc) 
     1251                                        { 
     1252                                                try { 
     1253                                                        sqlExpr= sql.getBooleanExprFactory().temporalFunction((FunctionCall)expr); 
     1254                                                        reference.getTemporalConstructs().put(name, sqlExpr); 
     1255                                                } catch (UnsupportedRdbmsOperatorException e) { 
     1256                                                        // TODO Auto-generated catch block 
     1257                                                        e.printStackTrace(); 
     1258                                                } 
     1259                                        } 
    10161260                                } 
    10171261                                else if(!varInBind(expr)) //Union (or Extent) is used as an aggregate function on Select Clause! 
     
    10421286 
    10431287                                                reference.getSpatialConstructs().put(name, sqlExpr); 
     1288                                                reference.getTemporalConstructs().put(name, sqlExpr); 
     1289 
    10441290                                                iter.remove(); 
    10451291                                        } 
     
    12381484                        if((!(function instanceof UnionFunc) || !(((FunctionCall) expr).getArgs().size()==1)) 
    12391485                                        &&(!(function instanceof IntersectionFunc) || !(((FunctionCall) expr).getArgs().size()==1)) 
     1486                                        && !(function instanceof PeriodPrecedingFunc)   
     1487                                        && !(function instanceof PeriodSucceedingFunc) 
    12401488                                        &&!(function instanceof ExtentFunc)) 
    12411489                        { 
     
    12531501                        else 
    12541502                        { 
     1503                                System.out.println("Will be evaluated in Java"); 
    12551504                                return true; 
    12561505                        } 
     
    12581507                else //Var 
    12591508                { 
     1509                        System.out.println("Should not be evaluated in Java"); 
    12601510                        return false; 
    12611511                } 
     
    16491899                                        //if(!((FunctionCall)expr).getURI().equals("http://strdf.di.uoa.gr/ontology#buffer") || argNo!=2 ) 
    16501900                                        //{ 
    1651                                         if(!existingSpatialJoins.contains(arg)) 
     1901                                        if(!existingSpatialJoins.contains(arg) && !existingTemporalJoins.contains(arg)) 
    16521902                                        { 
    16531903                                                //XXX note: this may cause error if the user intends to  
     
    16731923                else if(expr instanceof Var) 
    16741924                { 
    1675                         if(!existingSpatialJoins.contains(expr)) 
     1925                        if(!existingSpatialJoins.contains(expr) && !existingTemporalJoins.contains(expr)) 
    16761926                        { 
    16771927                                //Want to find the UNIQUE names! 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizer.java

    r1427 r1527  
    153153        private Group referenceGroupBy = null; 
    154154 
     155        //used to keep the names used in a BIND clause 
     156        private Set<String> namesInBind = new HashSet<String>(); 
     157 
    155158        //Counter used to enumerate expressions in having 
    156159        private int havingID = 1; 
     
    12281231                        if (expr instanceof FunctionCall) 
    12291232                        //if (expr instanceof FunctionCall && !isFuncExprGrounded(expr)) 
    1230                         { // if the expr is grounded we are going to evaluate it in Java  
    1231                                 if(!evaluateInJava(expr)) 
     1233                        { // if the expr is grounded we are going to evaluate it in Java 
     1234                                //also if the function involves variables from a BIND clause 
     1235                                //we evaluate it in java 
     1236                                if(!evaluateInJava(expr) && !varInBind(expr)) 
    12321237                                { 
    12331238                                        Function function = FunctionRegistry.getInstance().get(((FunctionCall) expr).getURI()); 
     
    12541259                                        } 
    12551260                                } 
    1256                                 else //Union (or Extent) is used as an aggregate function on Select Clause! 
     1261                                else if(!varInBind(expr)) //Union (or Extent) is used as an aggregate function on Select Clause! 
    12571262                                { 
    12581263                                        //must add as aggregate 
     
    12641269                                        iter.remove(); 
    12651270                                } 
    1266  
     1271                                //if the name of the new variable is not present in the projection 
     1272                                //then it results from a BIND 
     1273                                if(!(node.getParentNode() instanceof Projection)) 
     1274                                        namesInBind.add(name+"?spatial"); 
    12671275                        } 
    12681276                        //Issue: MathExpr is not exclusively met in spatial cases! 
     
    15051513        } 
    15061514 
     1515        /** 
     1516         * 
     1517         * @param expr 
     1518         * @return true if the variable occurs inside a BIND clause 
     1519         * false otherwise 
     1520         */ 
     1521        private boolean varInBind(ValueExpr expr) 
     1522        { 
     1523                if(expr instanceof FunctionCall) 
     1524                { 
     1525                        for(int i = 0 ; i< ((FunctionCall) expr).getArgs().size(); i++) 
     1526                        { 
     1527                                return varInBind(((FunctionCall) expr).getArgs().get(i)); 
     1528                        } 
     1529                        return false; 
     1530                } 
     1531                else if(expr instanceof Var) //Var 
     1532                { 
     1533                        if(namesInBind.contains(((Var)expr).getName())) 
     1534                                return true; 
     1535                        return false; 
     1536                } 
     1537                else 
     1538                        return false; 
     1539        } 
     1540 
    15071541        @Override 
    15081542        public void meet(Slice node) 
  • monetdb/pom.xml

    r1427 r1527  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.2.10-temporals-SNAPSHOT</version> 
     9                <version>3.3.2-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • monetdb/src/main/java/org/openrdf/sail/monetdb/evaluation/MonetDBQueryBuilder.java

    r1436 r1527  
    101101import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Touches; 
    102102import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Within; 
     103import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlAdjacentPeriod; 
     104import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlAfterPeriod; 
     105import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlBeforePeriod; 
     106import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlEqualsPeriod; 
     107import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlFinishes; 
     108import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlMeets; 
     109import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlNequalsPeriod; 
     110import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlOverleftPeriod; 
     111import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlOverrightPeriod; 
     112import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriod; 
     113import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodContainedBy; 
     114import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodContains; 
     115import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodEnd; 
     116import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodIntersection; 
     117import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodIntersects; 
     118import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodMinus; 
     119import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodOverlaps; 
     120import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodStart; 
     121import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodUnion; 
     122import org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlStarts; 
    103123import org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder; 
    104124import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlBracketBuilder; 
     
    390410                if(expr instanceof BinaryGeneralDBOperator) 
    391411                { 
     412                        System.out.println("expr instanceof BinaryGeneralDBOperator"); 
    392413                        dispatchBinarySqlOperator((BinaryGeneralDBOperator) expr, (MonetDBSqlExprBuilder)query.select); 
    393414                } 
     
    26252646        } 
    26262647 
     2648        @Override 
     2649        protected void append(GeneralDBSqlPeriodContainedBy expr, 
     2650                        GeneralDBSqlExprBuilder filter) 
     2651                        throws UnsupportedRdbmsOperatorException { 
     2652                // TODO Auto-generated method stub 
     2653                 
     2654        } 
     2655 
     2656        @Override 
     2657        protected void append(GeneralDBSqlPeriodContains expr, 
     2658                        GeneralDBSqlExprBuilder filter) 
     2659                        throws UnsupportedRdbmsOperatorException { 
     2660                // TODO Auto-generated method stub 
     2661                 
     2662        } 
     2663 
     2664        @Override 
     2665        protected void append(GeneralDBSqlPeriodIntersection expr, 
     2666                        GeneralDBSqlExprBuilder filter) 
     2667                        throws UnsupportedRdbmsOperatorException { 
     2668                // TODO Auto-generated method stub 
     2669                 
     2670        } 
     2671 
     2672        @Override 
     2673        protected void append(GeneralDBSqlPeriodMinus expr, 
     2674                        GeneralDBSqlExprBuilder filter) 
     2675                        throws UnsupportedRdbmsOperatorException { 
     2676                // TODO Auto-generated method stub 
     2677                 
     2678        } 
     2679 
     2680        @Override 
     2681        protected void append(GeneralDBSqlPeriod expr, 
     2682                        GeneralDBSqlExprBuilder filter) 
     2683                        throws UnsupportedRdbmsOperatorException { 
     2684                // TODO Auto-generated method stub 
     2685                 
     2686        } 
     2687 
     2688        @Override 
     2689        protected void append(GeneralDBSqlPeriodOverlaps expr, 
     2690                        GeneralDBSqlExprBuilder filter) 
     2691                        throws UnsupportedRdbmsOperatorException { 
     2692                // TODO Auto-generated method stub 
     2693                 
     2694        } 
     2695 
     2696        @Override 
     2697        protected void append(GeneralDBSqlPeriodUnion expr, 
     2698                        GeneralDBSqlExprBuilder filter) 
     2699                        throws UnsupportedRdbmsOperatorException { 
     2700                // TODO Auto-generated method stub 
     2701                 
     2702        } 
     2703 
     2704        @Override 
     2705        protected void append(GeneralDBSqlAfterPeriod expr, 
     2706                        GeneralDBSqlExprBuilder filter) 
     2707                        throws UnsupportedRdbmsOperatorException { 
     2708                // TODO Auto-generated method stub 
     2709                 
     2710        } 
     2711 
     2712        @Override 
     2713        protected void append(GeneralDBSqlBeforePeriod expr, 
     2714                        GeneralDBSqlExprBuilder filter) 
     2715                        throws UnsupportedRdbmsOperatorException { 
     2716                // TODO Auto-generated method stub 
     2717                 
     2718        } 
     2719 
     2720        @Override 
     2721        protected void append(GeneralDBSqlOverleftPeriod expr, 
     2722                        GeneralDBSqlExprBuilder filter) 
     2723                        throws UnsupportedRdbmsOperatorException { 
     2724                // TODO Auto-generated method stub 
     2725                 
     2726        } 
     2727 
     2728        @Override 
     2729        protected void append(GeneralDBSqlOverrightPeriod expr, 
     2730                        GeneralDBSqlExprBuilder filter) 
     2731                        throws UnsupportedRdbmsOperatorException { 
     2732                // TODO Auto-generated method stub 
     2733                 
     2734        } 
     2735 
     2736        @Override 
     2737        protected void append(GeneralDBSqlEqualsPeriod expr, 
     2738                        GeneralDBSqlExprBuilder filter) 
     2739                        throws UnsupportedRdbmsOperatorException { 
     2740                // TODO Auto-generated method stub 
     2741                 
     2742        } 
     2743 
     2744        @Override 
     2745        protected void append(GeneralDBSqlNequalsPeriod expr, 
     2746                        GeneralDBSqlExprBuilder filter) 
     2747                        throws UnsupportedRdbmsOperatorException { 
     2748                // TODO Auto-generated method stub 
     2749                 
     2750        } 
     2751 
     2752        @Override 
     2753        protected void append(GeneralDBSqlMeets expr, GeneralDBSqlExprBuilder filter) 
     2754                        throws UnsupportedRdbmsOperatorException { 
     2755                // TODO Auto-generated method stub 
     2756                 
     2757        } 
     2758 
     2759        @Override 
     2760        protected void append(GeneralDBSqlStarts expr, 
     2761                        GeneralDBSqlExprBuilder filter) 
     2762                        throws UnsupportedRdbmsOperatorException { 
     2763                // TODO Auto-generated method stub 
     2764                 
     2765        } 
     2766 
     2767        @Override 
     2768        protected void append(GeneralDBSqlFinishes expr, 
     2769                        GeneralDBSqlExprBuilder filter) 
     2770                        throws UnsupportedRdbmsOperatorException { 
     2771                // TODO Auto-generated method stub 
     2772                 
     2773        } 
     2774 
     2775        @Override 
     2776        protected void append(GeneralDBSqlAdjacentPeriod expr, 
     2777                        GeneralDBSqlExprBuilder filter) 
     2778                        throws UnsupportedRdbmsOperatorException { 
     2779                // TODO Auto-generated method stub 
     2780                 
     2781        } 
     2782 
     2783        /* (non-Javadoc) 
     2784         * @see org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder#append(org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodStart, org.openrdf.sail.generaldb.evaluation.GeneralDBSqlExprBuilder) 
     2785         */ 
     2786        @Override 
     2787        protected void append(GeneralDBSqlPeriodStart expr, 
     2788                        GeneralDBSqlExprBuilder filter) 
     2789                        throws UnsupportedRdbmsOperatorException { 
     2790                // TODO Auto-generated method stub 
     2791                 
     2792        } 
     2793 
     2794        /* (non-Javadoc) 
     2795         * @see org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder#append(org.openrdf.sail.generaldb.algebra.temporal.GeneralDBSqlPeriodEnd, org.openrdf.sail.generaldb.evaluation.GeneralDBSqlExprBuilder) 
     2796         */ 
     2797        @Override 
     2798        protected void append(GeneralDBSqlPeriodEnd expr, 
     2799                        GeneralDBSqlExprBuilder filter) 
     2800                        throws UnsupportedRdbmsOperatorException { 
     2801                // TODO Auto-generated method stub 
     2802                 
     2803        } 
     2804 
     2805        @Override 
     2806        protected void append(GeneralDBSqlPeriodIntersects expr, 
     2807                        GeneralDBSqlExprBuilder filter) 
     2808                        throws UnsupportedRdbmsOperatorException { 
     2809                // TODO Auto-generated method stub 
     2810                 
     2811        } 
     2812 
    26272813} 
  • monetdb/src/main/java/org/openrdf/sail/monetdb/evaluation/MonetDBQueryBuilder.java

    r1453 r1527  
    987987        } 
    988988 
     989        protected String appendConstantWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 
     990        { 
     991                GeneralDBStringValue arg = (GeneralDBStringValue) expr; 
     992                String raw = arg.getValue(); 
     993 
     994                AbstractWKT wkt = new AbstractWKT(raw); 
     995                filter.append("Transform("); 
     996                filter.append(" GeomFromText('" + wkt.getWKT() + "'," + String.valueOf(GeoConstants.defaultSRID) + ")"); 
     997                filter.append(", "+GeoConstants.defaultSRID +")"); 
     998 
     999                return raw; 
     1000        } 
     1001         
    9891002        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
    9901003        protected void appendTransformFunc(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     
    13411354                        ///// 
    13421355 
    1343  
     1356                        //case where both arguments are constnats 
     1357                        boolean constantArgs = false;    
     1358  
    13441359                        switch(func) 
    13451360                        { 
     
    13621377                        if(expr.getLeftArg() instanceof GeneralDBStringValue) 
    13631378                        { 
    1364                                 appendWKT(expr.getLeftArg(),filter); 
     1379                                if(expr.getRightArg() instanceof GeneralDBStringValue) 
     1380                                {        
     1381                                        //both arguments are constants so we do not need 
     1382                                        //to transform the geometries to WGS84 
     1383                                        constantArgs = true; 
     1384                                        appendWKT(expr.getLeftArg(), filter); 
     1385                                } 
     1386                                else 
     1387                                        appendConstantWKT(expr.getLeftArg(), filter); 
    13651388                        } 
    13661389                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 
     
    13911414                                if(expr.getRightArg() instanceof GeneralDBStringValue) 
    13921415                                { 
    1393                                         appendWKT(expr.getRightArg(),filter); 
     1416                                        if(constantArgs == true) 
     1417                                                // both arguments are constants, so we do not need 
     1418                                                // to transform the geometries to WGS84 
     1419                                                appendWKT(expr.getRightArg(), filter); 
     1420                                        else 
     1421                                                appendConstantWKT(expr.getRightArg(),filter); 
    13941422                                } 
    13951423                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 
  • pom.xml

    r1519 r1527  
    396396                                <groupId>org.openrdf.sesame</groupId> 
    397397                                <artifactId>sesame-rio-api</artifactId> 
    398                                 <version>${sesame.version}</version> 
     398                                <version>2.6.9</version> 
    399399                        </dependency> 
    400400                        <dependency> 
    401401                                <groupId>org.openrdf.sesame</groupId> 
    402402                                <artifactId>sesame-rio-rdfxml</artifactId> 
    403                                 <version>${sesame.version}</version> 
     403                                <version>2.6.9</version> 
     404                        </dependency> 
     405                         
     406                         
     407                        <dependency> 
     408                                <groupId>org.openrdf.sesame</groupId> 
     409                                <artifactId>sesame-rio</artifactId> 
     410                                <version>2.6.9</version> 
    404411                        </dependency> 
    405412 
     
    407414                                <groupId>org.openrdf.sesame</groupId> 
    408415                                <artifactId>sesame-rio-ntriples</artifactId> 
    409                                 <version>${sesame.version}</version> 
     416                                <version>2.6.9</version> 
    410417                        </dependency> 
    411418 
     
    413420                                <groupId>org.openrdf.sesame</groupId> 
    414421                                <artifactId>sesame-rio-turtle</artifactId> 
    415                                 <version>${sesame.version}</version> 
     422                                <version>2.6.9</version> 
    416423                        </dependency> 
    417424 
     
    419426                                <groupId>org.openrdf.sesame</groupId> 
    420427                                <artifactId>sesame-rio-trig</artifactId> 
    421                                 <version>${sesame.version}</version> 
     428                                <version>2.6.9</version> 
    422429                        </dependency> 
    423430 
     
    425432                                <groupId>org.openrdf.sesame</groupId> 
    426433                                <artifactId>sesame-rio-trix</artifactId> 
    427                                 <version>${sesame.version}</version> 
     434                                <version>2.6.9</version> 
    428435                        </dependency> 
    429436 
     
    431438                                <groupId>org.openrdf.sesame</groupId> 
    432439                                <artifactId>sesame-rio-n3</artifactId> 
    433                                 <version>${sesame.version}</version> 
     440                                <version>2.6.9</version> 
    434441                        </dependency> 
    435442 
     
    437444                                <groupId>org.openrdf.sesame</groupId> 
    438445                                <artifactId>sesame-rio-binary</artifactId> 
    439                                 <version>${sesame.version}</version> 
     446                                <version>2.6.9</version> 
     447                        </dependency> 
     448                        <dependency> 
     449                                <groupId>org.openrdf.sesame</groupId> 
     450                                <artifactId>sesame-rio-api</artifactId> 
     451                                <version>2.6.9</version> 
    440452                        </dependency> 
    441453 
     
    942954                    <url>http://maven.strabon.di.uoa.gr/content/repositories/strabon.sesame/</url> 
    943955                </repository> 
    944                 <repository> 
     956                 <repository> 
    945957                        <releases> 
    946958                                <enabled>false</enabled> 
     
    965977                </repository> 
    966978                <repository> 
     979                        <releases> 
     980                                <enabled>true</enabled> 
     981                        </releases> 
     982                        <snapshots> 
     983                                <enabled>false</enabled> 
     984                        </snapshots> 
     985                        <id>aduna-mirror-ontotext</id> 
     986                        <name>Aduna Maven Repository - Ontotext Mirror</name> 
     987                        <url>http://maven.ontotext.com/content/repositories/aduna/</url> 
     988                </repository> 
     989                <repository> 
    967990                        <snapshots> 
    968991                                <enabled>true</enabled> 
     
    9821005                </repository> 
    9831006                --> 
    984                 <repository> 
    985                         <releases> 
    986                                 <enabled>true</enabled> 
    987                         </releases> 
    988                         <snapshots> 
    989                                 <enabled>false</enabled> 
    990                         </snapshots> 
    991                         <id>aduna-mirror-ontotext</id> 
    992                         <name>Aduna Maven Repository - Ontotext Mirror</name> 
    993                         <url>http://maven.ontotext.com/content/repositories/aduna/</url> 
    994                 </repository> 
    9951007        </repositories> 
    9961008 
  • pom.xml

    r1433 r1527  
    55        <groupId>eu.earthobservatory</groupId> 
    66        <artifactId>strabon</artifactId> 
    7         <version>3.2.10-temporals-SNAPSHOT</version> 
     7        <version>3.3.2-SNAPSHOT</version> 
    88        <packaging>pom</packaging> 
    99 
     
    141141 
    142142        <properties> 
    143         <eu.earthobservatory.version>3.2.10-temporals-SNAPSHOT</eu.earthobservatory.version> 
     143        <eu.earthobservatory.version>3.3.2-SNAPSHOT</eu.earthobservatory.version> 
    144144                <sesame.version>2.6.3</sesame.version> 
    145145                <aduna.appbase.version>3.5.0</aduna.appbase.version> 
     
    819819                                <groupId>org.apache.maven.plugins</groupId> 
    820820                                <artifactId>maven-javadoc-plugin</artifactId> 
    821                                 <version>2.8.1</version> 
     821                                <version>2.10.1</version> 
    822822                                <configuration> 
    823823                                        <source>1.6</source> 
     
    825825                                </configuration> 
    826826                        </plugin> 
    827  
    828827                        <!-- 
    829828                        <plugin> 
  • postgis/pom.xml

    r1427 r1527  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.2.10-temporals-SNAPSHOT</version> 
     9                <version>3.3.2-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java

    r1520 r1527  
    1010package org.openrdf.sail.postgis.evaluation; 
    1111 
     12import java.text.ParseException; 
     13import java.text.SimpleDateFormat; 
    1214import java.util.ArrayList; 
     15import java.util.Calendar; 
     16import java.util.Date; 
     17import java.util.GregorianCalendar; 
    1318import java.util.List; 
    14  
     19import java.util.TimeZone; 
     20 
     21import org.openrdf.query.algebra.evaluation.function.datetime.Timezone; 
    1522import org.openrdf.query.algebra.evaluation.function.spatial.AbstractWKT; 
    1623import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 
     
    107114import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Touches; 
    108115import org.openrdf.sail.generaldb.algebra.sf.GeneralDBSqlSF_Within; 
     116import org.openrdf.sail.generaldb.algebra.temporal.*; 
    109117import org.openrdf.sail.generaldb.evaluation.GeneralDBQueryBuilder; 
    110118import org.openrdf.sail.generaldb.evaluation.GeneralDBSqlBracketBuilder; 
     
    122130 *  
    123131 * @author Manos Karpathiotakis <mk@di.uoa.gr> 
     132 * @author Konstantina Bereta <Konstantina.Bereta@di.uoa.gr> 
    124133 * @author Dimitrianos Savva <dimis@di.uoa.gr> 
     134 *  
    125135 */ 
    126136public class PostGISQueryBuilder extends GeneralDBQueryBuilder { 
     
    130140        public static final String ST_TRANSFORM         = "ST_Transform"; 
    131141        public static final String ST_ASBINARY          = "ST_AsBinary"; 
     142        public static final String PERIOD_COLUMN = "period"; //this is the name of the period column in period_values table 
    132143        public static final String GEOGRAPHY            = "Geography"; 
    133144        public static final String GEOMETRY                     = "Geometry"; 
    134145         
     146        public static final String PERIOD_TO_CSTRING="period_out"; //postgres temporal functions for converting period to cstring 
     147        public static final String CSTRING_TO_TEXT="textin"; //postres function for converting cstring to text 
    135148        /** 
    136149         * If (spatial) label column met is null, I must not try to retrieve its srid.  
     
    276289                } 
    277290                else { 
     291                        String alias = getLabelAlias(var.getRdbmsVar()); 
     292 
    278293                        if(var.isSpatial()) 
    279294                        { 
     
    283298                                filter.appendFunction(ST_TRANSFORM); 
    284299                                filter.openBracket(); 
     300                                System.out.println("267"); 
    285301                                // 
    286                                 String alias = getLabelAlias(var.getRdbmsVar()); 
     302                                alias = getLabelAlias(var.getRdbmsVar()); 
    287303 
    288304                                filter.column(alias, STRDFGEO_FIELD); 
     
    298314                                filter.column(alias, SRID_FIELD); 
    299315                        } 
    300                         else 
    301                         { 
     316                        else if(var.isTemporal()) 
     317                        { 
     318                                //textin(period_out(period)) 
     319                                filter.appendFunction(CSTRING_TO_TEXT); 
     320                                filter.openBracket(); 
     321                                filter.appendFunction(PERIOD_TO_CSTRING); 
     322                                filter.openBracket(); 
     323                                filter.column(alias,PERIOD_COLUMN); 
     324                                filter.closeBracket(); 
     325                                filter.closeBracket(); 
     326                        } 
     327                        else{ 
    302328                                //XXX original/default case 
    303                                 String alias = getLabelAlias(var.getRdbmsVar()); 
     329                                //System.out.println("DEFAUUUUULT!: a value column will be printed"); 
    304330                                filter.column(alias, "value"); 
    305331                        } 
     
    359385        public GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) throws UnsupportedRdbmsOperatorException 
    360386        { 
     387                boolean isTemporalConstruct = false; 
     388                 
    361389                if(!(expr instanceof GeneralDBSqlSpatialMetricBinary)  
    362390                                &&!(expr instanceof GeneralDBSqlSpatialMetricTriple) 
     
    364392                                &&!(expr instanceof GeneralDBSqlMathExpr) 
    365393                                &&!(expr instanceof GeneralDBSqlSpatialProperty) 
    366                                 && !(expr instanceof GeneralDBSqlGeoSpatial)) 
    367                 { 
     394                                && !(expr instanceof GeneralDBSqlGeoSpatial) 
     395                                &&!(expr instanceof GeneralDBSqlTemporalConstructUnary) 
     396                                &&!(expr instanceof GeneralDBSqlTemporalConstructBinary)) 
     397                { 
     398                         
    368399                        query.select().appendFunction(ST_ASBINARY); 
     400                } 
     401                else if( expr instanceof GeneralDBSqlTemporalConstructBinary) 
     402                { 
     403                        isTemporalConstruct = true; 
     404                        query.select().append(CSTRING_TO_TEXT); 
     405                        query.select.append("("); 
     406                        query.select.append(PERIOD_TO_CSTRING+"("); 
    369407                } 
    370408                else 
     
    381419                        dispatchUnarySqlOperator((UnaryGeneralDBOperator) expr, query.select); 
    382420                } 
    383                 else if(expr instanceof GeneralDBSqlSpatialMetricTriple) 
     421                 
     422else if(expr instanceof GeneralDBSqlSpatialMetricTriple) 
    384423                { 
    385424                        dispatchTripleSqlOperator((GeneralDBSqlSpatialMetricTriple) expr, query.select); 
     
    389428                        dispatchTripleSqlOperator((GeneralDBSqlSpatialConstructTriple) expr, query.select); 
    390429                } 
     430 
     431 
     432               else if(expr instanceof GeneralDBSqlSpatialMetricTriple) 
     433                { 
     434                        dispatchTripleSqlOperator((GeneralDBSqlSpatialMetricTriple) expr, query.select); 
     435                } 
     436                else if(expr instanceof GeneralDBSqlSpatialConstructTriple) 
     437                { 
     438                        dispatchTripleSqlOperator((GeneralDBSqlSpatialConstructTriple) expr, query.select); 
     439                } 
     440 
     441                else if(expr instanceof GeneralDBSqlSpatialConstructTriple) 
     442                { 
     443                        dispatchTripleSqlOperator((GeneralDBSqlSpatialConstructTriple) expr, query.select); 
     444                } 
    391445                //SRID support must be explicitly added! 
     446                if(isTemporalConstruct) 
     447                { 
     448                        query.select.append("))");       
     449                } 
     450 
    392451 
    393452                return this; 
     
    830889                appendGeneralDBSpatialFunctionUnary(expr, filter, SpatialFunctionsPostGIS.ST_AsGML); 
    831890        } 
    832  
     891         
     892         
    833893/*       
     894 
    834895   @Override 
    835896        protected void append(GeneralDBSqlGeoSrid expr, GeneralDBSqlExprBuilder filter) 
     
    10091070                return raw; 
    10101071        } 
     1072         
     1073        /*Temporal Functions 
     1074         *  
     1075         * */ 
     1076         
     1077        protected String appendPeriodConstant(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 
     1078        { 
     1079                GeneralDBStringValue arg = (GeneralDBStringValue) expr; 
     1080                String period = arg.getValue(); 
     1081                 
     1082                //FIXME period constant should be validated before appended 
     1083                if(period.equalsIgnoreCase("now")) 
     1084                { 
     1085                        filter.append("period(now())"); 
     1086                } 
     1087                else if(period.equalsIgnoreCase("uc")) 
     1088                { 
     1089                           TimeZone UTC = TimeZone.getTimeZone("UTC"); 
     1090                            final Calendar c = new GregorianCalendar(UTC); 
     1091                            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
     1092                            
     1093                            c.set(1, 0, 1, 0, 0, 0); 
     1094                            c.set(Calendar.MILLISECOND, 0); 
     1095                            Date begin = c.getTime(); 
     1096                            c.setTime(new Date(Long.MAX_VALUE)); 
     1097                            Date end = c.getTime(); 
     1098                            try { 
     1099                                        format.parse(end.toString()); 
     1100                                } catch (ParseException e) { 
     1101                                        // TODO Auto-generated catch block 
     1102                                        e.printStackTrace(); 
     1103                                } 
     1104                        filter.append("period("+ end +")"); 
     1105                } 
     1106                else 
     1107                { 
     1108                        if(period.contains(",")) //valid time is a period 
     1109                        { 
     1110                                filter.append("period_in(textout('"+period+"'))");               
     1111                        } 
     1112                        else // valid time is an instant 
     1113                        { 
     1114 
     1115                                String instant =period.substring(period.indexOf('[')+1, period.indexOf(']')); 
     1116                                if (expr.getParentNode() instanceof GeneralDBSqlPeriod) 
     1117                                { 
     1118                                        filter.append("to_timestamp('"+instant+ "','YYYY-MM-DD HH:MI:SS.MS')"); 
     1119                                } 
     1120                                else 
     1121                                { 
     1122                                        filter.append("period(to_timestamp('"+instant+ "','YYYY-MM-DD HH:MI:SS.MS'))"); 
     1123                                } 
     1124                        } 
     1125                 
     1126                } 
     1127                return period; 
     1128        } 
     1129         
     1130        @Override 
     1131        protected void append(GeneralDBSqlPeriodContainedBy expr, GeneralDBSqlExprBuilder filter) 
     1132                        throws UnsupportedRdbmsOperatorException 
     1133                        { 
     1134                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1135                        } 
     1136         
     1137        @Override 
     1138        protected void append(GeneralDBSqlPeriodContains expr, GeneralDBSqlExprBuilder filter) 
     1139                        throws UnsupportedRdbmsOperatorException 
     1140                        { 
     1141                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1142                        } 
     1143 
     1144        @Override 
     1145        protected void append(GeneralDBSqlPeriodOverlaps expr, GeneralDBSqlExprBuilder filter) 
     1146                        throws UnsupportedRdbmsOperatorException 
     1147                        { 
     1148                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1149                        } 
     1150 
     1151        @Override 
     1152        protected void append(GeneralDBSqlPeriodIntersects expr, GeneralDBSqlExprBuilder filter) 
     1153                        throws UnsupportedRdbmsOperatorException 
     1154                        { 
     1155                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1156                        } 
     1157 
     1158        @Override 
     1159        protected void append(GeneralDBSqlAfterPeriod expr, GeneralDBSqlExprBuilder filter) 
     1160                        throws UnsupportedRdbmsOperatorException 
     1161                        { 
     1162                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1163                        } 
     1164         
     1165        @Override 
     1166        protected void append(GeneralDBSqlBeforePeriod expr, 
     1167                        GeneralDBSqlExprBuilder filter) 
     1168                        throws UnsupportedRdbmsOperatorException { 
     1169                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1170                 
     1171        } 
     1172        @Override 
     1173        protected void append(GeneralDBSqlOverrightPeriod expr, 
     1174                        GeneralDBSqlExprBuilder filter) 
     1175                        throws UnsupportedRdbmsOperatorException { 
     1176                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1177                 
     1178        } 
     1179        @Override 
     1180        protected void append(GeneralDBSqlOverleftPeriod expr, 
     1181                        GeneralDBSqlExprBuilder filter) 
     1182                        throws UnsupportedRdbmsOperatorException { 
     1183                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1184                 
     1185        } 
     1186        @Override 
     1187        protected void append(GeneralDBSqlEqualsPeriod expr, 
     1188                        GeneralDBSqlExprBuilder filter) 
     1189                        throws UnsupportedRdbmsOperatorException { 
     1190                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1191                 
     1192        } 
     1193        @Override 
     1194        protected void append(GeneralDBSqlNequalsPeriod expr, 
     1195                        GeneralDBSqlExprBuilder filter) 
     1196                        throws UnsupportedRdbmsOperatorException { 
     1197                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1198                 
     1199        } 
     1200         
     1201        @Override 
     1202        protected void append(GeneralDBSqlMeets expr, 
     1203                        GeneralDBSqlExprBuilder filter) 
     1204                        throws UnsupportedRdbmsOperatorException { 
     1205                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1206                 
     1207        } 
     1208         
     1209        @Override 
     1210        protected void append(GeneralDBSqlStarts expr, 
     1211                        GeneralDBSqlExprBuilder filter) 
     1212                        throws UnsupportedRdbmsOperatorException { 
     1213                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1214                 
     1215        } 
     1216        @Override 
     1217        protected void append(GeneralDBSqlFinishes expr, 
     1218                        GeneralDBSqlExprBuilder filter) 
     1219                        throws UnsupportedRdbmsOperatorException { 
     1220                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1221                 
     1222        } 
     1223        @Override 
     1224        protected void append(GeneralDBSqlAdjacentPeriod expr, 
     1225                        GeneralDBSqlExprBuilder filter) 
     1226                        throws UnsupportedRdbmsOperatorException { 
     1227                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1228                 
     1229        } 
     1230         
     1231         
     1232        @Override 
     1233        protected void append(GeneralDBSqlPeriodIntersection expr, GeneralDBSqlExprBuilder filter) 
     1234                        throws UnsupportedRdbmsOperatorException 
     1235                        { 
     1236                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1237                        } 
     1238         
     1239        @Override 
     1240        protected void append(GeneralDBSqlPeriodMinus expr, GeneralDBSqlExprBuilder filter) 
     1241                        throws UnsupportedRdbmsOperatorException 
     1242                        { 
     1243                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1244                        } 
     1245        @Override 
     1246        protected void append(GeneralDBSqlPeriod expr, GeneralDBSqlExprBuilder filter) 
     1247                        throws UnsupportedRdbmsOperatorException 
     1248                        { 
     1249                appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1250                        } 
     1251         
     1252        @Override 
     1253        protected void append(GeneralDBSqlPeriodUnion expr, GeneralDBSqlExprBuilder filter) 
     1254                        throws UnsupportedRdbmsOperatorException 
     1255                        { 
     1256        appendGeneralDBTemporalFunctionBinary(expr, filter, expr.getPostgresFunction()); 
     1257                        } 
     1258 
     1259        @Override 
     1260        protected void append(GeneralDBSqlPeriodStart expr, GeneralDBSqlExprBuilder filter) 
     1261                        throws UnsupportedRdbmsOperatorException 
     1262                        { 
     1263        appendGeneralDBTemporalFunctionUnary(expr, filter, expr.getPostgresFunction()); 
     1264                        } 
     1265 
     1266        @Override 
     1267        protected void append(GeneralDBSqlPeriodEnd expr, GeneralDBSqlExprBuilder filter) 
     1268                        throws UnsupportedRdbmsOperatorException 
     1269                        { 
     1270        appendGeneralDBTemporalFunctionUnary(expr, filter, expr.getPostgresFunction()); 
     1271                        } 
     1272 
     1273 
     1274 
     1275 
     1276 
     1277 
     1278         
    10111279 
    10121280        protected String appendConstantWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) throws UnsupportedRdbmsOperatorException 
     
    12171485                filter.openBracket(); 
    12181486                filter.appendFunction(ST_TRANSFORM); 
     1487                System.out.println("1328"); 
    12191488                filter.openBracket(); 
    12201489 
     
    12781547                                        filter.appendFunction(ST_TRANSFORM); 
    12791548                                        filter.openBracket(); 
     1549                                        System.out.println("1390"); 
    12801550                                } 
    12811551                        } 
     
    14681738        //Used in all the generaldb stsparql (and geosparql) boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
    14691739        //EXCEPT ST_Transform!!! 
    1470         protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) throws UnsupportedRdbmsOperatorException 
     1740        protected void appendGeneralDBTemporalFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, String func) 
     1741                        throws UnsupportedRdbmsOperatorException 
     1742                        { 
     1743         
     1744                //filter.openBracket(); 
     1745 
     1746                boolean check1 = expr.getLeftArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 
     1747                boolean check2 = expr.getRightArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 
     1748 
     1749                if(check1) 
     1750                { 
     1751                        this.append((GeneralDBSqlNull)expr.getLeftArg(), filter); 
     1752 
     1753                } 
     1754                else if(check2) 
     1755                { 
     1756                        this.append((GeneralDBSqlNull)expr.getRightArg(), filter); 
     1757                } 
     1758                else 
     1759                { 
     1760 
     1761                        GeneralDBSqlExpr tmp = expr; 
     1762                        if(tmp instanceof GeneralDBSqlTemporalConstructBinary && tmp.getParentNode() == null) 
     1763                        { 
     1764                                while(true) 
     1765                                { 
     1766                                        GeneralDBSqlExpr child; 
     1767 
     1768                                        if(tmp instanceof BinaryGeneralDBOperator) 
     1769                                        { 
     1770                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 
     1771                                        } 
     1772                                        else //(tmp instanceof UnaryGeneralDBOperator) 
     1773                                        { 
     1774                                                child = ((UnaryGeneralDBOperator) tmp).getArg(); 
     1775                                        } 
     1776 
     1777                                        tmp = child; 
     1778                                        if(tmp instanceof GeneralDBLabelColumn) 
     1779                                        { 
     1780                         
     1781                                                break; 
     1782                                        } 
     1783                                        else if (tmp instanceof GeneralDBStringValue) //Constant!! 
     1784                                        { 
     1785                                                                                                break; 
     1786                                        } 
     1787 
     1788                                } 
     1789                                 
     1790                        } 
     1791                        ///// 
     1792                        filter.appendFunction(func); //postgres temporal operators get deprecated. I will use the function names instead- constant 
     1793                        filter.openBracket(); 
     1794                         
     1795                        if (expr.getLeftArg() instanceof GeneralDBSqlTemporalConstructBinary) 
     1796                        { 
     1797                                appendConstructFunction(expr.getLeftArg(), filter); 
     1798                        } 
     1799                        else if(expr.getLeftArg() instanceof GeneralDBStringValue) 
     1800                        { 
     1801                                appendPeriodConstant(expr.getLeftArg(), filter); 
     1802                        } 
     1803                        else if(expr instanceof GeneralDBSqlPeriod) 
     1804                        { 
     1805                                filter.append("first"); 
     1806                                filter.openBracket(); 
     1807                                appendPeriod((GeneralDBLabelColumn)(tmp),filter); 
     1808                                filter.closeBracket(); 
     1809                                 
     1810                        } 
     1811                        else 
     1812                        {        
     1813                                appendPeriod((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 
     1814                                 
     1815                        } 
     1816                 
     1817                        if(func.equals("=")|| func.equals("!=")|| func.equals("-")|| func.equals("+")|| func.equals("~")||  
     1818                                        func.equals("@")|| func.equals("<<")|| func.equals(">>")|| func.equals("&<")|| func.equals("&>")|| func.equals("&&")) 
     1819                        { 
     1820                                filter.append(" "); 
     1821                                filter.appendFunction(func); 
     1822                                filter.append(" "); 
     1823                        } 
     1824                         
     1825                //TODO:Think about adding more temporal function types (e.g., metrics, unary operators) 
     1826                         
     1827                        /*else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructUnary) 
     1828                        { 
     1829                                appendConstructFunction(expr.getLeftArg(), filter); 
     1830                        } 
     1831                        else if(expr.getLeftArg(functionName) instanceof GeneralDBSqlCase) 
     1832                        { 
     1833                                GeneralDBLabelColumn onlyLabel = (GeneralDBLabelColumn)((GeneralDBSqlCase)expr.getLeftArg()).getEntries().get(0).getResult(); 
     1834                                appendMBB(onlyLabel,filter);  
     1835                        } 
     1836                        else 
     1837                        { 
     1838                                appendMBB((GeneralDBLabelColumn)(expr.getLeftArg()),filter); 
     1839                        }*/ 
     1840                        //filter.appendComma(); 
     1841 
     1842                                                //filter.openBracket(); 
     1843                        filter.appendComma(); 
     1844                        if (expr.getRightArg() instanceof GeneralDBSqlTemporalConstructBinary) 
     1845                        { 
     1846                                appendConstructFunction(expr.getRightArg(), filter); 
     1847                        } 
     1848                        else if(expr.getRightArg() instanceof GeneralDBStringValue) 
     1849                        { 
     1850                                appendPeriodConstant(expr.getRightArg(), filter); 
     1851                        } 
     1852                        else if (expr instanceof GeneralDBSqlPeriod) 
     1853                        { 
     1854                                filter.append("first"); 
     1855                                filter.openBracket(); 
     1856                                appendPeriod((GeneralDBLabelColumn)(expr.getRightArg()),filter); 
     1857                                filter.closeBracket(); 
     1858 
     1859                        } 
     1860                        else 
     1861                        { 
     1862                                appendPeriod((GeneralDBLabelColumn)(expr.getRightArg()),filter); 
     1863                        } 
     1864 
     1865                } 
     1866                filter.closeBracket(); 
     1867 
     1868 
     1869                        } 
     1870         
     1871        protected void appendGeneralDBTemporalFunctionUnary(UnaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, String func) 
     1872                        throws UnsupportedRdbmsOperatorException 
     1873                        { 
     1874         
     1875                //filter.openBracket(); 
     1876 
     1877                boolean check1 = expr.getArg().getClass().getCanonicalName().equals("org.openrdf.sail.generaldb.algebra.GeneralDBSqlNull"); 
     1878 
     1879                if(check1) 
     1880                { 
     1881                        this.append((GeneralDBSqlNull)expr.getArg(), filter); 
     1882 
     1883                } 
     1884                else 
     1885                { 
     1886 
     1887                        GeneralDBSqlExpr tmp = expr; 
     1888                        if(tmp instanceof GeneralDBSqlTemporalConstructUnary && tmp.getParentNode() == null) 
     1889                        { 
     1890                                while(true) 
     1891                                { 
     1892                                        GeneralDBSqlExpr child; 
     1893 
     1894                                        if(tmp instanceof BinaryGeneralDBOperator) 
     1895                                        { 
     1896                                                child = ((BinaryGeneralDBOperator) tmp).getLeftArg(); 
     1897                                        } 
     1898                                        else //(tmp instanceof UnaryGeneralDBOperator) 
     1899                                        { 
     1900                                                child = ((UnaryGeneralDBOperator) tmp).getArg(); 
     1901                                        } 
     1902 
     1903                                        tmp = child; 
     1904                                        if(tmp instanceof GeneralDBLabelColumn) 
     1905                                        { 
     1906                         
     1907                                                break; 
     1908                                        } 
     1909                                        else if (tmp instanceof GeneralDBStringValue) //Constant!! 
     1910                                        { 
     1911                                                                                                break; 
     1912                                        } 
     1913 
     1914                                } 
     1915                                 
     1916                        } 
     1917                        ///// 
     1918                        filter.appendFunction(func); //postgres temporal operators get deprecated. I will use the function names instead- constant 
     1919                        filter.openBracket(); 
     1920                        if ((expr.getArg() instanceof GeneralDBSqlTemporalConstructBinary) || (expr.getArg() instanceof GeneralDBSqlTemporalConstructUnary)) 
     1921                        { 
     1922                                appendConstructFunction(expr.getArg(), filter); 
     1923                        } 
     1924                        else if(expr.getArg() instanceof GeneralDBStringValue) 
     1925                        { 
     1926                                appendPeriodConstant(expr.getArg(), filter); 
     1927                        } 
     1928                        else 
     1929                        {                        
     1930                                appendPeriod((GeneralDBLabelColumn)(expr.getArg()),filter); 
     1931 
     1932                        } 
     1933 
     1934                } 
     1935                filter.closeBracket(); 
     1936 
     1937 
     1938                        } 
     1939        protected void appendGeneralDBSpatialFunctionBinary(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) 
     1940                        throws UnsupportedRdbmsOperatorException 
    14711941        { 
    14721942                //In the case where no variable is present in the expression! e.g ConvexHull("POLYGON((.....))") 
     
    15432013                                        filter.appendFunction(ST_TRANSFORM); 
    15442014                                        filter.openBracket(); 
     2015                                        System.out.println("1687"); 
    15452016                                } 
    15462017                        } 
     
    21532624                        GeneralDBSqlExpr tmp = expr; 
    21542625 
    2155  
    21562626                        if(tmp instanceof GeneralDBSqlSpatialConstructUnary && tmp.getParentNode() == null) 
    21572627                        { 
     
    22082678                                        filter.appendFunction(ST_TRANSFORM); 
    22092679                                        filter.openBracket(); 
     2680                                        System.out.println("before switch"); 
    22102681                                } 
    22112682                        } 
     
    30393510        } 
    30403511 
     3512         
     3513 
    30413514} 
  • postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java

    r1469 r1527  
    12781278         
    12791279 
     1280        protected String appendConstantWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) throws UnsupportedRdbmsOperatorException 
     1281        { 
     1282                GeneralDBStringValue arg = (GeneralDBStringValue) expr; 
     1283                String raw = arg.getValue(); 
     1284                 
     1285                // parse raw WKT 
     1286                AbstractWKT wkt = new AbstractWKT(raw); 
     1287                // transform constant geometry to the default SRID 
     1288                filter.append("ST_Transform("); 
     1289                filter.append(" ST_GeomFromText('" + wkt.getWKT() + "'," + String.valueOf(wkt.getSRID()) + ")"); 
     1290                filter.append(", "+GeoConstants.defaultSRID +")"); 
     1291                 
     1292                return raw; 
     1293        } 
     1294         
    12801295        //Used in all the generaldb boolean spatial functions of the form ?GEO1 ~ ?GEO2  
    12811296        //      protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException 
     
    20032018                        ///// 
    20042019 
    2005  
     2020                        //case where both arguments are constnats 
     2021                        boolean constantArgs = false;    
    20062022 
    20072023                        switch(func) 
     
    20122028                        case ST_Union: filter.appendFunction("ST_Union"); break; 
    20132029                        case ST_SymDifference: filter.appendFunction("ST_SymDifference"); break; 
    2014                         case ST_Buffer: filter.appendFunction("ST_Buffer"); break; 
    20152030                         
    20162031                        // PostGIS 
     
    20302045                        if(expr.getLeftArg() instanceof GeneralDBStringValue) 
    20312046                        { 
    2032                                 appendWKT(expr.getLeftArg(),filter); 
     2047                                if(expr.getRightArg() instanceof GeneralDBStringValue) 
     2048                                {        
     2049                                        //both arguments are constants so we do not need 
     2050                                        //to transform the geometries to WGS84 
     2051                                        constantArgs = true; 
     2052                                        appendWKT(expr.getLeftArg(), filter); 
     2053                                } 
     2054                                else 
     2055                                        appendConstantWKT(expr.getLeftArg(), filter); 
    20332056                        } 
    20342057                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 
     
    20572080                        if(expr.getRightArg() instanceof GeneralDBStringValue) 
    20582081                        { 
    2059                                 appendWKT(expr.getRightArg(),filter); 
     2082                                if(constantArgs == true) 
     2083                                        // both arguments are constants, so we do not need 
     2084                                        // to transform the geometries to WGS84 
     2085                                        appendWKT(expr.getRightArg(), filter); 
     2086                                else 
     2087                                        appendConstantWKT(expr.getRightArg(),filter); 
    20602088                        } 
    20612089                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 
     
    23162344        } 
    23172345 
    2318         //Buffer function 
     2346        //Buffer function (Giannis: dont get deceived by "filter". It also applies for the case the buffer occurs in the select clause too) 
    23192347        protected void appendBuffer(TripleGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) throws UnsupportedRdbmsOperatorException 
    23202348        { 
     
    23852413                                        else if (tmp instanceof GeneralDBStringValue) //Constant!! 
    23862414                                        { 
    2387                                                 sridNeeded  = false; 
     2415                                                sridNeeded  = true; 
    23882416                                                sridExpr = String.valueOf(WKTHelper.getSRID(((GeneralDBStringValue) tmp).getValue())); 
    23892417                                                break; 
  • resultio-spatial/api/pom.xml

    r1427 r1527  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/pom.xml

    r1427 r1527  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlgeojson/pom.xml

    r1427 r1527  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlhtml/pom.xml

    r1427 r1527  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlkml/pom.xml

    r1427 r1527  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.2.10-temporals-SNAPSHOT</version> 
     8                <version>3.3.2-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlkml/src/main/java/org/openrdf/query/resultio/sparqlkml/stSPARQLResultsKMLWriter.java

    r1478 r1527  
    1111import java.io.IOException; 
    1212import java.io.OutputStream; 
     13import java.util.ArrayList; 
    1314import java.util.Hashtable; 
    1415import java.util.List; 
     
    4950 
    5051import eu.earthobservatory.constants.GeoConstants; 
     52import eu.earthobservatory.constants.TemporalConstants; 
    5153 
    5254/** 
     
    5456 * @author Charalampos Nikolaou <charnik@di.uoa.gr> 
    5557 * @author Panayiotis Smeros <psmeros@di.uoa.gr> 
     58 * @author George Garbis <ggarbis@di.uoa.gr> 
    5659 * @author Konstantina Bereta <konstantina.bereta@di.uoa.gr> 
    5760 */ 
     
    6467        protected static final String RESULT_SET_TAG    = "Folder"; 
    6568        protected static final String PLACEMARK_TAG     = "Placemark"; 
     69        protected static final String DOCUMENT_TAG      = "Document"; 
    6670        protected static final String TIMESTAMP_TAG     = "TimeStamp"; 
    6771        protected static final String TIMESPAN_TAG              = "TimeSpan"; 
     
    7579        protected static final String VALUE_TAG                 = "value"; 
    7680        protected static final String NAME_ATTR                 = NAME_TAG; 
     81         
     82        protected static final String STYLE_TAG         = "Style"; 
     83        protected static final String POLY_STYLE_TAG    = "PolyStyle"; 
    7784 
    7885        protected static final String TABLE_ROW_BEGIN   = "<TR>"; 
     
    8491        protected static final String TABLE_DESC_END    = "</TABLE>]]>" + NEWLINE; 
    8592 
     93         
    8694        /** 
    8795         * The underlying XML formatter. 
     
    137145        protected int depth; 
    138146 
     147        /** 
     148         * List of names of predefined KML styles 
     149         */ 
     150        private List<String> styleNames = new ArrayList<String>(4); 
     151         
    139152        /** 
    140153         * Creates an stSPARQLResultsKMLWriter that encodes the SPARQL results in