Changeset 1019:f488c7c3d433


Ignore:
Timestamp:
04/09/13 02:16:25 (6 years ago)
Author:
Babis Nikolaou <charnik@…>
Branch:
default
Message:

made RDFS Entailment of GeoSPARQL work in one pass over the input

Location:
runtime/src/main/java/eu/earthobservatory/runtime/generaldb
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • runtime/src/main/java/eu/earthobservatory/runtime/generaldb/GeneralDBSailRepositoryConnection.java

    r1016 r1019  
    1010package eu.earthobservatory.runtime.generaldb; 
    1111 
     12import java.io.IOException; 
     13import java.io.InputStream; 
     14import java.io.Reader; 
     15 
     16import org.openrdf.OpenRDFUtil; 
     17import org.openrdf.model.Resource; 
     18import org.openrdf.repository.RepositoryException; 
    1219import org.openrdf.repository.sail.SailRepository; 
    1320import org.openrdf.repository.sail.SailRepositoryConnection; 
     21import org.openrdf.repository.util.RDFInserter; 
     22import org.openrdf.rio.RDFFormat; 
     23import org.openrdf.rio.RDFHandlerException; 
     24import org.openrdf.rio.RDFParseException; 
     25import org.openrdf.rio.RDFParser; 
     26import org.openrdf.rio.Rio; 
     27import org.openrdf.rio.UnsupportedRDFormatException; 
     28import org.openrdf.rio.helpers.ParseErrorLogger; 
    1429import org.openrdf.sail.SailConnection; 
    1530 
     
    2843        } 
    2944         
    30         // TODO add the respective add method that will call an extension of the RDFInserter 
     45        /** 
     46         * Adds the data that can be read from the supplied InputStream or Reader to 
     47         * this repository.  
     48         *  
     49         * This method is exactly like the one defined in class {@link RepositoryConnectionBase}, 
     50         * except for the fact that uses ???? as the RDF handler to triple insertion instead of 
     51         * the Sesame's default {@link RDFInserter}.  
     52         *  
     53         * @param inputStreamOrReader 
     54         *        An {@link InputStream} or {@link Reader} containing RDF data that 
     55         *        must be added to the repository. 
     56         * @param baseURI 
     57         *        The base URI for the data. 
     58         * @param dataFormat 
     59         *        The file format of the data. 
     60         * @param contexts 
     61         *        The context(s) to which the data should be added. 
     62         * @throws IOException 
     63         * @throws UnsupportedRDFormatException 
     64         * @throws RDFParseException 
     65         * @throws RepositoryException 
     66         */ 
     67        @Override 
     68        protected void addInputStreamOrReader(Object inputStreamOrReader, String baseURI, RDFFormat dataFormat, Resource... contexts)  
     69                                                                                                                                                throws IOException, RDFParseException, RepositoryException { 
     70                OpenRDFUtil.verifyContextNotNull(contexts); 
     71 
     72                RDFParser rdfParser = Rio.createParser(dataFormat, getRepository().getValueFactory()); 
     73                rdfParser.setParserConfig(getParserConfig()); 
     74                rdfParser.setParseErrorListener(new ParseErrorLogger()); 
     75 
     76                //RDFInserter rdfInserter = new RDFInserter(this); 
     77                RDFInserter rdfInserter = new GeosparqlRDFHandlerBase(this); 
     78                rdfInserter.enforceContext(contexts); 
     79                rdfParser.setRDFHandler(rdfInserter); 
     80 
     81                boolean autoCommit = isAutoCommit(); 
     82                setAutoCommit(false); 
     83 
     84                try { 
     85                        if (inputStreamOrReader instanceof InputStream) { 
     86                                rdfParser.parse((InputStream)inputStreamOrReader, baseURI); 
     87                        } 
     88                        else if (inputStreamOrReader instanceof Reader) { 
     89                                rdfParser.parse((Reader)inputStreamOrReader, baseURI); 
     90                        } 
     91                        else { 
     92                                throw new IllegalArgumentException( 
     93                                                "inputStreamOrReader must be an InputStream or a Reader, is a: " 
     94                                                                + inputStreamOrReader.getClass()); 
     95                        } 
     96                } 
     97                catch (RDFHandlerException e) { 
     98                        if (autoCommit) { 
     99                                rollback(); 
     100                        } 
     101                        // RDFInserter only throws wrapped RepositoryExceptions 
     102                        throw (RepositoryException)e.getCause(); 
     103                } 
     104                catch (RuntimeException e) { 
     105                        if (autoCommit) { 
     106                                rollback(); 
     107                        } 
     108                        throw e; 
     109                } 
     110                finally { 
     111                        setAutoCommit(autoCommit); 
     112                } 
     113        } 
     114 
    31115 
    32116} 
  • runtime/src/main/java/eu/earthobservatory/runtime/generaldb/GeosparqlRDFHandlerBase.java

    r1018 r1019  
    1111 
    1212import java.io.StringReader; 
    13  
     13import java.util.Hashtable; 
     14 
     15import org.openrdf.model.Resource; 
    1416import org.openrdf.model.Statement; 
     17import org.openrdf.model.URI; 
     18import org.openrdf.model.Value; 
     19import org.openrdf.model.impl.ContextStatementImpl; 
     20import org.openrdf.model.impl.StatementImpl; 
     21import org.openrdf.model.impl.URIImpl; 
    1522import org.openrdf.model.vocabulary.RDF; 
    1623import org.openrdf.model.vocabulary.RDFS; 
    1724import org.openrdf.repository.RepositoryConnection; 
    1825import org.openrdf.repository.util.RDFInserter; 
    19 import org.openrdf.rio.helpers.RDFHandlerBase; 
     26import org.openrdf.rio.RDFHandlerException; 
    2027import org.openrdf.rio.ntriples.NTriplesParser; 
     28import org.slf4j.Logger; 
     29import org.slf4j.LoggerFactory; 
    2130 
    2231import eu.earthobservatory.constants.GeoConstants; 
     
    3140public class GeosparqlRDFHandlerBase extends RDFInserter { 
    3241         
    33         //private static final Logger logger = LoggerFactory.getLogger(eu.earthobservatory.runtime.generaldb.GeosparqlRDFHandlerBase.class); 
    34          
    35         public GeosparqlRDFHandlerBase(RepositoryConnection con) { 
    36                 super(con); 
    37         } 
    38  
     42        private static final Logger logger = LoggerFactory.getLogger(eu.earthobservatory.runtime.generaldb.GeosparqlRDFHandlerBase.class); 
     43         
    3944        private static final boolean ENABLE_INFERENCE = false; 
    4045         
    41         private static String TYPE              = RDF.TYPE.stringValue(); 
    42         private static String CLASS     = RDFS.CLASS.stringValue(); 
    43         private static String SUBCLASS  = RDFS.SUBCLASSOF.stringValue(); 
    44  
    45         private StringBuffer triples = new StringBuffer(1024); 
    46          
     46        private static String TYPE = RDF.TYPE.stringValue(); 
     47 
     48        private Hashtable<String, URI> uriMap; 
     49 
    4750        /**  
    4851         * The number of triples that the "triples" object above contains. 
     
    5053        private int numTriples = 0; 
    5154         
    52         public StringBuffer getTriples() 
    53         { 
    54                 return triples; 
    55         } 
    56          
    57         public int getNumberOfTriples() { 
    58                 return numTriples; 
     55        public GeosparqlRDFHandlerBase(RepositoryConnection con) { 
     56                super(con); 
     57                 
     58                this.uriMap = new Hashtable<String, URI>(); 
     59                 
     60                if (logger.isDebugEnabled()) { 
     61                        logger.debug("[Strabon.GeoSPARQLEntailment] RDFS Entailment Extension of GeoSPARQL started."); 
     62                } 
     63        } 
     64         
     65        /** 
     66         * Inserts the given URI in the hashtable of URIs 
     67         * and retrieves the instance of class URI. 
     68         *  
     69         * @param uri 
     70         * @return 
     71         */ 
     72        private URI getURI(String uri) { 
     73                URI ret = null; 
     74                if ((ret = uriMap.get(uri)) == null) { 
     75                        ret = new URIImpl(uri); 
     76                        uriMap.put(uri, ret); 
     77                } 
     78                 
     79                return ret; 
    5980        } 
    6081         
    6182        @Override 
    62         public void startRDF() { 
     83        public void startRDF() throws RDFHandlerException { 
    6384                if (ENABLE_INFERENCE) { 
    6485                        insertGeoSPARQLClassHierarchy(); 
     
    6889         
    6990        @Override 
    70         public void handleStatement(Statement st) 
     91        public void endRDF() throws RDFHandlerException { 
     92                if (ENABLE_INFERENCE) { 
     93                        logger.info("[Strabon.GeoSPARQLEntailment] Inferred {} triples.", numTriples); 
     94                } 
     95        } 
     96         
     97        /** 
     98         * Inserts an inferred statement using the underlying {@link RDFInserter#handleStatement} 
     99         * method.  
     100         *  
     101         * @param subj 
     102         * @param pred 
     103         * @param obj 
     104         * @param ctxt 
     105         */ 
     106        protected void handleInferredStatement(Resource subj, URI pred, Value obj, Resource ctxt) throws RDFHandlerException { 
     107                Statement stmt; 
     108                 
     109                if (ctxt == null) { 
     110                        stmt = new StatementImpl(subj, pred, obj); 
     111                         
     112                } else { 
     113                        stmt = new ContextStatementImpl(subj, pred, obj, ctxt); 
     114                         
     115                } 
     116                 
     117                super.handleStatement(stmt); 
     118                numTriples++; 
     119        } 
     120         
     121        @Override 
     122        public void handleStatement(Statement st) throws RDFHandlerException 
    71123        { 
    72                 String subj = st.getSubject().toString(); 
     124                // pass it to RDFInserter first 
     125                super.handleStatement(st); 
     126                 
     127                // now we do our play 
    73128                String pred = st.getPredicate().toString(); 
    74129                String obj = st.getObject().toString(); 
     
    86141                if( pred.startsWith(GeoSPARQL.GEO+"sf") || 
    87142                        pred.startsWith(GeoSPARQL.GEO+"eh") ||  
    88                         pred.startsWith(GeoSPARQL.GEO+"rcc8")) 
    89                 { 
    90                         writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
    91                         writeTriple(obj, TYPE, GeoSPARQL.SpatialObject); 
     143                        pred.startsWith(GeoSPARQL.GEO+"rcc8")) { 
     144                         
     145                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
     146                        if (st.getObject() instanceof Resource) { // necessary check, because it could be a Literal 
     147                                handleInferredStatement((Resource) st.getObject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
     148                        } 
    92149                } 
    93150                /* Infer  
     
    98155                 *              subj rdf:type geo:Geometry  
    99156                 */ 
    100                 else if(pred.equals(TYPE) && (obj.equals(GeoSPARQL.Feature) || obj.equals(GeoSPARQL.Geometry))) 
    101                 { 
    102                         writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     157                else if(pred.equals(TYPE) && (obj.equals(GeoSPARQL.Feature) || obj.equals(GeoSPARQL.Geometry))) { 
     158                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    103159                }  
    104160                /* 
     
    115171                else if(pred.equals(GeoSPARQL.hasGeometry) || pred.equals(GeoSPARQL.hasDefaultGeometry)) 
    116172                { 
    117                         writeTriple(subj, TYPE, GeoSPARQL.Feature); 
    118                         writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
    119                          
    120                         writeTriple(obj, TYPE, GeoSPARQL.Feature); 
    121                         writeTriple(obj, TYPE, GeoSPARQL.SpatialObject); 
     173                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Feature), st.getContext()); 
     174                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
     175 
     176                        if (st.getObject() instanceof Resource) { // necessary check, because it could be a Literal 
     177                                handleInferredStatement((Resource) st.getObject(), RDF.TYPE, getURI(GeoSPARQL.Feature), st.getContext()); 
     178                                handleInferredStatement((Resource) st.getObject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
     179                        } 
    122180                } 
    123181                else if (pred.equals(TYPE)) { 
    124                         // GML class hierarchy 
    125                         if (obj.equals(GeoConstants.GML_OGC + "GM_Complex") 
    126                                         || obj.equals(GeoConstants.GML_OGC + "GM_Aggregate") 
    127                                         || obj.equals(GeoConstants.GML_OGC + "GM_Primitive")) { 
    128                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    129                                                 + "GM_Object" + "> .\n"; 
    130                                 triples.append(triple); 
    131                                 numTriples++; 
    132                         } 
    133                         if (obj.equals(GeoConstants.GML_OGC + "GM_Composite")) { 
    134                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    135                                                 + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
    136                                                 + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
    137                                 triples.append(triple); 
    138                                 numTriples++; 
    139  
    140                         } 
    141                         if (obj.equals(GeoConstants.GML_OGC + "GM_MultiPrimitive")) { 
    142                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    143                                                 + "GM_Aggregate" + "> .\n" + "<" + subj + "> <" 
    144                                                 + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
    145                                 triples.append(triple); 
    146                                 numTriples++; 
    147  
    148                         } 
    149                         if (obj.equals(GeoConstants.GML_OGC + "GM_Point") 
    150                                         || obj.equals(GeoConstants.GML_OGC + "GM_OrientablePrimitive") 
    151                                         || obj.equals(GeoConstants.GML_OGC + "GM_Solid")) { 
    152                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    153                                                 + "GM_Primitive" + "> .\n" + "<" + subj + "> <" 
    154                                                 + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
    155                                 triples.append(triple); 
    156                                 numTriples++; 
    157  
    158                         } 
    159                         if (obj.equals(GeoConstants.GML_OGC + "GM_OrientableCurve") 
    160                                         || obj.equals(GeoConstants.GML_OGC + "GM_OrientableSurface")) { 
    161                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    162                                                 + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
    163                                                 + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
    164                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    165                                                 + "GM_Object" + "> .\n"; 
    166                                 triples.append(triple); 
    167                                 numTriples++; 
    168  
    169                         } 
    170                         if (obj.equals(GeoConstants.GML_OGC + "GM_Curve")) { 
    171                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    172                                                 + "GM_Aggregate" + "> .\n" 
    173                                                 + "<" + subj + "> <" + TYPE +"> <" + GeoConstants.GML_OGC + "GM_OrientableCurve" + "> .\n" 
    174                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientablePrimitive" + "> .\n" 
    175                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
    176                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
    177                                 triples.append(triple); 
    178                                 numTriples++; 
    179  
    180                         } 
    181                         if (obj.equals(GeoConstants.GML_OGC + "GM_Surface")) { 
    182                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC+ "GM_Aggregate" + "> .\n" 
    183                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientableSurface" + "> .\n" 
    184                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientablePrimitive" + "> .\n" 
    185                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
    186                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    187                                                 + "GM_Object" + "> .\n"; 
    188                                 triples.append(triple); 
    189                                 numTriples++; 
    190  
    191                         } 
    192                         if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeCurve")) { 
    193                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    194                                                 + "GM_Aggregate" + "> .\n" + "<" + subj + "> <" 
    195                                                 + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientableCurve" + "> .\n" 
    196                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    197                                                 + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
    198                                                 + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
    199                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    200                                                 + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
    201                                                 + "> <" + GeoConstants.GML_OGC + "GM_Composite" + "> .\n" + "<" 
    202                                                 + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
    203                                                 + "> .\n"; 
    204                                 triples.append(triple); 
    205                                 numTriples++; 
    206  
    207                         } 
    208                         if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeSurface")) { 
    209                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    210                                                 + "GM_OrientableSurface" + "> .\n" + 
    211  
    212                                                 "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    213                                                 + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
    214                                                 + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
    215                                                 + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    216                                                 + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
    217                                                 + "> <" + GeoConstants.GML_OGC + "GM_Composite" + "> .\n" + "<" 
    218                                                 + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
    219                                                 + "> .\n"; 
    220                                 triples.append(triple); 
    221                                 numTriples++; 
    222  
    223                         } 
    224                         if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeSolid")) { 
    225                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    226                                                 + "GM_Solid" + "> .\n" + "<" + subj + "> <" + TYPE 
    227                                                 + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" + "<" 
    228                                                 + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Complex" 
    229                                                 + "> .\n" + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    230                                                 + "GM_Composite" + "> .\n" + "<" + subj + "> <" 
    231                                                 + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
    232                                 triples.append(triple); 
    233                                 numTriples++; 
    234  
    235                         } 
    236                         if (obj.equals(GeoConstants.GML_OGC + "GM_MultiPoint") 
    237                                         || obj.equals(GeoConstants.GML_OGC + "GM_MultiCurve") 
    238                                         || obj.equals(GeoConstants.GML_OGC + "GM_MultiSurface") 
    239                                         || obj.equals(GeoConstants.GML_OGC + "GM_MultiSolid")) { 
    240                                 String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
    241                                                 + "GM_MultiPrimitive" + "> .\n" + "<" + subj + "> <" 
    242                                                 + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Aggregate" + "> .\n" + "<" 
    243                                                 + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
    244                                                 + "> .\n"; 
    245                                 triples.append(triple); 
    246                                 numTriples++; 
    247  
    248                         } 
     182/* THE FOLLOWING CORRESPONDS TO GML AND NEEDS REWRITING TO FIT THAT OF SIMPLE FEATURES */                        
     183//                      // GML class hierarchy 
     184//                      if (obj.equals(GeoConstants.GML_OGC + "GM_Complex") 
     185//                                      || obj.equals(GeoConstants.GML_OGC + "GM_Aggregate") 
     186//                                      || obj.equals(GeoConstants.GML_OGC + "GM_Primitive")) { 
     187//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     188//                                              + "GM_Object" + "> .\n"; 
     189//                      } 
     190//                      if (obj.equals(GeoConstants.GML_OGC + "GM_Composite")) { 
     191//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     192//                                              + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
     193//                                              + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
     194// 
     195//                      } 
     196//                      if (obj.equals(GeoConstants.GML_OGC + "GM_MultiPrimitive")) { 
     197//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     198//                                              + "GM_Aggregate" + "> .\n" + "<" + subj + "> <" 
     199//                                              + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
     200// 
     201//                      } 
     202//                      if (obj.equals(GeoConstants.GML_OGC + "GM_Point") 
     203//                                      || obj.equals(GeoConstants.GML_OGC + "GM_OrientablePrimitive") 
     204//                                      || obj.equals(GeoConstants.GML_OGC + "GM_Solid")) { 
     205//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     206//                                              + "GM_Primitive" + "> .\n" + "<" + subj + "> <" 
     207//                                              + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
     208// 
     209//                      } 
     210//                      if (obj.equals(GeoConstants.GML_OGC + "GM_OrientableCurve") 
     211//                                      || obj.equals(GeoConstants.GML_OGC + "GM_OrientableSurface")) { 
     212//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     213//                                              + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
     214//                                              + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
     215//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     216//                                              + "GM_Object" + "> .\n"; 
     217//                              triples.append(triple); 
     218//                              numTriples++; 
     219// 
     220//                      } 
     221//                      if (obj.equals(GeoConstants.GML_OGC + "GM_Curve")) { 
     222//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     223//                                              + "GM_Aggregate" + "> .\n" 
     224//                                              + "<" + subj + "> <" + TYPE +"> <" + GeoConstants.GML_OGC + "GM_OrientableCurve" + "> .\n" 
     225//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientablePrimitive" + "> .\n" 
     226//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
     227//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
     228// 
     229//                      } 
     230//                      if (obj.equals(GeoConstants.GML_OGC + "GM_Surface")) { 
     231//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC+ "GM_Aggregate" + "> .\n" 
     232//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientableSurface" + "> .\n" 
     233//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientablePrimitive" + "> .\n" 
     234//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
     235//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     236//                                              + "GM_Object" + "> .\n"; 
     237// 
     238//                      } 
     239//                      if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeCurve")) { 
     240//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     241//                                              + "GM_Aggregate" + "> .\n" + "<" + subj + "> <" 
     242//                                              + TYPE + "> <" + GeoConstants.GML_OGC + "GM_OrientableCurve" + "> .\n" 
     243//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     244//                                              + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
     245//                                              + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
     246//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     247//                                              + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
     248//                                              + "> <" + GeoConstants.GML_OGC + "GM_Composite" + "> .\n" + "<" 
     249//                                              + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
     250//                                              + "> .\n"; 
     251// 
     252//                      } 
     253//                      if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeSurface")) { 
     254//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     255//                                              + "GM_OrientableSurface" + "> .\n" + 
     256// 
     257//                                              "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     258//                                              + "GM_OrientablePrimitive" + "> .\n" + "<" + subj 
     259//                                              + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" 
     260//                                              + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     261//                                              + "GM_Complex" + "> .\n" + "<" + subj + "> <" + TYPE 
     262//                                              + "> <" + GeoConstants.GML_OGC + "GM_Composite" + "> .\n" + "<" 
     263//                                              + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
     264//                                              + "> .\n"; 
     265// 
     266//                      } 
     267//                      if (obj.equals(GeoConstants.GML_OGC + "GM_CompositeSolid")) { 
     268//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     269//                                              + "GM_Solid" + "> .\n" + "<" + subj + "> <" + TYPE 
     270//                                              + "> <" + GeoConstants.GML_OGC + "GM_Primitive" + "> .\n" + "<" 
     271//                                              + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Complex" 
     272//                                              + "> .\n" + "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     273//                                              + "GM_Composite" + "> .\n" + "<" + subj + "> <" 
     274//                                              + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" + "> .\n"; 
     275// 
     276//                      } 
     277//                      if (obj.equals(GeoConstants.GML_OGC + "GM_MultiPoint") 
     278//                                      || obj.equals(GeoConstants.GML_OGC + "GM_MultiCurve") 
     279//                                      || obj.equals(GeoConstants.GML_OGC + "GM_MultiSurface") 
     280//                                      || obj.equals(GeoConstants.GML_OGC + "GM_MultiSolid")) { 
     281//                              String triple = "<" + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC 
     282//                                              + "GM_MultiPrimitive" + "> .\n" + "<" + subj + "> <" 
     283//                                              + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Aggregate" + "> .\n" + "<" 
     284//                                              + subj + "> <" + TYPE + "> <" + GeoConstants.GML_OGC + "GM_Object" 
     285//                                              + "> .\n"; 
     286//                      } 
    249287                        /* 
    250288                         * Simple Features class hierarchy 
     
    254292                                SimpleFeatures.Surface.equals(obj) || 
    255293                                SimpleFeatures.GeometryCollection.equals(obj)) {// first level 
    256                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    257                                  
    258                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    259                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     294                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     295                                 
     296                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     297                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    260298                                 
    261299                        } else if (SimpleFeatures.LineString.equals(obj)) { // second level 
    262                                 writeTriple(subj, TYPE, SimpleFeatures.Curve); 
    263                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    264                                  
    265                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    266                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     300                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Curve), st.getContext()); 
     301                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     302                                 
     303                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     304                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    267305                                 
    268306                        } else if (SimpleFeatures.Polygon.equals(obj) ||  
    269307                                           SimpleFeatures.PolyhedralSurface.equals(obj)) { // second level 
    270                                 writeTriple(subj, TYPE, SimpleFeatures.Surface); 
    271                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    272                                  
    273                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    274                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     308                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Surface), st.getContext()); 
     309                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     310                                 
     311                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     312                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    275313                                 
    276314                        } else if (SimpleFeatures.MultiSurface.equals(obj) || 
    277315                                        SimpleFeatures.MultiCurve.equals(obj) || 
    278316                                        SimpleFeatures.MultiPoint.equals(obj)) { // second level 
    279                                 writeTriple(subj, TYPE, SimpleFeatures.GeometryCollection); 
    280                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    281                                  
    282                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    283                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     317                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.GeometryCollection), st.getContext()); 
     318                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     319                                 
     320                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     321                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    284322                                 
    285323                        } else if ( SimpleFeatures.Line.equals(obj) ||  
    286324                                                SimpleFeatures.LinearRing.equals(obj)) { // third level 
    287                                 writeTriple(subj, TYPE, SimpleFeatures.LineString); 
    288                                 writeTriple(subj, TYPE, SimpleFeatures.Curve); 
    289                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    290                                  
    291                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    292                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     325                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.LineString), st.getContext()); 
     326                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Curve), st.getContext()); 
     327                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     328                                 
     329                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     330                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    293331                                 
    294332                        } else if (SimpleFeatures.Triangle.equals(obj)) { // third level 
    295                                 writeTriple(subj, TYPE, SimpleFeatures.Polygon); 
    296                                 writeTriple(subj, TYPE, SimpleFeatures.Surface); 
    297                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    298                                  
    299                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    300                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     333                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Polygon), st.getContext()); 
     334                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Surface), st.getContext()); 
     335                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     336                                 
     337                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     338                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    301339                                 
    302340                        } else if (SimpleFeatures.TIN.equals(obj)) { // third level 
    303                                 writeTriple(subj, TYPE, SimpleFeatures.PolyhedralSurface); 
    304                                 writeTriple(subj, TYPE, SimpleFeatures.Surface); 
    305                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    306                                  
    307                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    308                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     341                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.PolyhedralSurface), st.getContext()); 
     342                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Surface), st.getContext()); 
     343                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     344                                 
     345                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     346                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    309347                                 
    310348                        } else if (SimpleFeatures.MultiPolygon.equals(obj)) { // third level 
    311                                 writeTriple(subj, TYPE, SimpleFeatures.MultiSurface); 
    312                                 writeTriple(subj, TYPE, SimpleFeatures.GeometryCollection); 
    313                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    314                                  
    315                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    316                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     349                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.MultiSurface), st.getContext()); 
     350                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.GeometryCollection), st.getContext()); 
     351                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     352                                 
     353                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     354                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    317355                                 
    318356                        } else if (SimpleFeatures.MultiLineString.equals(obj)) {// third level 
    319                                 writeTriple(subj, TYPE, SimpleFeatures.MultiCurve); 
    320                                 writeTriple(subj, TYPE, SimpleFeatures.GeometryCollection); 
    321                                 writeTriple(subj, TYPE, SimpleFeatures.Geometry); 
    322                                  
    323                                 writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    324                                 writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
     357                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.MultiCurve), st.getContext()); 
     358                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.GeometryCollection), st.getContext()); 
     359                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(SimpleFeatures.Geometry), st.getContext()); 
     360                                 
     361                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), st.getContext()); 
     362                                handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), st.getContext()); 
    325363                                 
    326364                        } 
     
    338376                                        GeoSPARQL.asWKT.equals(pred)                       || GeoSPARQL.asGML.equals(pred)) { 
    339377                         
    340                         writeTriple(subj, TYPE, GeoSPARQL.Geometry); 
    341                         writeTriple(subj, TYPE, GeoSPARQL.SpatialObject); 
    342                 } 
    343         } 
    344  
    345         protected void writeTriple(String subj, String pred, String obj) { 
    346                 String triple = "<"+subj+"> <"+pred+"> <"+obj+"> .\n"; 
    347                 //logger.info(triple); 
    348                 triples.append(triple); 
    349                 numTriples++; 
     378                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.Geometry), null); 
     379                        handleInferredStatement(st.getSubject(), RDF.TYPE, getURI(GeoSPARQL.SpatialObject), null); 
     380                } 
    350381        } 
    351382 
     
    353384         * Materializes the RDF class hierarchy of Simple Features 
    354385         */ 
    355         protected void insertSimpleFeaturesClassHierarchy() { 
     386        protected void insertSimpleFeaturesClassHierarchy() throws RDFHandlerException { 
    356387                // insert rdf:type rdfs:Class 
    357                 writeTriple(SimpleFeatures.Geometry, TYPE, CLASS); 
    358                 writeTriple(SimpleFeatures.Point, TYPE, CLASS); 
    359                 writeTriple(SimpleFeatures.Curve, TYPE, CLASS); 
    360                 writeTriple(SimpleFeatures.Surface, TYPE, CLASS); 
    361                 writeTriple(SimpleFeatures.GeometryCollection, TYPE, CLASS); 
    362                 writeTriple(SimpleFeatures.LineString, TYPE, CLASS); 
    363                 writeTriple(SimpleFeatures.Polygon, TYPE, CLASS); 
    364                 writeTriple(SimpleFeatures.PolyhedralSurface, TYPE, CLASS); 
    365                 writeTriple(SimpleFeatures.MultiSurface, TYPE, CLASS); 
    366                 writeTriple(SimpleFeatures.MultiCurve, TYPE, CLASS); 
    367                 writeTriple(SimpleFeatures.MultiPoint, TYPE, CLASS); 
    368                 writeTriple(SimpleFeatures.Line, TYPE, CLASS); 
    369                 writeTriple(SimpleFeatures.LinearRing, TYPE, CLASS); 
    370                 writeTriple(SimpleFeatures.Triangle, TYPE, CLASS); 
    371                 writeTriple(SimpleFeatures.TIN, TYPE, CLASS); 
    372                 writeTriple(SimpleFeatures.MultiPolygon, TYPE, CLASS); 
    373                 writeTriple(SimpleFeatures.MultiLineString, TYPE, CLASS); 
     388                handleInferredStatement(getURI(SimpleFeatures.Geometry), RDF.TYPE, RDFS.CLASS, null); 
     389                handleInferredStatement(getURI(SimpleFeatures.Point), RDF.TYPE, RDFS.CLASS, null); 
     390                handleInferredStatement(getURI(SimpleFeatures.Curve), RDF.TYPE, RDFS.CLASS, null); 
     391                handleInferredStatement(getURI(SimpleFeatures.Surface), RDF.TYPE, RDFS.CLASS, null); 
     392                handleInferredStatement(getURI(SimpleFeatures.GeometryCollection), RDF.TYPE, RDFS.CLASS, null); 
     393                handleInferredStatement(getURI(SimpleFeatures.LineString), RDF.TYPE, RDFS.CLASS, null); 
     394                handleInferredStatement(getURI(SimpleFeatures.Polygon), RDF.TYPE, RDFS.CLASS, null); 
     395                handleInferredStatement(getURI(SimpleFeatures.PolyhedralSurface), RDF.TYPE, RDFS.CLASS, null); 
     396                handleInferredStatement(getURI(SimpleFeatures.MultiSurface), RDF.TYPE, RDFS.CLASS, null); 
     397                handleInferredStatement(getURI(SimpleFeatures.MultiCurve), RDF.TYPE, RDFS.CLASS, null); 
     398                handleInferredStatement(getURI(SimpleFeatures.MultiPoint), RDF.TYPE, RDFS.CLASS, null); 
     399                handleInferredStatement(getURI(SimpleFeatures.Line), RDF.TYPE, RDFS.CLASS, null); 
     400                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDF.TYPE, RDFS.CLASS, null); 
     401                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDF.TYPE, RDFS.CLASS, null); 
     402                handleInferredStatement(getURI(SimpleFeatures.TIN), RDF.TYPE, RDFS.CLASS, null); 
     403                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDF.TYPE, RDFS.CLASS, null); 
     404                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDF.TYPE, RDFS.CLASS, null); 
    374405                 
    375406                // insert rdfs:subClassOf geo:Geometry 
    376                 writeTriple(SimpleFeatures.Geometry, SUBCLASS, GeoSPARQL.Geometry); 
    377                 writeTriple(SimpleFeatures.Point, SUBCLASS, GeoSPARQL.Geometry); 
    378                 writeTriple(SimpleFeatures.Curve, SUBCLASS, GeoSPARQL.Geometry); 
    379                 writeTriple(SimpleFeatures.Surface, SUBCLASS, GeoSPARQL.Geometry); 
    380                 writeTriple(SimpleFeatures.GeometryCollection, SUBCLASS, GeoSPARQL.Geometry); 
    381                 writeTriple(SimpleFeatures.LineString, SUBCLASS, GeoSPARQL.Geometry); 
    382                 writeTriple(SimpleFeatures.Polygon, SUBCLASS, GeoSPARQL.Geometry); 
    383                 writeTriple(SimpleFeatures.PolyhedralSurface, SUBCLASS, GeoSPARQL.Geometry); 
    384                 writeTriple(SimpleFeatures.MultiSurface, SUBCLASS, GeoSPARQL.Geometry); 
    385                 writeTriple(SimpleFeatures.MultiCurve, SUBCLASS, GeoSPARQL.Geometry); 
    386                 writeTriple(SimpleFeatures.MultiPoint, SUBCLASS, GeoSPARQL.Geometry); 
    387                 writeTriple(SimpleFeatures.Line, SUBCLASS, GeoSPARQL.Geometry); 
    388                 writeTriple(SimpleFeatures.LinearRing, SUBCLASS, GeoSPARQL.Geometry); 
    389                 writeTriple(SimpleFeatures.Triangle, SUBCLASS, GeoSPARQL.Geometry); 
    390                 writeTriple(SimpleFeatures.TIN, SUBCLASS, GeoSPARQL.Geometry); 
    391                 writeTriple(SimpleFeatures.MultiPolygon, SUBCLASS, GeoSPARQL.Geometry); 
    392                 writeTriple(SimpleFeatures.MultiLineString, SUBCLASS, GeoSPARQL.Geometry); 
     407                handleInferredStatement(getURI(SimpleFeatures.Geometry), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     408                handleInferredStatement(getURI(SimpleFeatures.Point), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     409                handleInferredStatement(getURI(SimpleFeatures.Curve), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     410                handleInferredStatement(getURI(SimpleFeatures.Surface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     411                handleInferredStatement(getURI(SimpleFeatures.GeometryCollection), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     412                handleInferredStatement(getURI(SimpleFeatures.LineString), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     413                handleInferredStatement(getURI(SimpleFeatures.Polygon), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     414                handleInferredStatement(getURI(SimpleFeatures.PolyhedralSurface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     415                handleInferredStatement(getURI(SimpleFeatures.MultiSurface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     416                handleInferredStatement(getURI(SimpleFeatures.MultiCurve), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     417                handleInferredStatement(getURI(SimpleFeatures.MultiPoint), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     418                handleInferredStatement(getURI(SimpleFeatures.Line), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     419                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     420                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     421                handleInferredStatement(getURI(SimpleFeatures.TIN), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     422                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
     423                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDFS.SUBCLASSOF, getURI(GeoSPARQL.Geometry), null); 
    393424                 
    394425                // insert rdfs:subClassOf geo:SpatialObject 
    395                 writeTriple(SimpleFeatures.Geometry, SUBCLASS, GeoSPARQL.SpatialObject); 
    396                 writeTriple(SimpleFeatures.Point, SUBCLASS, GeoSPARQL.SpatialObject); 
    397                 writeTriple(SimpleFeatures.Curve, SUBCLASS, GeoSPARQL.SpatialObject); 
    398                 writeTriple(SimpleFeatures.Surface, SUBCLASS, GeoSPARQL.SpatialObject); 
    399                 writeTriple(SimpleFeatures.GeometryCollection, SUBCLASS, GeoSPARQL.SpatialObject); 
    400                 writeTriple(SimpleFeatures.LineString, SUBCLASS, GeoSPARQL.SpatialObject); 
    401                 writeTriple(SimpleFeatures.Polygon, SUBCLASS, GeoSPARQL.SpatialObject); 
    402                 writeTriple(SimpleFeatures.PolyhedralSurface, SUBCLASS, GeoSPARQL.SpatialObject); 
    403                 writeTriple(SimpleFeatures.MultiSurface, SUBCLASS, GeoSPARQL.SpatialObject); 
    404                 writeTriple(SimpleFeatures.MultiCurve, SUBCLASS, GeoSPARQL.SpatialObject); 
    405                 writeTriple(SimpleFeatures.MultiPoint, SUBCLASS, GeoSPARQL.SpatialObject); 
    406                 writeTriple(SimpleFeatures.Line, SUBCLASS, GeoSPARQL.SpatialObject); 
    407                 writeTriple(SimpleFeatures.LinearRing, SUBCLASS, GeoSPARQL.SpatialObject); 
    408                 writeTriple(SimpleFeatures.Triangle, SUBCLASS, GeoSPARQL.SpatialObject); 
    409                 writeTriple(SimpleFeatures.TIN, SUBCLASS, GeoSPARQL.SpatialObject); 
    410                 writeTriple(SimpleFeatures.MultiPolygon, SUBCLASS, GeoSPARQL.SpatialObject); 
    411                 writeTriple(SimpleFeatures.MultiLineString, SUBCLASS, GeoSPARQL.SpatialObject); 
     426                handleInferredStatement(getURI(SimpleFeatures.Geometry), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     427                handleInferredStatement(getURI(SimpleFeatures.Point), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     428                handleInferredStatement(getURI(SimpleFeatures.Curve), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     429                handleInferredStatement(getURI(SimpleFeatures.Surface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     430                handleInferredStatement(getURI(SimpleFeatures.GeometryCollection), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     431                handleInferredStatement(getURI(SimpleFeatures.LineString), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     432                handleInferredStatement(getURI(SimpleFeatures.Polygon), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     433                handleInferredStatement(getURI(SimpleFeatures.PolyhedralSurface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     434                handleInferredStatement(getURI(SimpleFeatures.MultiSurface), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     435                handleInferredStatement(getURI(SimpleFeatures.MultiCurve), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     436                handleInferredStatement(getURI(SimpleFeatures.MultiPoint), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     437                handleInferredStatement(getURI(SimpleFeatures.Line), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     438                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     439                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     440                handleInferredStatement(getURI(SimpleFeatures.TIN), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     441                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     442                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
    412443                 
    413444                // first level  
    414                 writeTriple(SimpleFeatures.Point, SUBCLASS, SimpleFeatures.Geometry); 
    415                 writeTriple(SimpleFeatures.Curve, SUBCLASS, SimpleFeatures.Geometry); 
    416                 writeTriple(SimpleFeatures.Surface, SUBCLASS, SimpleFeatures.Geometry); 
    417                 writeTriple(SimpleFeatures.GeometryCollection, SUBCLASS, SimpleFeatures.Geometry); 
     445                handleInferredStatement(getURI(SimpleFeatures.Point), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     446                handleInferredStatement(getURI(SimpleFeatures.Curve), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     447                handleInferredStatement(getURI(SimpleFeatures.Surface), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     448                handleInferredStatement(getURI(SimpleFeatures.GeometryCollection), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
    418449                 
    419450                // second level 
    420                 writeTriple(SimpleFeatures.LineString, SUBCLASS, SimpleFeatures.Curve); 
    421                 writeTriple(SimpleFeatures.LineString, SUBCLASS, SimpleFeatures.Geometry); 
    422                  
    423                 writeTriple(SimpleFeatures.Polygon, SUBCLASS, SimpleFeatures.Surface); 
    424                 writeTriple(SimpleFeatures.Polygon, SUBCLASS, SimpleFeatures.Geometry); 
    425                  
    426                 writeTriple(SimpleFeatures.PolyhedralSurface, SUBCLASS, SimpleFeatures.Surface); 
    427                 writeTriple(SimpleFeatures.PolyhedralSurface, SUBCLASS, SimpleFeatures.Geometry); 
    428                  
    429                 writeTriple(SimpleFeatures.MultiSurface, SUBCLASS, SimpleFeatures.GeometryCollection); 
    430                 writeTriple(SimpleFeatures.MultiSurface, SUBCLASS, SimpleFeatures.Geometry); 
    431                  
    432                 writeTriple(SimpleFeatures.MultiCurve, SUBCLASS, SimpleFeatures.GeometryCollection); 
    433                 writeTriple(SimpleFeatures.MultiCurve, SUBCLASS, SimpleFeatures.Geometry); 
    434                  
    435                 writeTriple(SimpleFeatures.MultiPoint, SUBCLASS, SimpleFeatures.GeometryCollection); 
    436                 writeTriple(SimpleFeatures.MultiPoint, SUBCLASS, SimpleFeatures.Geometry); 
     451                handleInferredStatement(getURI(SimpleFeatures.LineString), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Curve), null); 
     452                handleInferredStatement(getURI(SimpleFeatures.LineString), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     453                 
     454                handleInferredStatement(getURI(SimpleFeatures.Polygon), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Surface), null); 
     455                handleInferredStatement(getURI(SimpleFeatures.Polygon), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     456                 
     457                handleInferredStatement(getURI(SimpleFeatures.PolyhedralSurface), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Surface), null); 
     458                handleInferredStatement(getURI(SimpleFeatures.PolyhedralSurface), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     459                 
     460                handleInferredStatement(getURI(SimpleFeatures.MultiSurface), RDFS.SUBCLASSOF, getURI(SimpleFeatures.GeometryCollection), null); 
     461                handleInferredStatement(getURI(SimpleFeatures.MultiSurface), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     462                 
     463                handleInferredStatement(getURI(SimpleFeatures.MultiCurve), RDFS.SUBCLASSOF, getURI(SimpleFeatures.GeometryCollection), null); 
     464                handleInferredStatement(getURI(SimpleFeatures.MultiCurve), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     465                 
     466                handleInferredStatement(getURI(SimpleFeatures.MultiPoint), RDFS.SUBCLASSOF, getURI(SimpleFeatures.GeometryCollection), null); 
     467                handleInferredStatement(getURI(SimpleFeatures.MultiPoint), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
    437468                 
    438469                // third level 
    439                 writeTriple(SimpleFeatures.Line, SUBCLASS, SimpleFeatures.LineString); 
    440                 writeTriple(SimpleFeatures.Line, SUBCLASS, SimpleFeatures.Curve); 
    441                 writeTriple(SimpleFeatures.Line, SUBCLASS, SimpleFeatures.Geometry); 
    442                  
    443                 writeTriple(SimpleFeatures.LinearRing, SUBCLASS, SimpleFeatures.Polygon); 
    444                 writeTriple(SimpleFeatures.LinearRing, SUBCLASS, SimpleFeatures.Surface); 
    445                 writeTriple(SimpleFeatures.LinearRing, SUBCLASS, SimpleFeatures.Geometry); 
    446                  
    447                 writeTriple(SimpleFeatures.Triangle, SUBCLASS, SimpleFeatures.Polygon); 
    448                 writeTriple(SimpleFeatures.Triangle, SUBCLASS, SimpleFeatures.Surface); 
    449                 writeTriple(SimpleFeatures.Triangle, SUBCLASS, SimpleFeatures.Geometry); 
    450                  
    451                 writeTriple(SimpleFeatures.TIN, SUBCLASS, SimpleFeatures.PolyhedralSurface); 
    452                 writeTriple(SimpleFeatures.TIN, SUBCLASS, SimpleFeatures.Surface); 
    453                 writeTriple(SimpleFeatures.TIN, SUBCLASS, SimpleFeatures.Geometry); 
    454                  
    455                 writeTriple(SimpleFeatures.MultiPolygon, SUBCLASS, SimpleFeatures.MultiSurface); 
    456                 writeTriple(SimpleFeatures.MultiPolygon, SUBCLASS, SimpleFeatures.GeometryCollection); 
    457                 writeTriple(SimpleFeatures.MultiPolygon, SUBCLASS, SimpleFeatures.Geometry); 
    458                  
    459                 writeTriple(SimpleFeatures.MultiLineString, SUBCLASS, SimpleFeatures.MultiSurface); 
    460                 writeTriple(SimpleFeatures.MultiLineString, SUBCLASS, SimpleFeatures.GeometryCollection); 
    461                 writeTriple(SimpleFeatures.MultiLineString, SUBCLASS, SimpleFeatures.Geometry); 
     470                handleInferredStatement(getURI(SimpleFeatures.Line), RDFS.SUBCLASSOF, getURI(SimpleFeatures.LineString), null); 
     471                handleInferredStatement(getURI(SimpleFeatures.Line), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Curve), null); 
     472                handleInferredStatement(getURI(SimpleFeatures.Line), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     473                 
     474                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Polygon), null); 
     475                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Surface), null); 
     476                handleInferredStatement(getURI(SimpleFeatures.LinearRing), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     477                 
     478                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Polygon), null); 
     479                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Surface), null); 
     480                handleInferredStatement(getURI(SimpleFeatures.Triangle), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     481                 
     482                handleInferredStatement(getURI(SimpleFeatures.TIN), RDFS.SUBCLASSOF, getURI(SimpleFeatures.PolyhedralSurface), null); 
     483                handleInferredStatement(getURI(SimpleFeatures.TIN), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Surface), null); 
     484                handleInferredStatement(getURI(SimpleFeatures.TIN), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     485                 
     486                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDFS.SUBCLASSOF, getURI(SimpleFeatures.MultiSurface), null); 
     487                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDFS.SUBCLASSOF, getURI(SimpleFeatures.GeometryCollection), null); 
     488                handleInferredStatement(getURI(SimpleFeatures.MultiPolygon), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
     489                 
     490                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDFS.SUBCLASSOF, getURI(SimpleFeatures.MultiSurface), null); 
     491                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDFS.SUBCLASSOF, getURI(SimpleFeatures.GeometryCollection), null); 
     492                handleInferredStatement(getURI(SimpleFeatures.MultiLineString), RDFS.SUBCLASSOF, getURI(SimpleFeatures.Geometry), null); 
    462493        } 
    463494         
    464495        /** 
    465496         * Materializes the RDF class hierarchy of GeoSPARQL 
     497         * @throws RDFHandlerException  
    466498         */ 
    467         protected void insertGeoSPARQLClassHierarchy() { 
    468                 writeTriple(GeoSPARQL.SpatialObject, TYPE, CLASS); 
    469                 writeTriple(GeoSPARQL.Feature, TYPE, CLASS); 
    470                 writeTriple(GeoSPARQL.Geometry, TYPE, CLASS); 
    471                  
    472                  
    473                 writeTriple(GeoSPARQL.Feature, SUBCLASS, GeoSPARQL.SpatialObject); 
    474                 writeTriple(GeoSPARQL.Geometry, SUBCLASS, GeoSPARQL.SpatialObject); 
    475                  
    476         } 
    477          
     499        protected void insertGeoSPARQLClassHierarchy() throws RDFHandlerException { 
     500                handleInferredStatement(getURI(GeoSPARQL.SpatialObject), RDF.TYPE, RDFS.CLASS, null); 
     501                handleInferredStatement(getURI(GeoSPARQL.Feature), RDF.TYPE, RDFS.CLASS, null); 
     502                handleInferredStatement(getURI(GeoSPARQL.Geometry), RDF.TYPE, RDFS.CLASS, null); 
     503                 
     504                handleInferredStatement(getURI(GeoSPARQL.Feature), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     505                handleInferredStatement(getURI(GeoSPARQL.Geometry), RDFS.SUBCLASSOF, getURI(GeoSPARQL.SpatialObject), null); 
     506        } 
     507 
    478508        public static void main(String[] args) throws Exception { 
    479509                NTriplesParser parser = new NTriplesParser(); 
     
    503533                System.out.println("Original triples: " + gmltext); 
    504534                //System.out.println("Geometry domain list: " + handler.getgeometryDomainList()); 
    505                 System.out.println("New triples: " + handler.getTriples()); 
     535                //System.out.println("New triples: " + handler.getTriples()); 
    506536        } 
    507537} 
  • runtime/src/main/java/eu/earthobservatory/runtime/generaldb/Strabon.java

    r1018 r1019  
    1212import java.io.File; 
    1313import java.io.IOException; 
    14 import java.io.InputStream; 
    15 import java.io.InputStreamReader; 
    1614import java.io.OutputStream; 
    1715import java.io.StringReader; 
     
    4038import org.openrdf.rio.RDFHandlerException; 
    4139import org.openrdf.rio.RDFParseException; 
    42 import org.openrdf.rio.RDFParser; 
    43 import org.openrdf.rio.Rio; 
    4440import org.openrdf.sail.helpers.SailBase; 
    4541import org.slf4j.Logger; 
     
    382378                logger.info("[Strabon.storeURL] Format   : {}", ((format == null) ? "null" : format)); 
    383379 
    384                 InputStream in = (InputStream) url.openStream(); 
    385                 InputStreamReader reader = new InputStreamReader(in); 
    386  
    387                 RDFParser parser = Rio.createParser(format); 
    388  
    389                 GeosparqlRDFHandlerBase handler = new GeosparqlRDFHandlerBase(con); 
    390  
    391                 parser.setRDFHandler(handler); 
    392                 parser.parse(reader, ""); 
    393  
    394                 logger.info("[Strabon.storeURL] Inferred {} triples.", handler.getNumberOfTriples()); 
    395                 if (handler.getNumberOfTriples() > 0) { 
    396                         logger.debug("[Strabon.storeURL] Triples inferred: {}", handler.getTriples()); 
    397                 } 
    398                  
    399                 StringReader georeader = new StringReader(handler.getTriples().toString()); 
    400                 handler.endRDF(); 
    401  
    402380                if (context == null) { 
    403381                        con.add(url, baseURI, format); 
    404                         con.add(georeader, "", RDFFormat.NTRIPLES); 
    405382                         
    406383                } else { 
    407384                        con.add(url, baseURI, format, context); 
    408                         con.add(georeader, "", RDFFormat.NTRIPLES, context);     
    409                 } 
    410                  
    411                 georeader.close(); 
    412  
     385                } 
     386                 
    413387                logger.info("[Strabon.storeURL] Storing was successful."); 
    414388        } 
     
    416390        private void storeString(String text, String baseURI, URI context, RDFFormat format) throws RDFParseException, RepositoryException, IOException, RDFHandlerException 
    417391        { 
    418                 if (baseURI == null) 
     392                if (baseURI == null) { 
    419393                        baseURI = ""; 
     394                } 
    420395 
    421396                logger.info("[Strabon.storeString] Storing triples."); 
    422397                logger.info("[Strabon.storeString] Text     : " + text); 
    423                 logger.info("[Strabon.storeString] Base URI : " + ((baseURI == null) ? "null" : baseURI)); 
     398                logger.info("[Strabon.storeString] Base URI : " + baseURI); 
    424399                logger.info("[Strabon.storeString] Context  : " + ((context == null) ? "null" : context)); 
    425400                logger.info("[Strabon.storeString] Format   : " + ((format == null) ? "null" : format.toString())); 
     
    427402                StringReader reader = new StringReader(text); 
    428403 
    429                 RDFParser parser = Rio.createParser(format); 
    430  
    431                 GeosparqlRDFHandlerBase handler = new GeosparqlRDFHandlerBase(con); 
    432  
    433                 parser.setRDFHandler(handler); 
    434                 parser.parse(reader, ""); 
    435  
    436                 logger.info("[Strabon.storeString] Inferred " + handler.getNumberOfTriples() + " triples."); 
    437                 if (handler.getNumberOfTriples() > 0) { 
    438                         logger.info("[Strabon.storeString] Triples inferred:"+ handler.getTriples().toString()); 
    439                 } 
    440                 StringReader georeader = new StringReader(handler.getTriples().toString()); 
    441                 handler.endRDF(); 
    442  
    443404                if (context == null) { 
    444405                        con.add(reader, baseURI, format); 
    445                         reader.close(); 
    446406                         
    447407                } else { 
    448408                        con.add(reader, baseURI, format, context); 
    449                         reader.close(); 
    450                          
    451                 } 
    452                  
    453                 con.add(georeader, "", RDFFormat.NTRIPLES); 
    454                 georeader.close(); 
     409                         
     410                } 
     411                reader.close(); 
     412                 
    455413                logger.info("[Strabon.storeString] Storing was successful."); 
    456414        } 
Note: See TracChangeset for help on using the changeset viewer.