comparison rdf/RDFImporter.cpp @ 489:82ab61fa9223

* Reorganise our sparql queries on the basis that Redland must be
  available, not only optional.  So for anything querying the pool
  of data about plugins, we use a single datastore and model which
  is initialised at the outset by PluginRDFIndexer and then queried
  directly; for anything that "reads from a file" (e.g. loading
  annotations) we query directly using Rasqal, going to the
  datastore when we need additional plugin-related information.

  This may improve performance, but mostly it simplifies the code
  and fixes a serious issue with RDF import in the previous versions
  (namely that multiple sequential RDF imports would end up sharing
  the same RDF data pool!)

 void
 RDFImporterImpl::getDataModelsDense(std::vector<Model *> &models,
                                     ProgressReporter *reporter)
 {
     SimpleSPARQLQuery query = SimpleSPARQLQuery
-        (m_uristring,
+        (SimpleSPARQLQuery::QueryFromSingleSource,
          QString
          (
              " PREFIX mo: <http://purl.org/ontology/mo/>"
              " PREFIX af: <http://purl.org/ontology/af/>"
              

 void
 RDFImporterImpl::getDenseFeatureProperties(QString featureUri,
                                            int &sampleRate, int &windowLength,
                                            int &hopSize, int &width, int &height)
 {
+    SimpleSPARQLQuery::QueryType s = SimpleSPARQLQuery::QueryFromSingleSource;
+
     QString dimensionsQuery 
         (
             " PREFIX mo: <http://purl.org/ontology/mo/>"
             " PREFIX af: <http://purl.org/ontology/af/>"
             

             
             " } "
             );
 
     SimpleSPARQLQuery::Value dimensionsValue =
-        SimpleSPARQLQuery::singleResultQuery(m_uristring,
-                                             dimensionsQuery
-                                             .arg(m_uristring).arg(featureUri),
-                                             "dimensions");
+        SimpleSPARQLQuery::singleResultQuery
+        (s, dimensionsQuery.arg(m_uristring).arg(featureUri), "dimensions");
 
     cerr << "Dimensions = \"" << dimensionsValue.value.toStdString() << "\""
          << endl;
 
     if (dimensionsValue.value != "") {

 
     // Another laborious workaround for rasqal's failure to handle
     // multiple optionals properly
 
     SimpleSPARQLQuery::Value srValue = 
-        SimpleSPARQLQuery::singleResultQuery(m_uristring,
+        SimpleSPARQLQuery::singleResultQuery(s,
                                              queryTemplate
                                              .arg(m_uristring).arg(featureUri)
                                              .arg("sampleRate"),
                                              "sampleRate");
     if (srValue.value != "") {
         sampleRate = srValue.value.toInt();
     }
 
     SimpleSPARQLQuery::Value hopValue = 
-        SimpleSPARQLQuery::singleResultQuery(m_uristring,
+        SimpleSPARQLQuery::singleResultQuery(s,
                                              queryTemplate
                                              .arg(m_uristring).arg(featureUri)
                                              .arg("hopSize"),
                                              "hopSize");
     if (srValue.value != "") {
         hopSize = hopValue.value.toInt();
     }
 
     SimpleSPARQLQuery::Value winValue = 
-        SimpleSPARQLQuery::singleResultQuery(m_uristring,
+        SimpleSPARQLQuery::singleResultQuery(s,
                                              queryTemplate
                                              .arg(m_uristring).arg(featureUri)
                                              .arg("windowLength"),
                                              "windowLength");
     if (winValue.value != "") {

 
 void
 RDFImporterImpl::getDataModelsSparse(std::vector<Model *> &models,
                                      ProgressReporter *reporter)
 {
+    SimpleSPARQLQuery::QueryType s = SimpleSPARQLQuery::QueryFromSingleSource;
+
     // Our query is intended to retrieve every thing that has a time,
     // and every feature type and value associated with a thing that
     // has a time.
 
     // We will then need to refine this big bag of results into a set

         "   <%2> rdfs:label ?label . "
         " } "
 
         ).arg(m_uristring);
 
-    SimpleSPARQLQuery query(m_uristring, queryString);
+    SimpleSPARQLQuery query(s, queryString);
     query.setProgressReporter(reporter);
 
     cerr << "Query will be: " << queryString.toStdString() << endl;
 
     SimpleSPARQLQuery::ResultList results = query.execute();

 
         bool haveTime = false;
         bool haveDuration = false;
 
         QString label = SimpleSPARQLQuery::singleResultQuery
-            (m_uristring, labelQueryString.arg(thinguri), "label").value;
-
-        SimpleSPARQLQuery rangeQuery(m_uristring, rangeQueryString.arg(thinguri));
+            (s, labelQueryString.arg(thinguri), "label").value;
+
+        SimpleSPARQLQuery rangeQuery(s, rangeQueryString.arg(thinguri));
         SimpleSPARQLQuery::ResultList rangeResults = rangeQuery.execute();
         if (!rangeResults.empty()) {
 //                std::cerr << rangeResults.size() << " range results" << std::endl;
             time = RealTime::fromXsdDuration
                 (rangeResults[0]["time"].value.toStdString());

 //                std::cerr << "duration string " << rangeResults[0]["duration"].value.toStdString() << std::endl;
             haveTime = true;
             haveDuration = true;
         } else {
             QString timestring = SimpleSPARQLQuery::singleResultQuery
-                (m_uristring, timeQueryString.arg(thinguri), "time").value;
+                (s, timeQueryString.arg(thinguri), "time").value;
             if (timestring != "") {
                 time = RealTime::fromXsdDuration(timestring.toStdString());
                 haveTime = true;
             }
         }