comparison rdf/SimpleSPARQLQuery.cpp @ 490:c3fb8258e34d

* Make it possible to import an entire session from an RDF document.
  However, at the moment the timings of events appear to be constrained
  by how far the audio decoder has got through its audio file at the
  time the event is queried -- need to investigate.

 #include <rasqal.h>
 #endif
 
 #include <redland.h>
 
-//#define DEBUG_SIMPLE_SPARQL_QUERY 1
+#define DEBUG_SIMPLE_SPARQL_QUERY 1
 
 #include <iostream>
 
 using std::cerr;
 using std::endl;

 
     bool isOK() const { return (m_model != 0); }
 
     librdf_uri *getUri(QString uriString, QString &errorString)
     {
-        QMutexLocker locker(&m_mutex);
-
         if (m_parsedUris.find(uriString) != m_parsedUris.end()) {
             return m_parsedUris[uriString];
         }
 
         librdf_uri *uri = librdf_new_uri

         if (librdf_parser_parse_into_model(parser, uri, NULL, m_model)) {
 
             errorString = QString("Failed to parse RDF from URI \"%1\"")
                 .arg(uriString);
             librdf_free_parser(parser);
-            librdf_free_uri(uri);
+//            librdf_free_uri(uri);
             return 0;
 
         } else {
 
             librdf_free_parser(parser);

 SimpleSPARQLQuery::ResultList
 SimpleSPARQLQuery::Impl::execute()
 {
     ResultList list;
 
-    m_mutex.lock();
+    QMutexLocker locker(&m_mutex);
 
     if (m_type == QueryFromModel) {
         if (!m_redland) {
             // There can be no results, because no sources have been
             // added to the model yet (m_redland is only created when
             // addSourceToModel is called)
             cerr << "SimpleSPARQLQuery::execute: NOTE: No sources have been added to data model yet, so no results are possible" << endl;
-            m_mutex.unlock();
             return list;
         }
     }
 
     if (m_type == QueryFromSingleSource) {

             m_rasqal = new WrasqalWorldWrapper();
             if (!m_rasqal->isOK()) {
                 cerr << "ERROR: SimpleSPARQLQuery::execute: Failed to initialise Rasqal query engine" << endl;
                 delete m_rasqal;
                 m_rasqal = 0;
-                m_mutex.unlock();
                 return list;
             }
         }
 #else
         if (!m_rasqalInitialised) {
             rasqal_init();
             m_rasqalInitialised = true;
         }
 #endif
     }
-
-    m_mutex.unlock();
 
     if (m_type == QueryFromSingleSource) {
         return executeDirectParser();
     } else {
         return executeDatastore();

         for (int i = 0; i < count; ++i) {
 
             const unsigned char *name =
                 rasqal_query_results_get_binding_name(results, i);
 
+            if (!name) {
+                std::cerr << "WARNING: Result " << i << " of query has no name" << std::endl;
+                continue;
+            }
+
             rasqal_literal *literal =
                 rasqal_query_results_get_binding_value(results, i);
 
             QString key = (const char *)name;
 

                 resultmap[key] = Value();
                 continue;
             }
 
             ValueType type = LiteralValue;
-            if (literal->type == RASQAL_LITERAL_URI) type = URIValue;
-            else if (literal->type == RASQAL_LITERAL_BLANK) type = BlankValue;
-
-            QString text = (const char *)rasqal_literal_as_string(literal);
+            if (literal->type == RASQAL_LITERAL_BLANK) type = BlankValue;
+            else if (literal->type == RASQAL_LITERAL_URI) type = URIValue;
+
+            QString text;
+            const char *lit = (const char *)rasqal_literal_as_string(literal);
+            if (!lit) {
+                std::cerr << "WARNING: Result " << i << " of query has null value" << std::endl;
+            } else {
+                text = lit;
+            }
 
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
             std::cerr << i << ". " << key.toStdString() << " -> " << text.toStdString() << " (type " << type << ")" << std::endl;
 #endif
 

         for (int i = 0; i < count; ++i) {
 
             const char *name =
                 librdf_query_results_get_binding_name(results, i);
 
+            if (!name) {
+                std::cerr << "WARNING: Result " << i << " of query has no name" << std::endl;
+                continue;
+            }
+
             librdf_node *node =
                 librdf_query_results_get_binding_value(results, i);
 
             QString key = (const char *)name;
 

 
             if (librdf_node_is_resource(node)) {
 
                 type = URIValue;
                 librdf_uri *uri = librdf_node_get_uri(node);
-                text = (const char *)librdf_uri_as_string(uri);
+                const char *us = (const char *)librdf_uri_as_string(uri);
+
+                if (!us) {
+                    std::cerr << "WARNING: Result " << i << " of query claims URI type, but has null URI" << std::endl;
+                } else {
+                    text = us;
+                }
 
             } else if (librdf_node_is_literal(node)) {
 
                 type = LiteralValue;
-                text = (const char *)librdf_node_get_literal_value(node);
+
+                const char *lit = (const char *)librdf_node_get_literal_value(node);
+                if (!lit) {
+                    std::cerr << "WARNING: Result " << i << " of query claims literal type, but has no literal" << std::endl;
+                } else {
+                    text = lit;
+                }
 
             } else if (librdf_node_is_blank(node)) {
 
                 type = BlankValue;
 

 bool
 SimpleSPARQLQuery::Impl::addSourceToModel(QString sourceUri)
 {
     QString err;
 
-    m_mutex.lock();
+    QMutexLocker locker(&m_mutex);
 
     if (!m_redland) {
         m_redland = new WredlandWorldWrapper();
         if (!m_redland->isOK()) {
             cerr << "ERROR: SimpleSPARQLQuery::addSourceToModel: Failed to initialise Redland datastore" << endl;
             delete m_redland;
             m_redland = 0;
-            m_mutex.unlock();
             return false;
         }
     }
-
-    m_mutex.unlock();
 
     librdf_uri *uri = m_redland->getUri(sourceUri, err);
 
     if (!uri) {
         std::cerr << "SimpleSPARQLQuery::addSourceToModel: Failed to add source URI \"" << sourceUri.toStdString() << ": " << err.toStdString() << std::endl;