pull up getQueryExecution to superclass

Author: schlotze

context-core/src/main/java/de/atb/context/persistence/common/RepositoryTDB.java

@@ -18,8 +18,14 @@
 import de.atb.context.common.util.BusinessCase;
 import de.atb.context.common.util.IApplicationScenarioProvider;
 import de.atb.context.context.util.OntologyNamespace;
+import org.apache.jena.ontology.OntModel;
+import org.apache.jena.ontology.OntModelSpec;
 import org.apache.jena.query.Dataset;
+import org.apache.jena.query.QueryExecution;
+import org.apache.jena.query.QueryExecutionFactory;
 import org.apache.jena.query.ReadWrite;
+import org.apache.jena.rdf.model.Model;
+import org.apache.jena.rdf.model.ModelFactory;
 import org.apache.jena.tdb.TDB;
 import org.apache.jena.tdb.TDBFactory;
 import org.slf4j.Logger;
@@ -189,4 +195,22 @@ private synchronized Dataset initializeDataset(final BusinessCase bc) throws Con
             throw new ConfigurationException("Data directory for the TDB repository couldn't be created.");
         }
     }
+
+    protected QueryExecution getQueryExecution(String query, boolean useReasoner, Dataset dataset) {
+        if (query == null) {
+            throw new NullPointerException("Query may not be null!");
+        }
+        if (query.trim().length() == 0) {
+            throw new IllegalArgumentException("Query may not be empty!");
+        }
+        String finalQuery = prepareSparqlQuery(query);
+        Model model = dataset.getDefaultModel();
+        OntModel ontModel;
+        if (useReasoner) {
+            ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, model);
+        } else {
+            ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM, model);
+        }
+        return QueryExecutionFactory.create(finalQuery, ontModel);
+    }
 }

context-extraction/src/main/java/de/atb/context/persistence/context/ContextRepository.java

@@ -19,7 +19,6 @@
 import de.atb.context.common.util.BusinessCase;
 import de.atb.context.common.util.IApplicationScenarioProvider;
 import de.atb.context.common.util.TimeFrame;
-import de.atb.context.context.util.OntologyNamespace;
 import de.atb.context.extraction.ContextContainer;
 import de.atb.context.extraction.util.base.BaseDatatypeProperties;
 import de.atb.context.extraction.util.base.BaseOntologyClasses;
@@ -291,7 +290,7 @@ private <R> R executeSparql(BusinessCase businessCase, String query, boolean use
         Dataset dataset = getDataSet(businessCase);
         dataset.begin(ReadWrite.READ);
         try {
-            QueryExecution queryExecution = getQueryExecution(businessCase, query, useReasoner, dataset);
+            QueryExecution queryExecution = getQueryExecution(query, useReasoner, dataset);
             R result = executioner.apply(queryExecution);
             dataset.commit();
             return result;
@@ -304,24 +303,6 @@ private <R> R executeSparql(BusinessCase businessCase, String query, boolean use
         }
     }
 
-    private QueryExecution getQueryExecution(BusinessCase businessCase, String query, boolean useReasoner, Dataset dataset) {
-        if (query == null) {
-            throw new NullPointerException("Query may not be null!");
-        }
-        if (query.trim().length() == 0) {
-            throw new IllegalArgumentException("Query may not be empty!");
-        }
-        String finalQuery = prepareSparqlQuery(query);
-        Model model = dataset.getDefaultModel();
-        OntModel ontModel;
-        if (useReasoner) {
-            ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, model);
-        } else {
-            ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM, model);
-        }
-        return QueryExecutionFactory.create(finalQuery, ontModel);
-    }
-
     /**
      * (non-Javadoc)
      *

context-monitoring/src/main/java/de/atb/context/persistence/monitoring/MonitoringDataRepository.java

@@ -453,20 +453,11 @@ public synchronized ResultSet executeSparqlSelectQuery(final BusinessCase busine
         if (businessCase == null) {
             throw new NullPointerException("BusinessCase may not be null!");
         }
-        if (query == null) {
-            throw new NullPointerException("Query may not be null!");
-        }
-        if (query.trim().length() == 0) {
-            throw new IllegalArgumentException("Query may not be empty!");
-        }
 
-        final String finalQuery = prepareSparqlQuery(query);
         final Dataset dataset = getDataSet(businessCase);
 
         return transactional(dataset, null, () -> {
-            final Model model = dataset.getDefaultModel();
-            final OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM, model);
-            final QueryExecution qexec = QueryExecutionFactory.create(finalQuery, ontModel);
+            final QueryExecution qexec = getQueryExecution(query, false, dataset);
             return qexec.execSelect();
         });
     }