Fixed a severe bug that prevented the system from loading a dataset a…

…s singleton if more than one annotator was used. Reduced the length of error messages printed by the HTTP based entity checker in a non debug mode. Updated the GERBIL vocabulary and the RDF generation of experiment results. Created a small tool for exporting the database content into an RDF dump. Fixed a bug in the VocabularyController.

.gitignore

@@ -1,12 +1,13 @@
-*.class
-*.cache
-.classpath
-.project
-target
-bin
-.settings
-gerbil_keys.properties
-gerbil_data
-*.log
-google*.html
-export
+*.class
+*.cache
+.classpath
+.project
+target
+bin
+.settings
+gerbil_keys.properties
+gerbil_data
+*.log
+google*.html
+export
+datadump.nt

exportData.sh

@@ -0,0 +1 @@
+mvn clean compile exec:java -Dexec.mainClass=org.aksw.gerbil.tools.DataDumpTool

pom.xml

@@ -368,7 +368,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>exec-maven-plugin</artifactId>
-				<version>1.4.0</version>
+				<version>1.5.0</version>
 			</plugin>
 			<!-- Javadoc plugin for generating documentation -->
 			<plugin>

src/main/java/org/aksw/gerbil/database/ExperimentDAO.java

@@ -85,6 +85,16 @@ public interface ExperimentDAO extends Closeable {
      */
     public List<ExperimentTaskResult> getResultsOfExperiment(String experimentId);
 
+    /**
+     * Returns the result of the experiment task with the given ID or null if
+     * this task does not exist.
+     * 
+     * @param experimentTaskId
+     *            the id of the experiment task
+     * @return the experiment task or null if this task does not exist.
+     */
+    public ExperimentTaskResult getResultOfExperimentTask(int experimentTaskId);
+
     /**
      * This method is called with the description of an experiment task and an
      * experiment id. The method checks whether there is already such an

src/main/java/org/aksw/gerbil/database/ExperimentDAOImpl.java

@@ -20,7 +20,6 @@
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
 
 import javax.sql.DataSource;
@@ -54,6 +53,7 @@ public class ExperimentDAOImpl extends AbstractExperimentDAO {
     private final static String CONNECT_TASK_EXPERIMENT = "INSERT INTO Experiments (id, taskId) VALUES(:id, :taskId)";
     private final static String GET_TASK_STATE = "SELECT state FROM ExperimentTasks WHERE id=:id";
     private final static String GET_EXPERIMENT_RESULTS = "SELECT annotatorName, datasetName, experimentType, matching, microF1, microPrecision, microRecall, macroF1, macroPrecision, macroRecall, state, errorCount, lastChanged, taskId FROM ExperimentTasks t, Experiments e WHERE e.id=:id AND e.taskId=t.id";
+    private final static String GET_EXPERIMENT_TASK_RESULT = "SELECT annotatorName, datasetName, experimentType, matching, microF1, microPrecision, microRecall, macroF1, macroPrecision, macroRecall, state, errorCount, lastChanged, id FROM ExperimentTasks t WHERE id=:id";
     private final static String GET_CACHED_TASK = "SELECT id FROM ExperimentTasks WHERE annotatorName=:annotatorName AND datasetName=:datasetName AND experimentType=:experimentType AND matching=:matching AND lastChanged>:lastChanged AND state>:errorState ORDER BY lastChanged DESC LIMIT 1";
     private final static String GET_HIGHEST_EXPERIMENT_ID = "SELECT id FROM Experiments ORDER BY id DESC LIMIT 1";
     private final static String SET_UNFINISHED_TASK_STATE = "UPDATE ExperimentTasks SET state=:state, lastChanged=:lastChanged WHERE state=:unfinishedState";
@@ -67,7 +67,7 @@ public class ExperimentDAOImpl extends AbstractExperimentDAO {
 
     private final static String GET_ADDITIONAL_RESULTS = "SELECT resultId, value FROM ExperimentTasks_AdditionalResults WHERE taskId=:taskId";
     private final static String INSERT_ADDITIONAL_RESULT = "INSERT INTO ExperimentTasks_AdditionalResults(taskId, resultId, value) VALUES (:taskId, :resultId, :value)";
-    private final static String GET_SUB_TASK_RESULTS = "SELECT annotatorName, datasetName, experimentType, matching, microF1, microPrecision, microRecall, macroF1, macroPrecision, macroRecall, state, errorCount, lastChanged, taskId FROM ExperimentTasks t, ExperimentTasks_SubTasks s WHERE s.taskId=:taskId AND s.subTaskId=t.id";
+    private final static String GET_SUB_TASK_RESULTS = "SELECT annotatorName, datasetName, experimentType, matching, microF1, microPrecision, microRecall, macroF1, macroPrecision, macroRecall, state, errorCount, lastChanged, subTaskId FROM ExperimentTasks t, ExperimentTasks_SubTasks s WHERE s.taskId=:taskId AND s.subTaskId=t.id";
     private final static String INSERT_SUB_TASK_RELATION = "INSERT INTO ExperimentTasks_SubTasks(taskId, subTaskId) VALUES (:taskId, :subTaskId)";
 
     // FIXME remove the following two statements by removing the experiment task
@@ -390,6 +390,24 @@ protected void addSubTasks(ExperimentTaskResult expTask) {
         }
     }
 
+    @Override
+    public ExperimentTaskResult getResultOfExperimentTask(int experimentTaskId) {
+        MapSqlParameterSource parameters = new MapSqlParameterSource();
+        parameters.addValue("id", experimentTaskId);
+        List<ExperimentTaskResult> results = this.template.query(GET_EXPERIMENT_TASK_RESULT, parameters,
+                new ExperimentTaskResultRowMapper());
+        if (results.size() == 0) {
+            return null;
+        }
+        ExperimentTaskResult result = results.get(0);
+        // FIXME remove this ugly workaround regarding the version of an
+        // experiment task
+        addVersion(result);
+        addAdditionalResults(result);
+        addSubTasks(result);
+        return result;
+    }
+
     @Override
     public void close() throws IOException {
         this.template.execute(SHUTDOWN, new PreparedStatementCallback<Object>() {

src/main/java/org/aksw/gerbil/dataid/DataIDGenerator.java

@@ -18,16 +18,19 @@
 
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Iterator;
 import java.util.List;
 
+import org.aksw.gerbil.database.ResultNameToIdMapping;
 import org.aksw.gerbil.datatypes.ExperimentTaskResult;
 import org.aksw.gerbil.semantic.vocabs.CUBE;
 import org.aksw.gerbil.semantic.vocabs.GERBIL;
 import org.aksw.gerbil.web.ExperimentTaskStateHelper;
 import org.apache.jena.riot.RDFDataMgr;
 
+import com.carrotsearch.hppc.IntDoubleOpenHashMap;
 import com.github.jsonldjava.jena.JenaJSONLD;
 import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
 import com.hp.hpl.jena.rdf.model.Model;
@@ -39,21 +42,19 @@
 
 public class DataIDGenerator {
 
-    private static final String EXPERIMENT_PREFIX = "#experiment_";
+    private static final String EXPERIMENT_PREFIX = "experiment?id=";
+    private static final String EXPERIMENT_TASK_PREFIX = "experimentTask_";
     private static final String DATASET_DATAID = "dataId/corpora/";
     private static final String ANNOTATOR_DATAID = "dataId/annotators/";
     private static final String DATAID_EXTENSION = "";
 
     private String gerbilURL;
-    private String gerbilFullURL;
 
-    public DataIDGenerator(String gerbilURL, String gerbilFullURL) {
+    public DataIDGenerator(String gerbilURL) {
         this.gerbilURL = gerbilURL;
-        this.gerbilFullURL = gerbilFullURL;
     }
 
-    public String createDataIDModel(List<ExperimentTaskResult> results, String eID) {
-
+    public Model generateDataIDModel() {
         // create an empty JENA Model
         Model model = ModelFactory.createDefaultModel();
 
@@ -64,23 +65,45 @@ public String createDataIDModel(List<ExperimentTaskResult> results, String eID)
         model.setNsPrefix("xsd", XSD.getURI());
         model.setNsPrefix("qb", CUBE.getURI());
 
+        return model;
+    }
+
+    public String createDataIDModel(List<ExperimentTaskResult> results, String eID) {
         // If the experiment is not existing (== there are no results), return
         // an empty String
         if (results.size() == 0) {
             return "";
         }
 
+        Model model = generateDataIDModel();
+
+        addToModel(model, results, eID);
+
+        // writing dataid result to output
+        OutputStream o = new ByteArrayOutputStream();
+
+        // creating json-ld output format
+        RDFDataMgr.write(o, model, JenaJSONLD.JSONLD);
+
+        return o.toString();
+    }
+
+    public void addToModel(Model model, List<ExperimentTaskResult> results, String eID) {
+        if (results.size() == 0) {
+            return;
+        }
+
         Resource experiment = createExperimentResource(model, eID);
 
-        int experimentNumber = 0;
+        boolean first = true;
         Iterator<ExperimentTaskResult> resultIterator = results.iterator();
         ExperimentTaskResult result;
         // iterating over the experiments
         while (resultIterator.hasNext()) {
             result = resultIterator.next();
             // If this is the first experiment result, use it to get further
             // properties of the experiment (matching, ...)
-            if (experimentNumber == 0) {
+            if (first) {
                 Resource r = GERBIL.getExperimentTypeResource(result.type);
                 if (r != null) {
                     experiment.addProperty(GERBIL.experimentType, r);
@@ -89,27 +112,16 @@ public String createDataIDModel(List<ExperimentTaskResult> results, String eID)
                 if (r != null) {
                     experiment.addProperty(GERBIL.matching, r);
                 }
+                first = false;
             }
             // create experiment task
-            addExperimentTask(model, result, experiment, experimentNumber);
-
-            ++experimentNumber;
+            addExperimentTask(model, result, experiment);
         }
-
-        // writing dataid result to output (this should be removed)
-        // RDFDataMgr.write(System.out, model, RDFFormat.TURTLE);
-
-        OutputStream o = new ByteArrayOutputStream();
-
-        // creating json-ld output format
-        RDFDataMgr.write(o, model, JenaJSONLD.JSONLD);
-
-        return o.toString();
     }
 
-    private Resource createExperimentResource(Model model, String eID) {
+    public Resource createExperimentResource(Model model, String eID) {
         // create experiment resource
-        Resource experiment = model.createResource(gerbilFullURL + EXPERIMENT_PREFIX + eID);
+        Resource experiment = model.createResource(gerbilURL + EXPERIMENT_PREFIX + eID);
         experiment.addProperty(RDF.type, CUBE.Dataset);
         experiment.addProperty(RDF.type, GERBIL.Experiment);
 
@@ -119,36 +131,92 @@ private Resource createExperimentResource(Model model, String eID) {
         return experiment;
     }
 
-    private void addExperimentTask(Model model, ExperimentTaskResult result, Resource experiment, int experimentNumber) {
+    public void addExperimentTask(Model model, ExperimentTaskResult result, Resource experiment) {
+        addExperimentTask(model, result, experiment, null);
+    }
+
+    public void addExperimentTask(Model model, ExperimentTaskResult result, Resource experiment,
+            Resource superExpTask) {
+        List<Resource> experimentTasks = new ArrayList<Resource>();
+        createExperimentTask(model, result, superExpTask, experimentTasks);
+        linkTasksToExperiment(model, experiment, experimentTasks);
+    }
+
+    public void linkTasksToExperiment(Model model, Resource experiment, List<Resource> experimentTasks) {
+        for (Resource experimentTask : experimentTasks) {
+            model.add(experimentTask, CUBE.dataset, experiment.getURI());
+        }
+    }
+
+    public void createExperimentTask(Model model, ExperimentTaskResult result, Resource superExpTask,
+            List<Resource> experimentTasks) {
         // create Resource
-        Resource experimentTask = model.createResource(experiment.getURI() + "_task_" + experimentNumber);
+        Resource experimentTask = model.createResource(generateExperimentTaskUri(result.idInDb));
+        experimentTasks.add(experimentTask);
+        if (model.containsResource(experimentTask)) {
+            return;
+        }
         experimentTask.addProperty(RDF.type, CUBE.Observation);
 
         // add annotator and dataset
         experimentTask.addProperty(GERBIL.annotator,
-                gerbilURL + DATASET_DATAID + DataIDUtils.treatsNames(result.annotator) + DATAID_EXTENSION);
-        experimentTask.addProperty(GERBIL.dataset,
                 gerbilURL + ANNOTATOR_DATAID + DataIDUtils.treatsNames(result.dataset) + DATAID_EXTENSION);
+        experimentTask.addProperty(GERBIL.dataset,
+                gerbilURL + DATASET_DATAID + DataIDUtils.treatsNames(result.annotator) + DATAID_EXTENSION);
 
         // set the status of this task
         model.add(experimentTask, GERBIL.statusCode, model.createTypedLiteral(result.state));
 
+        if (superExpTask != null) {
+            model.add(experimentTask, GERBIL.subExperimentOf, superExpTask);
+        }
+
         // If this task has been finished
         if (ExperimentTaskStateHelper.taskFinished(result)) {
-        	model.add(experimentTask, CUBE.dataset, model.createResource(experiment.getURI()));
             // creating and setting literals for the current experiment
-            model.add(experimentTask, GERBIL.microF1, model.createTypedLiteral(String.valueOf(result.getMicroF1Measure()),XSDDatatype.XSDdecimal));
-            model.add(experimentTask, GERBIL.microPrecision, model.createTypedLiteral(String.valueOf(result.getMicroPrecision()),XSDDatatype.XSDdecimal));
-            model.add(experimentTask, GERBIL.microRecall, model.createTypedLiteral(String.valueOf(result.getMicroRecall()),XSDDatatype.XSDdecimal));
-            model.add(experimentTask, GERBIL.macroF1, model.createTypedLiteral(String.valueOf(result.getMacroF1Measure()),XSDDatatype.XSDdecimal));
-            model.add(experimentTask, GERBIL.macroPrecision, model.createTypedLiteral(String.valueOf(result.getMacroPrecision()),XSDDatatype.XSDdecimal));
-            model.add(experimentTask, GERBIL.macroRecall, model.createTypedLiteral(String.valueOf(result.getMacroRecall()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.microF1,
+                    model.createTypedLiteral(String.valueOf(result.getMicroF1Measure()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.microPrecision,
+                    model.createTypedLiteral(String.valueOf(result.getMicroPrecision()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.microRecall,
+                    model.createTypedLiteral(String.valueOf(result.getMicroRecall()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.macroF1,
+                    model.createTypedLiteral(String.valueOf(result.getMacroF1Measure()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.macroPrecision,
+                    model.createTypedLiteral(String.valueOf(result.getMacroPrecision()), XSDDatatype.XSDdecimal));
+            model.add(experimentTask, GERBIL.macroRecall,
+                    model.createTypedLiteral(String.valueOf(result.getMacroRecall()), XSDDatatype.XSDdecimal));
             model.add(experimentTask, GERBIL.errorCount, model.createTypedLiteral(String.valueOf(result.errorCount)));
+
+            if (result.hasAdditionalResults()) {
+                IntDoubleOpenHashMap additionalResults = result.getAdditionalResults();
+                String propertyUri;
+                ResultNameToIdMapping mapping = ResultNameToIdMapping.getInstance();
+                for (int i = 0; i < additionalResults.allocated.length; ++i) {
+                    if (additionalResults.allocated[i]) {
+                        propertyUri = mapping.getResultName(additionalResults.keys[i]);
+                        if (propertyUri != null) {
+                            propertyUri = GERBIL.getURI() + propertyUri.replace(" ", "_");
+                            model.add(experimentTask, model.createProperty(propertyUri), model.createTypedLiteral(
+                                    String.valueOf(additionalResults.values[i]), XSDDatatype.XSDdecimal));
+                        }
+                    }
+                }
+            }
+            if (result.hasSubTasks()) {
+                for (ExperimentTaskResult subResult : result.getSubTasks()) {
+                    createExperimentTask(model, subResult, experimentTask, experimentTasks);
+                }
+            }
         }
 
         Calendar cal = Calendar.getInstance();
         cal.setTimeInMillis(result.timestamp);
         model.add(experimentTask, GERBIL.timestamp, model.createTypedLiteral(cal));
     }
 
+    public String generateExperimentTaskUri(int taskId) {
+        return gerbilURL + EXPERIMENT_TASK_PREFIX + taskId;
+    }
+
 }

src/main/java/org/aksw/gerbil/dataset/SingletonDatasetConfigImpl.java

@@ -43,11 +43,11 @@ public SingletonDatasetConfigImpl(String annotatorName, boolean couldBeCached,
     }
 
     @Override
-    protected Dataset loadDataset() throws Exception {
+    protected Dataset getPreparedDataset() throws Exception {
         instanceMutex.acquire();
         try {
             if (instance == null) {
-                instance = super.loadDataset();
+                instance = super.getPreparedDataset();
                 instance.setClosePermitionGranter(this);
             }
             ++instanceUsages;

src/main/java/org/aksw/gerbil/dataset/check/impl/HttpBasedEntityChecker.java

@@ -50,7 +50,12 @@ public boolean entityExists(String uri) {
         try {
             request = createHeadRequest(uri);
         } catch (IllegalArgumentException e) {
-            LOGGER.error("Exception while creating HTTP request. Returning false.", e);
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.error("Exception while creating HTTP request. Returning false.", e);
+            } else {
+                LOGGER.error("Exception while creating HTTP request. Returning false. Exception: "
+                        + e.getLocalizedMessage());
+            }
             return false;
         }
         CloseableHttpResponse response = null;
@@ -59,7 +64,12 @@ public boolean entityExists(String uri) {
             StatusLine status = response.getStatusLine();
             return (status.getStatusCode() >= 200) && (status.getStatusCode() < 300);
         } catch (Exception e) {
-            LOGGER.error("Exception while sending HTTP request. Returning false.", e);
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.error("Exception while sending HTTP request. Returning false.", e);
+            } else {
+                LOGGER.error(
+                        "Exception while sending HTTP request. Returning false. Exception: " + e.getLocalizedMessage());
+            }
             return false;
         } finally {
             closeRequest(request);