| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.stanbol.entityhub.indexing.source.jenatdb; |
| |
| import static org.apache.stanbol.entityhub.indexing.source.jenatdb.Utils.initTDBDataset; |
| |
| import java.io.File; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.NoSuchElementException; |
| |
| import org.apache.commons.io.FilenameUtils; |
| import org.apache.marmotta.ldpath.api.backend.RDFBackend; |
| import org.apache.stanbol.entityhub.core.model.InMemoryValueFactory; |
| import org.apache.stanbol.entityhub.indexing.core.EntityDataIterable; |
| import org.apache.stanbol.entityhub.indexing.core.EntityDataIterator; |
| import org.apache.stanbol.entityhub.indexing.core.EntityDataProvider; |
| import org.apache.stanbol.entityhub.indexing.core.IndexingComponent; |
| import org.apache.stanbol.entityhub.indexing.core.config.IndexingConfig; |
| import org.apache.stanbol.entityhub.indexing.core.source.ResourceLoader; |
| import org.apache.stanbol.entityhub.indexing.core.source.ResourceState; |
| import org.apache.stanbol.entityhub.servicesapi.model.Reference; |
| import org.apache.stanbol.entityhub.servicesapi.model.Representation; |
| import org.apache.stanbol.entityhub.servicesapi.model.Text; |
| import org.apache.stanbol.entityhub.servicesapi.model.ValueFactory; |
| import org.apache.stanbol.entityhub.servicesapi.util.ModelUtils; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.hp.hpl.jena.datatypes.BaseDatatype; |
| import com.hp.hpl.jena.datatypes.DatatypeFormatException; |
| import com.hp.hpl.jena.datatypes.RDFDatatype; |
| import com.hp.hpl.jena.datatypes.xsd.XSDDateTime; |
| import com.hp.hpl.jena.datatypes.xsd.XSDDuration; |
| import com.hp.hpl.jena.graph.Node; |
| import com.hp.hpl.jena.graph.NodeFactory; |
| import com.hp.hpl.jena.graph.Triple; |
| import com.hp.hpl.jena.graph.impl.LiteralLabel; |
| import com.hp.hpl.jena.query.Query; |
| import com.hp.hpl.jena.query.QueryExecutionFactory; |
| import com.hp.hpl.jena.query.QueryFactory; |
| import com.hp.hpl.jena.query.QuerySolution; |
| import com.hp.hpl.jena.query.ResultSet; |
| import com.hp.hpl.jena.query.Syntax; |
| import com.hp.hpl.jena.rdf.model.AnonId; |
| import com.hp.hpl.jena.rdf.model.RDFNode; |
| import com.hp.hpl.jena.sparql.core.DatasetGraph; |
| import com.hp.hpl.jena.sparql.core.Var; |
| import com.hp.hpl.jena.sparql.engine.binding.Binding; |
| import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; |
| import com.hp.hpl.jena.util.iterator.ExtendedIterator; |
| /** |
| * Implementation of an {@link IndexingComponent} for Entity data that provides |
| * the possibility to both:<ol> |
| * <li>randomly access entity data via the {@link EntityDataProvider} interface |
| * <li>iterate over all entities in this store via the {@link EntityDataIterator} |
| * interface. |
| * </ol> |
| * |
| * @author Rupert Westenthaler |
| * |
| */ |
| public class RdfIndexingSource extends AbstractTdbBackend implements EntityDataIterable,EntityDataProvider, RDFBackend<Node> { |
| /** |
| * The Parameter used to configure the source folder(s) relative to the |
| * {@link IndexingConfig#getSourceFolder()}. The ',' (comma) is used as |
| * separator to parsed multiple sources. |
| */ |
| public static final String PARAM_SOURCE_FILE_OR_FOLDER = "source"; |
| /** |
| * The directory where successfully imported files are copied to |
| */ |
| public static final String PARAM_IMPORTED_FOLDER = "imported"; |
| /** |
| * Allows to enable/disable the indexing of Bnodes (see |
| * <a href="https://issues.apache.org/jira/browse/STANBOL-765">STANBOL-765</a> |
| * for details). |
| */ |
| private static final String PARAM_BNODE_STATE = "bnode"; |
| /** |
| * If present, this Parameter allows to convert RDF BlankNodes to dereferable |
| * URIs by using {bnode-prefix}{bnode-id} (see |
| * <a href="https://issues.apache.org/jira/browse/STANBOL-765">STANBOL-765</a> |
| * for details) |
| */ |
| public static final String PARAM_BNODE_PREFIX = "bnode-prefix"; |
| /** |
| * The Parameter that can be used to deactivate the importing of sources. |
| * If this parameter is set to <code>false</code> the values configured for |
| * {@link #PARAM_IMPORT_SOURCE} are ignored. The default value is |
| * <code>true</code> |
| */ |
| public static final String PARAM_IMPORT_SOURCE = "import"; |
| /** |
| * Allows to configure a {@link RdfImportFilter} (full qualified class name). |
| * If present it gets the full configuration set for this component parsed. |
| * This means that the import filter can be configured by the same |
| * configuration as this component. |
| */ |
| public static final String PARAM_IMPORT_FILTER = "import-filter"; |
| /** |
| * The default directory name used to search for RDF files to be imported |
| */ |
| public static final String DEFAULT_SOURCE_FOLDER_NAME = "rdfdata"; |
| |
| public static final String DEFAULT_IMPORTED_FOLDER_NAME = "imported"; |
| //protected to allow internal classes direct access (without hidden getter/ |
| //setter added by the compiler that decrease performance) |
| protected final static Logger log = LoggerFactory.getLogger(RdfIndexingSource.class); |
| |
| /** |
| * The RDF data |
| */ |
| private DatasetGraphTDB indexingDataset; |
| /** |
| * The valueFactory used to create {@link Representation}s, {@link Reference}s |
| * and {@link Text} instances. |
| */ |
| private ValueFactory vf; |
| |
| private ResourceLoader loader; |
| |
| protected String bnodePrefix; //protected to allow direct access in inner classes |
| /** |
| * used for logging a single WARN level entry on the first ignored BlankNode |
| */ |
| private boolean bnodeIgnored = false; |
| private RdfImportFilter importFilter; |
| |
| /** |
| * Default Constructor relaying on that {@link #setConfiguration(Map)} is |
| * called afterwards to provide the configuration! |
| */ |
| public RdfIndexingSource(){ |
| this(null); |
| } |
| /** |
| * Internally used to initialise a {@link ValueFactory} |
| * @param valueFactory |
| */ |
| private RdfIndexingSource(ValueFactory valueFactory){ |
| if(valueFactory == null){ |
| this.vf = InMemoryValueFactory.getInstance(); |
| } else { |
| this.vf = valueFactory; |
| } |
| } |
| /** |
| * Constructs an instance based on the provided parameter |
| * @param modelLocation the directory for the RDF model. MUST NOT be NULL |
| * however the parsed {@link File} needs not to exist. |
| * @param sourceFileOrDirectory the source file or directory containing the |
| * file(s) to import. Parse <code>null</code> if no RDF files need to be |
| * imported |
| * @param valueFactory The {@link ValueFactory} used to create instances |
| * or <code>null</code> to use the default implementation. |
| * @param importFilter Optionally an importFilter used for filtering some |
| * triples read from the RDF source files. |
| */ |
| public RdfIndexingSource(File modelLocation, |
| File sourceFileOrDirectory, |
| ValueFactory valueFactory, |
| RdfImportFilter importFilter){ |
| if(modelLocation == null){ |
| throw new IllegalArgumentException("The parsed model location MUST NOT be NULL!"); |
| } |
| //init the store |
| this.indexingDataset = initTDBDataset(modelLocation); |
| //use a ResourceLoader that fails on the first invalid RDF file (STANBOL-328) |
| this.loader = new ResourceLoader(new RdfResourceImporter(indexingDataset,importFilter), true,true); |
| loader.addResource(sourceFileOrDirectory); |
| } |
| @Override |
| public void setConfiguration(Map<String,Object> config) { |
| IndexingConfig indexingConfig = (IndexingConfig)config.get(IndexingConfig.KEY_INDEXING_CONFIG); |
| //first init the RDF Model |
| this.indexingDataset = Utils.getTDBDataset(config); |
| //second we need to check if we need to import RDF files to the RDF model |
| //look if we need want to use an import filter |
| Object value = config.get(PARAM_IMPORT_FILTER); |
| if(value == null){ |
| log.info("No RDF Import Filter configured"); |
| importFilter = null; |
| } else { |
| String[] filterNames = value.toString().split(","); |
| List<RdfImportFilter> filters = new ArrayList<RdfImportFilter>(); |
| ClassLoader cl = indexingConfig.getClass().getClassLoader(); |
| for(String filterName : filterNames){ |
| filterName = filterName.trim(); |
| try { |
| Class<? extends RdfImportFilter> importFilterClass = cl.loadClass( |
| filterName).asSubclass(RdfImportFilter.class); |
| RdfImportFilter filter = importFilterClass.newInstance(); |
| filter.setConfiguration(config); |
| filters.add(filter); |
| log.info("Use RDF ImportFilter {} (type: {})",importFilter,importFilterClass.getSimpleName()); |
| } catch (ClassNotFoundException e) { |
| throw new IllegalArgumentException("Configured RdfImportFilter '" |
| +filterName+"' not found", e); |
| } catch (InstantiationException e) { |
| throw new IllegalArgumentException("Configured RdfImportFilter '" |
| +filterName+"' can not be instantiated", e); |
| } catch (IllegalAccessException e) { |
| throw new IllegalArgumentException("Configured RdfImportFilter '" |
| +filterName+"' can not be created", e); |
| } |
| } |
| if(filters.isEmpty()){ |
| this.importFilter = null; |
| } else if(filters.size() == 1){ |
| this.importFilter = filters.get(0); |
| } else { |
| this.importFilter = new UnionImportFilter(filters.toArray( |
| new RdfImportFilter[filters.size()])); |
| } |
| } |
| |
| boolean failOnError = indexingConfig.isFailOnError(); |
| //create the ResourceLoader |
| this.loader = new ResourceLoader(new RdfResourceImporter(indexingDataset, importFilter), failOnError); |
| |
| value = config.get(PARAM_IMPORTED_FOLDER); |
| String importedFolderName; |
| if(value != null && !value.toString().isEmpty()){ |
| importedFolderName = value.toString(); |
| } else { |
| importedFolderName = DEFAULT_IMPORTED_FOLDER_NAME; |
| } |
| File importedFolder = new File(indexingConfig.getSourceFolder(),importedFolderName); |
| log.info("Imported RDF File Folder: {}",importedFolder); |
| this.loader.setImportedDir(importedFolder); |
| //check if importing is deactivated |
| boolean importSource = true; //default is true |
| value = config.get(PARAM_IMPORT_SOURCE); |
| if(value != null){ |
| importSource = Boolean.parseBoolean(value.toString()); |
| } |
| if(importSource){ // if we need to import ... check the source config |
| log.info("Importing RDF data from:"); |
| value = config.get(PARAM_SOURCE_FILE_OR_FOLDER); |
| if(value == null){ //if not set use the default |
| value = DEFAULT_SOURCE_FOLDER_NAME; |
| } |
| for(String source : value.toString().split(",")){ |
| File sourceFileOrDirectory = indexingConfig.getSourceFile(source); |
| if(sourceFileOrDirectory.exists()){ |
| //register the configured source with the ResourceLoader |
| this.loader.addResource(sourceFileOrDirectory); |
| } else { |
| if(FilenameUtils.getExtension(source).isEmpty()){ |
| //non existent directory -> create |
| //This is typically the case if this method is called to |
| //initialise the default configuration. So we will try |
| //to create the directory users need to copy the source |
| //RDF files. |
| if(!sourceFileOrDirectory.mkdirs()){ |
| log.warn("Unable to create directory {} configured to improt RDF data from. " + |
| "You will need to create this directory manually before copying the" + |
| "RDF files into it.",sourceFileOrDirectory); |
| //this would not be necessary because the directory will |
| //be empty - however I like to be consistent and have |
| //all configured and existent files & dirs added the the |
| //resource loader |
| this.loader.addResource(sourceFileOrDirectory); |
| } |
| } else { |
| log.warn("Unable to find RDF source {} within the indexing Source folder ",source,indexingConfig.getSourceFolder()); |
| } |
| } |
| } |
| if(log.isInfoEnabled()){ |
| for(String registeredSource : loader.getResources(ResourceState.REGISTERED)){ |
| log.info(" > "+registeredSource); |
| } |
| } |
| } else { |
| log.info("Importing RDF data deactivated by parameer {}={}"+PARAM_IMPORT_SOURCE,value); |
| } |
| //STANBOL-765: parsed bnode-prefix from parsed configuration. |
| value = config.get(PARAM_BNODE_STATE); |
| final Boolean bnodeState; |
| if(value != null){ |
| bnodeState = value instanceof Boolean ? (Boolean) value : |
| Boolean.parseBoolean(value.toString()); |
| } else if(config.containsKey(PARAM_BNODE_STATE)){ //support key without value |
| bnodeState = true; |
| } else { |
| bnodeState = null; //undefined |
| } |
| if(bnodeState == null || bnodeState){ //null or enabled -> consider prefix |
| value = config.get(PARAM_BNODE_PREFIX); |
| if(value != null){ |
| try { |
| new URI(value.toString()); |
| } catch (URISyntaxException e) { |
| throw new IllegalArgumentException("The configured "+PARAM_BNODE_PREFIX+"='" |
| + value.toString() + "' MUST BE a valid URI!"); |
| } |
| bnodePrefix = value.toString(); |
| } else if(bnodeState != null) { //use default prefix if bnodeState is true |
| bnodePrefix = String.format("urn:bnode:%s:",indexingConfig.getName()); |
| } // else bnodeState == null and no custom prefix -> disable by default |
| } |
| if(bnodePrefix != null){ |
| log.info("Indexing of Bnodes enabled (prefix: {}",bnodePrefix); |
| } else { |
| log.info("Indexing of Bnodes disabled"); |
| |
| } |
| } |
| @Override |
| public boolean needsInitialisation() { |
| return (importFilter != null && importFilter.needsInitialisation()) || |
| !loader.getResources(ResourceState.REGISTERED).isEmpty(); |
| } |
| @Override |
| public void initialise(){ |
| if(importFilter != null && importFilter.needsInitialisation()){ |
| importFilter.initialise(); |
| } |
| if(!loader.getResources(ResourceState.REGISTERED).isEmpty()){ |
| loader.loadResources(); |
| } |
| } |
| @Override |
| public void close() { |
| loader = null; |
| indexingDataset.close(); |
| if(importFilter != null){ |
| importFilter.close(); |
| } |
| } |
| public void debug(){ |
| String entityVar = "s"; |
| String fieldVar = "p"; |
| String valueVar = "o"; |
| StringBuilder qb = new StringBuilder(); |
| qb.append(String.format("SELECT ?%s ?%s ?%s \n", |
| entityVar,fieldVar,valueVar)); //for the select |
| qb.append("{ \n"); |
| qb.append(String.format(" ?%s ?%s ?%s . \n", |
| entityVar,fieldVar,valueVar)); //for the where |
| qb.append("} \n"); |
| log.debug("EntityDataIterator Query: \n"+qb.toString()); |
| Query q = QueryFactory.create(qb.toString(), Syntax.syntaxARQ); |
| ResultSet rs = QueryExecutionFactory.create(q, indexingDataset.toDataset()).execSelect(); |
| Var s = Var.alloc(entityVar); |
| Var p = Var.alloc(fieldVar); |
| Var o = Var.alloc(valueVar); |
| while (rs.hasNext()){ |
| Binding b = rs.nextBinding(); |
| log.debug("{} {} {}",new Object[]{b.get(s),b.get(p),b.get(o)}); |
| } |
| } |
| |
| @Override |
| public EntityDataIterator entityDataIterator() { |
| String entityVar = "s"; |
| String fieldVar = "p"; |
| String valueVar = "o"; |
| StringBuilder qb = new StringBuilder(); |
| qb.append(String.format("SELECT ?%s ?%s ?%s \n", |
| entityVar,fieldVar,valueVar)); //for the select |
| qb.append("{ \n"); |
| qb.append(String.format(" ?%s ?%s ?%s . \n", |
| entityVar,fieldVar,valueVar)); //for the where |
| qb.append("} \n"); |
| log.debug("EntityDataIterator Query: \n"+qb.toString()); |
| Query q = QueryFactory.create(qb.toString(), Syntax.syntaxARQ); |
| return new RdfEntityIterator( |
| QueryExecutionFactory.create(q, indexingDataset.toDataset()).execSelect(), |
| entityVar,fieldVar,valueVar); |
| } |
| |
| @Override |
| public Representation getEntityData(String id) { |
| final Node resource; |
| //STANBOL-765: check if the parsed id represents an bnode |
| if(bnodePrefix != null && id.startsWith(bnodePrefix)){ |
| resource = NodeFactory.createAnon(AnonId.create(id.substring(bnodePrefix.length()))); |
| } else { |
| resource = NodeFactory.createURI(id); |
| } |
| Representation source = vf.createRepresentation(id); |
| boolean found; |
| ExtendedIterator<Triple> outgoing = null; |
| try { // There may still be exceptions while reading triples |
| outgoing = indexingDataset.getDefaultGraph().find(resource, null, null); |
| found = outgoing.hasNext(); |
| while(outgoing.hasNext()){ //iterate over the statements for that resource |
| Triple statement = outgoing.next(); |
| Node predicate = statement.getPredicate(); |
| if(predicate == null || !predicate.isURI()){ |
| log.warn("Ignore field {} for resource {} because it is null or not an URI!", |
| predicate,resource); |
| } else { |
| String field = predicate.getURI(); |
| Node value = statement.getObject(); |
| processValue(value, source, field); |
| } //end else predicate != null |
| } //end iteration over resource triple |
| } catch (Exception e) { |
| log.warn("Unable to retrieve entity data for Entity '"+id+"'",e); |
| found = false; |
| try { |
| if(outgoing != null){ |
| outgoing.close(); |
| } |
| } catch (Exception e1) { /* ignore */} |
| } |
| if(found) { |
| if(log.isTraceEnabled()){ |
| log.info("RDFTerm: \n{}", ModelUtils.getRepresentationInfo(source)); |
| } |
| return source; |
| } else { |
| log.debug("No Statements found for id {} (Node: {})!",id,resource); |
| return null; |
| } |
| } |
| /** |
| * Getter for the Jena TDB {@link DatasetGraph} used as source |
| * @return the indexingDataset |
| */ |
| public final DatasetGraphTDB getIndexingDataset() { |
| return indexingDataset; |
| } |
| |
| /** |
| * Processes a {@link Node} and adds the according value to the parsed |
| * Representation. |
| * @param value The node to convert to an value for the Representation |
| * @param source the representation (MUST NOT be <code>null</code> |
| * @param field the field (MUST NOT be <code>null</code>) |
| */ |
| private void processValue(Node value, Representation source, String field) { |
| if(value == null){ |
| log.warn("Encountered NULL value for field {} and entity {}", |
| field,source.getId()); |
| } else if(value.isURI()){ //add a reference |
| source.addReference(field, value.getURI()); |
| } else if(value.isLiteral()){ //add a value or a text depending on the dataType |
| LiteralLabel ll = value.getLiteral(); |
| // log.debug("LL: lexical {} | value {} | dataType {} | language {}", |
| // new Object[]{ll.getLexicalForm(),ll.getValue(),ll.getDatatype(),ll.language()}); |
| //if the dataType == null , than we can expect a plain literal |
| RDFDatatype dataType = ll.getDatatype(); |
| if(dataType != null){ //add a value |
| Object literalValue; |
| try { |
| literalValue = ll.getValue(); |
| if(literalValue instanceof BaseDatatype.TypedValue){ |
| //used for unknown data types |
| // -> in such cases just use the lexical type |
| String lexicalValue = ((BaseDatatype.TypedValue)literalValue).lexicalValue; |
| if(lexicalValue != null && !lexicalValue.isEmpty()){ |
| source.add(field,lexicalValue); |
| } |
| } else if(literalValue instanceof XSDDateTime) { |
| source.add(field, ((XSDDateTime)literalValue).asCalendar().getTime()); //Entityhub uses the time |
| } else if(literalValue instanceof XSDDuration) { |
| String duration = literalValue.toString(); |
| if(duration != null && !duration.isEmpty()) { |
| source.add(field, literalValue.toString()); |
| } |
| } else if(!ll.getLexicalForm().isEmpty()){ |
| source.add(field, literalValue); |
| } //else ignore literals that are empty |
| } catch (DatatypeFormatException e) { |
| log.warn(" Unable to convert {} to {} -> use lecicalForm", |
| ll.getLexicalForm(),ll.getDatatype()); |
| literalValue = ll.getLexicalForm(); |
| } |
| } else { //add a text |
| String lexicalForm = ll.getLexicalForm(); |
| if(lexicalForm != null && !lexicalForm.isEmpty()){ |
| String language = ll.language(); |
| if(language!=null && language.length()<1){ |
| language = null; |
| } |
| source.addNaturalText(field, lexicalForm, language); |
| } //else ignore empty literals |
| } |
| // "" is parsed if there is no language |
| } else if(value.isBlank()) { |
| if(bnodePrefix != null) { //STANBOL-765: convert Bnodes to URIs |
| StringBuilder sb = new StringBuilder(bnodePrefix); |
| sb.append(value.getBlankNodeId().getLabelString()); |
| source.addReference(field, sb.toString()); |
| } else { |
| logIgnoredBnode(log, source, field, value); |
| } |
| } else { |
| log.warn("ignoreing value {} for field {} and RDFTerm {} because it is of an unsupported type!", |
| new Object[]{value,field,source.getId()}); |
| } //end different value node type |
| } |
| /** |
| * Logs that a BlankNode was ignored (only the first time). Also debugs the |
| * ignored triple. |
| * @param log the logger to use |
| * @param s subject |
| * @param p predicate |
| * @param o object |
| */ |
| protected void logIgnoredBnode(Logger log, Object s, Object p, Object o) { |
| if(!bnodeIgnored){ |
| bnodeIgnored = true; |
| log.warn("The Indexed RDF Data do contain Blank Nodes. Those are " |
| + "ignored unless the '{}' parameter is set to valid URI. " |
| + "If this parameter is set Bnodes are converted to URIs by " |
| + "using {bnode-prefix}{bnodeId} (see STANBOL-765)", |
| PARAM_BNODE_PREFIX); |
| } |
| log.debug("ignoreing blank node value(s) for Triple {},{},{}!", |
| new Object[]{s,p,o}); |
| } |
| /** |
| * Implementation of the iterator over the entities stored in a |
| * {@link RdfIndexingSource}. This Iterator is based on query |
| * {@link ResultSet}. It uses the low level SPARQL API because this allows |
| * to use the same code to create values for Representations |
| * @author Rupert Westenthaler |
| * |
| */ |
| public final class RdfEntityIterator implements EntityDataIterator { |
| /** |
| * Variable used to |
| */ |
| final Var entityVar; |
| final Var fieldVar; |
| final Var valueVar; |
| /** |
| * The result set containing all triples in the form of <code> |
| * "entity -> field -> value"</code> |
| */ |
| private final ResultSet resultSet; |
| /** |
| * The {@link Node} representing the current entity or <code>null</code> |
| * if the iterator is newly created.<p> |
| * {@link Node#isURI()} is guaranteed to return <code>true</code> and |
| * {@link Node#getURI()} is guaranteed to return the id for the entity |
| */ |
| private Node currentEntity = null; |
| /** |
| * The {@link Node} for the next Entity in the iteration or <code>null</code> |
| * in case there are no further or the iterator is newly created (in that |
| * case {@link #currentEntity} will be also <code>null</code>)<p> |
| * {@link Node#isURI()} is guaranteed to return <code>true</code> and |
| * {@link Node#getURI()} is guaranteed to return the id for the entity |
| */ |
| private Node nextEntity = null; |
| /** |
| * The Representation of the current Element. Only available after a |
| * call to {@link #getRepresentation()} |
| */ |
| private Representation currentRepresentation = null; |
| /** |
| * Holds all <code>field,value"</code> pairs of the current Entity. |
| * Elements at even positions represent<code>fields</code> and elements |
| * at uneven positions represent <code>values</code>. |
| */ |
| private List<Node> data = new ArrayList<Node>(); |
| /** |
| * The next (not consumed) solution of the query. |
| */ |
| private Binding nextBinding = null; |
| |
| protected RdfEntityIterator(ResultSet resultSet, String entityVar,String fieldVar, String valueVar){ |
| if(resultSet == null){ |
| throw new IllegalArgumentException("The parsed ResultSet MUST NOT be NULL!"); |
| } |
| //check if the ResultSet provides the required variables to perform the query |
| List<String> vars = resultSet.getResultVars(); |
| if(!vars.contains(entityVar)){ |
| throw new IllegalArgumentException("The parsed ResultSet is missing the required" + |
| "Variable \""+entityVar+"\" representing the Entity!"); |
| } else { |
| this.entityVar = Var.alloc(entityVar); |
| } |
| if(!vars.contains(fieldVar)){ |
| throw new IllegalArgumentException("The parsed ResultSet is missing the required" + |
| "Variable \""+fieldVar+"\" representing the Field of an Entity!"); |
| } else { |
| this.fieldVar = Var.alloc(fieldVar); |
| } |
| if(!vars.contains(valueVar)){ |
| throw new IllegalArgumentException("The parsed ResultSet is missing the required" + |
| "Variable \""+valueVar+"\" representing the Value of a Field of an Entity!"); |
| } else { |
| this.valueVar = Var.alloc(valueVar); |
| } |
| this.resultSet = resultSet; |
| //this will read until the first binding of the first Entity is found |
| initFirst(); |
| } |
| private void initFirst(){ |
| if(currentEntity == null && nextEntity == null){ //only for the first call |
| //consume binding until the first valid entity starts |
| while(nextEntity == null && resultSet.hasNext()){ |
| Binding firstValid = resultSet.nextBinding(); |
| Node entityNode = firstValid.get(entityVar); |
| if((entityNode.isURI() && !entityNode.toString().isEmpty()) || |
| entityNode.isBlank() && bnodePrefix != null){ |
| //store it temporarily in nextBinding |
| nextBinding = firstValid; |
| //store it as next (first) entity |
| nextEntity = entityNode; |
| } else { |
| logIgnoredBnode(log,entityNode,firstValid.get(fieldVar),firstValid.get(valueVar)); |
| } |
| } |
| } else { |
| throw new IllegalStateException("This Mehtod MUST be only used for Initialisation!"); |
| } |
| } |
| @Override |
| public void close() { |
| data.clear(); |
| data = null; |
| currentEntity = null; |
| currentRepresentation = null; |
| //Looks like it is not possible to close a resultSet |
| } |
| |
| @Override |
| public Representation getRepresentation() { |
| //current Entity will be null if |
| // - next() was never called |
| // - the end of the iteration was reached |
| if(currentEntity == null){ |
| return null; |
| } else if(currentRepresentation == null){ |
| currentRepresentation = createRepresentation(); |
| } |
| return currentRepresentation; |
| } |
| |
| @Override |
| public boolean hasNext() { |
| return resultSet.hasNext(); |
| } |
| |
| @Override |
| public String next() { |
| return getNext(); |
| } |
| |
| @Override |
| public void remove() { |
| throw new UnsupportedOperationException( |
| "Removal of Entities is not supported by this Implementation!"); |
| } |
| /** |
| * Iterates over all {@link QuerySolution} of the {@link #resultSet} |
| * that do have {@link #currentEntity} as |
| * {@link RdfIndexingSource#VARIABLE_NAME_ENTITY VARIABLE_NAME_ENTITY}. |
| * NOTES: <ul> |
| * <li>This method also initialises the {@link #data} and sets the |
| * {@link #nextBinding} to the first solution of the next entity.<br> |
| * <li>That means also, that it would iterate over additional |
| * {@link RdfIndexingSource#VARIABLE_NAME_ENTITY VARIABLE_NAME_ENTITY} |
| * values that are not URIResources ( in cases |
| * {@link RDFNode#isURIResource()} returns <code>false</code>) |
| * <li>This method is also used to initialise the first Entity |
| * @return the URI of the current entity |
| */ |
| private String getNext(){ |
| //check for more elements |
| if(!resultSet.hasNext()){ |
| throw new NoSuchElementException("No more Entities available"); |
| } |
| //clean up data of the previous entity |
| this.data.clear(); //remove data of the previous entity |
| this.currentRepresentation = null; //and the representation |
| this.currentEntity = nextEntity; //set the nextEntity to the current |
| |
| //and process the first binding already consumed from the resultSet |
| //by calling this method for the previous Entity |
| if(nextBinding != null){ //will be null for the first Entity |
| processSolution(nextBinding); |
| } |
| //now get all the other Solutions for the current entity |
| boolean next = false; |
| while(!next && resultSet.hasNext()){ |
| Binding binding = resultSet.nextBinding(); |
| Node entityNode = binding.get(entityVar); |
| //NOTES: |
| // * for URIs we need to check for empty URIs! |
| // * STANBOL-765: added support for BlankNodes |
| if((entityNode.isURI() && !entityNode.toString().isEmpty()) || |
| entityNode.isBlank() && bnodePrefix != null){ |
| if(!entityNode.equals(currentEntity)){ |
| //start of next Entity |
| this.nextEntity = entityNode; //store the node for the next entity |
| this.nextBinding = binding; //store the first binding of the next entity |
| //we are done for this entity -> exit the loop |
| next = true; |
| } else { |
| processSolution(binding); |
| } |
| } else { |
| logIgnoredBnode(log,entityNode,binding.get(fieldVar),binding.get(valueVar)); |
| } |
| } |
| if(!next){ // exit the loop but still no new entity ... that means |
| nextEntity = null; //there are no more entities |
| nextBinding = null; // and there are also no more solutions |
| } |
| //STANBOL-765: if current is a Bnode add the bnode-prefix |
| return currentEntity.isBlank() ? |
| new StringBuilder(bnodePrefix).append(currentEntity.getBlankNodeId().getLabelString()).toString() : |
| currentEntity.getURI(); |
| } |
| /** |
| * Processes a {@link Binding} by storing the {@link Node}s for the |
| * variables {@link #fieldVar} and {@link #valueVar} to {@link #data}. |
| * This method ensures that both values are not <code>null</code> and |
| * that the {@link Node} representing the field is an URI ( |
| * returns <code>true</code> for {@link Node#isURI()}). |
| * @param binding the binding to process |
| */ |
| private void processSolution(Binding binding) { |
| Node field = binding.get(fieldVar); |
| if(field != null && field.isURI()){ //property MUST BE an URI |
| Node value = binding.get(valueVar); |
| if(value != null){ |
| //add the pair |
| data.add(field); |
| data.add(value); |
| } |
| } else { |
| //This may only happen if the Query used to create the ResultSet |
| //containing this Solution does not link the variable |
| //VARIABLE_NAME_FIELD to properties. |
| log.error("Found Field {} for Entity {} that is not an URIResource",field,currentEntity); |
| } |
| } |
| /** |
| * Used to create the Representation the first time |
| * {@link #getRepresentation()} is called for the current entity. The |
| * information for the Representation are already stored in {@link #data} |
| */ |
| private Representation createRepresentation() { |
| final String uri; |
| if(currentEntity.isBlank()){ //STANBOL-765: support bNodes |
| StringBuilder sb = new StringBuilder(bnodePrefix); |
| sb.append(currentEntity.getBlankNodeId().getLabelString()); |
| uri = sb.toString(); |
| } else { |
| uri = currentEntity.getURI(); |
| } |
| Representation representation = vf.createRepresentation(uri); |
| Iterator<Node> it = data.iterator(); |
| while(it.hasNext()){ |
| //data contains field,value pairs |
| //because of that we call two times next for |
| String field = it.next().getURI(); //the field |
| Node value = it.next();//and the value |
| processValue(value, representation, field); |
| } |
| return representation; |
| } |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * RDF Backend implementation |
| * ---------------------------------------------------------------------- |
| */ |
| @Override |
| public Collection<Node> listObjects(Node subject, Node property) { |
| Collection<Node> nodes = new ArrayList<Node>(); |
| if(bnodePrefix != null && subject.isURI() && subject.getURI().startsWith(bnodePrefix)){ |
| subject = NodeFactory.createAnon(new AnonId(subject.getURI().substring(bnodePrefix.length()))); |
| } |
| ExtendedIterator<Triple> it = indexingDataset.getDefaultGraph().find(subject, property, null); |
| while(it.hasNext()){ |
| //STANBOL-765: we need also to transform bnodes to URIs for the |
| //RDFBackend implementation |
| Node object = it.next().getObject(); |
| if(bnodePrefix != null && object.isBlank()){ |
| StringBuilder sb = new StringBuilder(bnodePrefix); |
| sb.append(object.getBlankNodeId().getLabelString()); |
| object = NodeFactory.createURI(sb.toString()); |
| } |
| nodes.add(object); |
| } |
| it.close(); |
| return nodes; |
| } |
| @Override |
| public Collection<Node> listSubjects(Node property, Node object) { |
| Collection<Node> nodes = new ArrayList<Node>(); |
| if(bnodePrefix != null && object.isURI() && object.getURI().startsWith(bnodePrefix)){ |
| object = NodeFactory.createAnon(new AnonId(object.getURI().substring(bnodePrefix.length()))); |
| } |
| ExtendedIterator<Triple> it = indexingDataset.getDefaultGraph().find(null, property, object); |
| while(it.hasNext()){ |
| Node subject = it.next().getSubject(); |
| //STANBOL-765: we need also to transform bnodes to URIs for the |
| //RDFBackend implementation |
| if(bnodePrefix != null && subject.isBlank()){ |
| StringBuilder sb = new StringBuilder(bnodePrefix); |
| sb.append(subject.getBlankNodeId().getLabelString()); |
| subject = NodeFactory.createURI(sb.toString()); |
| } |
| nodes.add(subject); |
| } |
| it.close(); |
| return nodes; |
| } |
| /** |
| * Since STANBOL-765 BlankNodes are converted to URIs if a {@link #bnodePrefix} |
| * is configured. This also means that one needs to expect calls to the |
| * {@link RDFBackend} interface with transformed Nodes. <p> |
| * This method ensures that if someone requests an uri {@link Node} for a |
| * URI that represents a transformed Bnode (when the URI starts with |
| * {@link #bnodePrefix}) that the according bnode {@link Node} is created |
| * @param node the node |
| * @return |
| */ |
| @Override |
| public Node createURI(String uri) { |
| if(bnodePrefix != null && uri.startsWith(bnodePrefix)){ |
| return NodeFactory.createAnon(AnonId.create(uri.substring(bnodePrefix.length()))); |
| } else { |
| return super.createURI(uri); |
| } |
| } |
| /** |
| * used in case multiple {@link RdfImportFilter}s are configured. |
| * @author Rupert Westenthaler |
| * |
| */ |
| private class UnionImportFilter implements RdfImportFilter { |
| |
| RdfImportFilter[] filters; |
| |
| UnionImportFilter(RdfImportFilter[] filters){ |
| this.filters = filters; |
| } |
| |
| @Override |
| public void setConfiguration(Map<String,Object> config) {} |
| |
| @Override |
| public boolean needsInitialisation() { return false;} |
| |
| @Override |
| public void initialise() {} |
| |
| @Override |
| public void close() {} |
| |
| @Override |
| public boolean accept(Node s, Node p, Node o) { |
| boolean state = true; |
| for(int i=0;state && i < filters.length;i++){ |
| state = filters[i].accept(s, p, o); |
| } |
| return state; |
| } |
| |
| } |
| |
| } |
