/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #ifdef KONCLUDE_REDLAND_INTEGRATION #include "COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer.h" namespace Konclude { namespace Reasoner { namespace Revision { namespace Persistence { COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer(CConfiguration* config) : CLogIdentifier("::Konclude::Reasoner::Persistence::RedlandExternalTriplesSPARQLServicePersistencer", this) { mConfig = config; mDefaultDatatypeString = PREFIX_XML_STRING_DATATYPE; mBlankNodeIdentifierPrefix = QString("kbni_%1_").arg(QUuid::createUuid().toString().replace("{", "").replace("}", ""));; mConfInitialLoading = CConfigDataReader::readConfigBoolean(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.InitialLoading"); mRDFSerializingFormat = QString("turtle"); mLoadingLimit = CConfigDataReader::readConfigInteger(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.LoadingLimitSize"); mPersistingStepSize = CConfigDataReader::readConfigInteger(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.PersistingStepSize"); mServiceUriData = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.ServiceAddress").toUtf8(); mCheckingQueryString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.CheckingQueryTemplate"); mLoadingQueryString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.LoadingQueryTemplate"); mPersistQueryString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.PersistingQueryTemplate"); mDeletingQueryString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.DeletingQueryTemplate"); mCreatingQueryString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.CreatingQueryTemplate"); mDatabaseNameString = CConfigDataReader::readConfigString(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.TriplesDatabaseName"); mConfPersistPostBatchFormEncoded = CConfigDataReader::readConfigBoolean(mConfig, "Konclude.Persistence.RedlandExternalTriplesSPARQLServicePersistencer.HTTPPostFormEncodedPersisting"); if (mConfPersistPostBatchFormEncoded) { mHttpManager = new CQtHttpTransactionManager(); } else { mHttpManager = nullptr; } } COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::~COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer() { if (mHttpManager) { mHttpManager->stopThread(true); delete mHttpManager; } } COntologyRevisionRedlandExternalStoredTriplesConnectionData* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::getOntologyPersistingTriplesData(const QString& ontName) { COntologyRevisionRedlandExternalStoredTriplesConnectionData* triplesData = mOntologyTriplesDataHash.value(ontName); if (!triplesData) { triplesData = new COntologyRevisionRedlandExternalStoredTriplesConnectionData(); mOntologyTriplesDataHash.insert(ontName, triplesData); } return triplesData; } CRedlandStoredTriplesData* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::getUpdatingTripleData() { bool localTriplesDataFlag = false; CRedlandStoredTriplesData* tripleData = nullptr; if (!tripleData) { tripleData = new CRedlandStoredTriplesData(); tripleData->initTriplesData(TRIPLES_DATA_ADDITION, nullptr); } librdf_world* world = tripleData->getRedlandWorld(); if (!world) { world = librdf_new_world(); librdf_world_open(world); tripleData->setRedlandWorldData(world); } librdf_storage* indexedStorage = tripleData->getRedlandIndexedStorage(); if (!indexedStorage && world) { indexedStorage = librdf_new_storage(world, "hashes", NULL, "hash-type='memory',index-predicates='yes'"); tripleData->setRedlandIndexedStorageData(indexedStorage); } librdf_model* indexedModel = tripleData->getRedlandIndexedModel(); if (!indexedModel && indexedStorage) { indexedModel = librdf_new_model(world, indexedStorage, NULL); tripleData->setRedlandIndexedModelData(indexedModel); } /*else { model = librdf_new_model_from_model(prevModel); tripleData->setRedlandModelData(model); }*/ if (!indexedModel) { delete tripleData; tripleData = nullptr; } return tripleData; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::persistOntologyRevision(COntologyRevision* ontoRev, COntologyRevision* prevOntoRev) { if (mOntologyNameFileHash.contains(prevOntoRev) && ontoRev->getOntology()->getBuildData()->getChangeAxiomList()->size() == prevOntoRev->getOntology()->getBuildData()->getChangeAxiomList()->size()) { COntologyTriplesData* triplesData = ontoRev->getOntology()->getOntologyTriplesData(); COntologyTriplesData* prevTriplesData = prevOntoRev->getOntology()->getOntologyTriplesData(); if (prevTriplesData && triplesData && triplesData->getLatestTriplesData(false) == prevTriplesData->getLatestTriplesData(false) || !prevTriplesData && !triplesData) { mOntologyNameFileHash.insert(ontoRev, mOntologyNameFileHash.value(prevOntoRev)); return true; } } CConcreteOntology* ontology = ontoRev->getOntology(); QString ontName = ontology->getOntologyName(); cint64 ontoVers = ontoRev->getOntologyRevisionDepth(); COntologyRevisionRedlandExternalStoredTriplesConnectionData* revTriplesData = getOntologyPersistingTriplesData(ontName); if (revTriplesData) { COntologyAxiomExpressionsRenderVisitor renderer; COntologyRedlandRDFRenderer rdfRenderer(nullptr); CONTOLOGYAXIOMSET* currAxiomSet = ontology->getBuildData()->getTellAxiomSet(); CQtList axiomList; for (CAxiomExpression* axiomExp : *currAxiomSet) { if (!revTriplesData->getPersistedAxiomExpressionSet()->contains(axiomExp)) { axiomList.append(axiomExp); } } QList triplesDataList; COntologyTriplesData* ontTriplesData = ontoRev->getOntology()->getOntologyTriplesData(); if (ontTriplesData) { for (CTriplesData* tripleData : *ontTriplesData->getAllTriplesData()) { if (!revTriplesData->getPersistedTriplesDataSet()->contains(tripleData)) { triplesDataList.append(tripleData); } } } LOG(INFO, getLogDomain(), logTr("Preparing new revision %2 of ontology '%1' for storing in external triple store").arg(ontName).arg(ontoVers), this); renderer.visitAndRender(axiomList, ontology, &rdfRenderer); renderer.visitAndRender(&triplesDataList, ontology, &rdfRenderer); if (!revTriplesData->isInitiallyLoaded()) { if (hasOntologyPersisted(ontName)) { if (mConfInitialLoading) { loadLatestOntologyRevision(ontName, ontoRev); } } else { createPersistingOntology(ontName); } } revTriplesData->setInitiallyLoaded(true); LOG(INFO, getLogDomain(), logTr("Trying saving new revision %2 of ontology '%1' in external triple store").arg(ontName).arg(ontoVers), this); CRedlandStoredTriplesData* triplesData = (COntologyRevisionRedlandExternalStoredTriplesConnectionData*)rdfRenderer.getRenderedTripleData(nullptr); QByteArray serFormByteArray = mRDFSerializingFormat.toUtf8(); unsigned char* modelString = librdf_model_to_string(triplesData->getRedlandIndexedModel(), nullptr, serFormByteArray.constData(), nullptr, nullptr); QStringList tripleLines = QString::fromUtf8((char*)modelString).split("\n"); QStringList prefixLines; QString firstTripleLine = tripleLines.first().trimmed(); while (!tripleLines.isEmpty() && firstTripleLine.toUpper().startsWith("PREFIX") || firstTripleLine.toUpper().startsWith("@PREFIX")) { if (firstTripleLine.toUpper().startsWith("PREFIX")) { QString line = firstTripleLine.mid(6); if (line.endsWith(".")) { line = line.mid(0, line.length() - 1); } QString prefixLine = QString("PREFIX %1").arg(line); prefixLines.append(prefixLine); } else if (firstTripleLine.toUpper().startsWith("@PREFIX")) { QString line = firstTripleLine.mid(7); if (line.endsWith(".")) { line = line.mid(0, line.length() - 1); } QString prefixLine = QString("PREFIX %1").arg(line); prefixLines.append(prefixLine); } tripleLines.takeFirst(); if (!tripleLines.isEmpty()) { firstTripleLine = tripleLines.first().trimmed(); } } cint64 triplesSentCount = 0; cint64 persistingStep = 0; while (!tripleLines.isEmpty()) { persistingStep++; cint64 persistingCount = 0; QStringList persistingTripleLines; bool breakPoint = false; while (!tripleLines.isEmpty() && (persistingCount < mPersistingStepSize || !breakPoint || mPersistingStepSize <= 0)) { QString line = tripleLines.takeFirst().trimmed(); if (!line.isEmpty()) { persistingTripleLines.append(line); if (line.endsWith(".")) { breakPoint = true; } else if (!line.isEmpty()) { breakPoint = false; } triplesSentCount++; } persistingCount++; } if (!persistingTripleLines.isEmpty()) { QString persistQueryString = mPersistQueryString; QString encodedOntologyName = ontName; persistQueryString = replaceQueryStringVariables(persistQueryString, encodedOntologyName, mConfPersistPostBatchFormEncoded); persistQueryString = persistQueryString.replace("$PrefixesString", prefixLines.join("\r\n")); persistQueryString = persistQueryString.replace("$TriplesString", persistingTripleLines.join("\r\n")); if (mConfPersistPostBatchFormEncoded) { sendPersistingHTTPPostFormEncodedRequest(persistQueryString, ontName); } else { sendPersistingRedlandClientRequest(persistQueryString, ontName); } } } LOG(INFO, getLogDomain(), logTr("Saved new revision %2 of ontology '%1' in external triple store by sending %3 triples").arg(ontName).arg(ontoVers).arg(triplesSentCount), this); for (CAxiomExpression* axiomExp : *currAxiomSet) { revTriplesData->getPersistedAxiomExpressionSet()->insert(axiomExp); } if (ontTriplesData) { for (CTriplesData* tripleData : *ontTriplesData->getAllTriplesData()) { revTriplesData->getPersistedTriplesDataSet()->insert(tripleData); } } CXLinker* statementLinker = triplesData->getRedlandStatementLinker(); for (CXLinker* statementLinkerIt = statementLinker; statementLinkerIt; ) { CXLinker* tmpStatementLinker = statementLinkerIt; statementLinkerIt = statementLinkerIt->getNext(); librdf_statement* statement = tmpStatementLinker->getData(); librdf_free_statement(statement); delete tmpStatementLinker; } triplesData->setRedlandStatementLinker(nullptr); delete triplesData; } return true; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::sendPersistingHTTPPostFormEncodedRequest(const QString &persistQueryString, const QString& ontName) { // may require some additional grants for user SPARQL for virtuoso, e.g., (can be executed in the SQL command line) //GRANT EXECUTE ON DB.DBA.SPARQL_INSERT_CTOR_ACC TO "SPARQL"; //GRANT EXECUTE ON DB.DBA.SPARQL_INS_OR_DEL_OR_MODIFY_CTOR_FIN TO "SPARQL"; QString databaseNameString = replaceQueryStringVariables(mDatabaseNameString, ontName); QByteArray postData; QUrlQuery query; query.addQueryItem("default-graph-uri", databaseNameString.replace("%","%25")); query.addQueryItem("query", persistQueryString); postData = query.toString(QUrl::FullyEncoded).toUtf8(); CHttpRequest* request = mHttpManager->createRequest(mServiceUriData, postData); mHttpManager->setRequestHeader(request, "Content-Type", "application/x-www-form-urlencoded"); CHttpResponse* response = mHttpManager->getResponse(request); mHttpManager->waitFinished(response); QString* resText = mHttpManager->getExtractedText(response); QString* errorString = mHttpManager->getErrorString(response); delete resText; delete errorString; mHttpManager->releaseResponse(response, true); return true; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::sendPersistingRedlandClientRequest(const QString &persistQueryString, const QString& ontName) { QByteArray persitQueryData = persistQueryString.toUtf8(); CRedlandStoredTriplesData* newTriplesData = getUpdatingTripleData(); librdf_world* world = newTriplesData->getRedlandWorld(); rasqal_service* rasqalService = getRasqalService(world, ontName, persitQueryData); rasqal_query_results* results = rasqal_service_execute(rasqalService); // may require some additional grants for user SPARQL for virtuoso, e.g., (can be executed in the SQL command line) //GRANT EXECUTE ON DB.DBA.SPARQL_INSERT_DICT_CONTENT TO "SPARQL"; //GRANT EXECUTE ON DB.DBA.L_O_LOOK TO "SPARQL"; //if (!rasqal_query_results_finished(results)) { // bool error = true; //} if (results) { rasqal_free_query_results(results); } rasqal_free_service(rasqalService); delete newTriplesData; return true; } QString COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::replaceQueryStringVariables(QString string, const QString& ontologyName, bool doublePercentageEncoding) { if (string.contains("$KnowledgeBaseName")) { string = string.replace("$KnowledgeBaseName", ontologyName); } if (string.contains("$PercentEncodedKnowledgeBaseName")) { QString encodedOntologyName = QUrl::toPercentEncoding(ontologyName); if (doublePercentageEncoding) { // qt somehow does not encode the % symbol correctly encodedOntologyName = encodedOntologyName.replace("%", "%25"); } string = string.replace("$PercentEncodedKnowledgeBaseName", encodedOntologyName); } return string; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::hasOntologyPersisted(const QString& ontologyName) { bool hasOntologyPersisted = false; QString checkingQueryString = mCheckingQueryString; checkingQueryString = replaceQueryStringVariables(checkingQueryString, ontologyName); QByteArray checkingQueryData = checkingQueryString.toUtf8(); CRedlandStoredTriplesData* newTriplesData = getUpdatingTripleData(); librdf_world* world = newTriplesData->getRedlandWorld(); rasqal_service* rasqalService = getRasqalService(world, ontologyName, checkingQueryData); rasqal_query_results* results = rasqal_service_execute(rasqalService); CXLinker* statmentLinker = nullptr; CXLinker* lastStatementLinker = nullptr; if (results && rasqal_query_results_is_bindings(results)) { if (!rasqal_query_results_finished(results)) { hasOntologyPersisted = true; } } if (results) { rasqal_free_query_results(results); } rasqal_free_service(rasqalService); delete newTriplesData; return hasOntologyPersisted; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::hasNewOntologyRevision(const QString& ontologyName, COntologyRevision* ontoRev) { if (hasOntologyPersisted(ontologyName)) { COntologyRevisionRedlandExternalStoredTriplesConnectionData* triplesData = getOntologyPersistingTriplesData(ontologyName); if (triplesData && !triplesData->isInitiallyLoaded()) { return true; } } return false; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::deletePersistedOntology(const QString& ontologyName) { QByteArray deleteQueryData = mDeletingQueryString.toUtf8(); deleteQueryData = replaceQueryStringVariables(deleteQueryData, ontologyName).toUtf8(); CRedlandStoredTriplesData* newTriplesData = getUpdatingTripleData(); librdf_world* world = newTriplesData->getRedlandWorld(); rasqal_service* rasqalService = getRasqalService(world, ontologyName, deleteQueryData); rasqal_query_results* results = rasqal_service_execute(rasqalService); if (results) { rasqal_free_query_results(results); } rasqal_free_service(rasqalService); delete newTriplesData; LOG(INFO, getLogDomain(), logTr("Deleted persisted version of ontology '%1' in external triple store").arg(ontologyName), this); return true; } bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::createPersistingOntology(const QString& ontologyName) { QByteArray creatingQueryData = mCreatingQueryString.toUtf8(); creatingQueryData = replaceQueryStringVariables(creatingQueryData, ontologyName).toUtf8(); CRedlandStoredTriplesData* newTriplesData = getUpdatingTripleData(); librdf_world* world = newTriplesData->getRedlandWorld(); rasqal_service* rasqalService = getRasqalService(world, ontologyName, creatingQueryData); rasqal_query_results* results = rasqal_service_execute(rasqalService); if (results) { rasqal_free_query_results(results); } rasqal_free_service(rasqalService); delete newTriplesData; LOG(INFO, getLogDomain(), logTr("Created database for persisting ontology '%1' in external triple store").arg(ontologyName), this); return true; } librdf_node* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::createIRIResourceNode(const QString& iri, librdf_world* world) { QByteArray bytes = iri.toUtf8(); raptor_uri* uri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)bytes.constData()); librdf_node* node = librdf_new_node_from_uri(world, uri); return node; } librdf_node* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::createBlankNode(const QString& identifier, librdf_world* world) { QByteArray bytes = identifier.toUtf8(); librdf_node* node = librdf_new_node_from_blank_identifier(world, (const unsigned char*)bytes.constData()); return node; } librdf_node* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::createBlankNode(cint64 id, librdf_world* world) { QString identifier = QString("%1%2").arg(mBlankNodeIdentifierPrefix).arg(id); QByteArray bytes = identifier.toUtf8(); librdf_node* node = librdf_new_node_from_blank_identifier(world, (const unsigned char*)bytes.constData()); return node; } librdf_node* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::createLiteralNode(const QString& literal, const QString& datatype, librdf_world* world) { QByteArray datatypeBytes = datatype.toUtf8(); librdf_uri* datatypeUri = nullptr; if (datatype != mDefaultDatatypeString) { librdf_new_uri(world, (const unsigned char*)datatypeBytes.constData()); } QByteArray literalBytes = literal.toUtf8(); librdf_node* node = librdf_new_node_from_typed_literal(world, (const unsigned char*)literalBytes.constData(), NULL, datatypeUri); return node; }; bool COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::loadLatestOntologyRevision(const QString& ontologyName, COntologyRevision* ontoRev) { COntologyRevisionRedlandExternalStoredTriplesConnectionData* triplesData = getOntologyPersistingTriplesData(ontologyName); if (triplesData && !triplesData->isInitiallyLoaded() && mConfInitialLoading && hasOntologyPersisted(ontologyName)) { LOG(INFO, getLogDomain(), logTr("Trying loading of initial revision of ontology '%1' from external SPARQL service").arg(ontologyName), this); CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ontoRev->getOntology()); builder->initializeBuilding(); CRedlandStoredTriplesData* newTriplesData = nullptr; cint64 statementCount = 0; newTriplesData = getUpdatingTripleData(); cint64 offset = 0; bool continueLoading = true; while (continueLoading) { continueLoading = false; bool hasLoadingLimit = false; QString loadingQueryString = mLoadingQueryString; loadingQueryString = replaceQueryStringVariables(loadingQueryString, ontologyName); if (loadingQueryString.contains("$LoadingLimit") && loadingQueryString.contains("$LoadingOffset")) { hasLoadingLimit = true; loadingQueryString = loadingQueryString.replace("$LoadingLimit", QString::number(mLoadingLimit)); loadingQueryString = loadingQueryString.replace("$LoadingOffset", QString::number(offset)); offset += mLoadingLimit; } QByteArray loadingQueryData = loadingQueryString.toUtf8(); librdf_world* world = newTriplesData->getRedlandWorld(); rasqal_service* rasqalService = getRasqalService(world, ontologyName, loadingQueryData); rasqal_query_results* results = rasqal_service_execute(rasqalService); CXLinker* statmentLinker = nullptr; CXLinker* lastStatementLinker = nullptr; if (results && rasqal_query_results_is_bindings(results)) { int bindCount = rasqal_query_results_get_bindings_count(results); const unsigned char **names = nullptr; rasqal_literal** values = nullptr; QByteArray plainLiteralBytes = QString(PREFIX_XML_PLAINLITERAL_DATATYPE).toUtf8(); librdf_uri *plainLiteralUri = librdf_new_uri(world, (const unsigned char*)plainLiteralBytes.constData()); while (!rasqal_query_results_finished(results)) { if (rasqal_query_results_get_bindings(results, &names, &values)) break; if (names) { cint64 nodeSet = 0; librdf_node* node[3] = { nullptr, nullptr, nullptr }; if (statementCount > 10) { bool debug = true; } for (int i = 0; names[i]; i++) { rasqal_literal* valueNode = values[i]; if (valueNode) { rasqal_literal_type type = rasqal_literal_get_type(valueNode); if (type == RASQAL_LITERAL_URI) { const unsigned char* chrString = rasqal_literal_as_string(valueNode); QString valueString = QString::fromUtf8((char*)chrString); if (valueString.startsWith("_:")) { node[i] = createBlankNode(valueString.mid(2), world); } else { node[i] = createIRIResourceNode(valueString, world); } nodeSet++; } else if (type == RASQAL_LITERAL_BLANK) { const unsigned char* chrString = rasqal_literal_as_string(valueNode); node[i] = createBlankNode(QString::fromUtf8((char*)chrString), world); nodeSet++; } else if (type == RASQAL_LITERAL_STRING) { const unsigned char* chrString = rasqal_literal_as_string(valueNode); raptor_uri* datatypeUri = rasqal_literal_datatype(valueNode); if (datatypeUri) { const unsigned char* datatypeString = raptor_uri_as_string(datatypeUri); node[i] = createLiteralNode(QString::fromUtf8((char*)chrString), QString::fromUtf8((char*)datatypeString), world); } else { node[i] = createLiteralNode(QString::fromUtf8((char*)chrString), "", world); } nodeSet++; } else { const unsigned char* chrString = rasqal_literal_as_string(valueNode); raptor_uri* datatypeUri = rasqal_literal_datatype(valueNode); if (datatypeUri) { const unsigned char* datatypeString = raptor_uri_as_string(datatypeUri); node[i] = createLiteralNode(QString::fromUtf8((char*)chrString), QString::fromUtf8((char*)datatypeString), world); } } } if (nodeSet >= 3) { if (hasLoadingLimit) { continueLoading = true; } librdf_statement* newStatement = librdf_new_statement_from_nodes(world, node[0], node[1], node[2]); librdf_model_add_statement(newTriplesData->getRedlandIndexedModel(), newStatement); CXLinker* tmpRenderedLinker = new CXLinker(); tmpRenderedLinker->initLinker(newStatement); statementCount++; if (tmpRenderedLinker) { if (!statmentLinker) { statmentLinker = tmpRenderedLinker; lastStatementLinker = statmentLinker->getLastListLink(); } else { lastStatementLinker->append(tmpRenderedLinker); lastStatementLinker = tmpRenderedLinker->getLastListLink(); } } } } } rasqal_query_results_next(results); } } newTriplesData->setRedlandStatementLinker(statmentLinker); if (results) { rasqal_free_query_results(results); } rasqal_free_service(rasqalService); } builder->addTriplesData(newTriplesData); triplesData->getPersistedTriplesDataSet()->insert(newTriplesData); CConcreteOntologyRedlandTriplesDataExpressionMapper* triplesMapper = new CConcreteOntologyRedlandTriplesDataExpressionMapper(builder); triplesMapper->mapTriples(ontoRev->getOntology(), ontoRev->getOntology()->getOntologyTriplesData()); QSet* axioms = builder->getAddedAxiomSet(); for (CAxiomExpression* axiom : *axioms) { triplesData->getPersistedAxiomExpressionSet()->insert(axiom); } builder->completeBuilding(); delete builder; LOG(INFO, getLogDomain(), logTr("Loaded initial revision of ontology '%1' from external SPARQL service").arg(ontologyName), this); triplesData->setInitiallyLoaded(true); return true; } return false; } rasqal_service* COntologyRevisionRedlandExternalTriplesSPARQLServicePersistencer::getRasqalService(librdf_world* world, const QString& ontologyName, QByteArray &queryData) { rasqal_world* rasqalWorld = librdf_world_get_rasqal(world); raptor_uri* serviceUri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)mServiceUriData.constData()); QString databaseNameString = replaceQueryStringVariables(mDatabaseNameString, ontologyName); QByteArray databaseNameData = databaseNameString.toUtf8(); raptor_uri* databaseNameUri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)databaseNameData.constData()); rasqal_data_graph* dataGraph = rasqal_new_data_graph_from_uri(rasqalWorld, databaseNameUri, databaseNameUri, RASQAL_DATA_GRAPH_BACKGROUND, NULL, NULL, NULL); raptor_sequence* dataGraphs = raptor_new_sequence(nullptr, nullptr); raptor_sequence_set_at(dataGraphs, 0, dataGraph); rasqal_service* rasqalService = rasqal_new_service(rasqalWorld, serviceUri, (const unsigned char*)queryData.constData(), dataGraphs); return rasqalService; } }; // end namespace Persistence }; // end namespace Revision }; // end namespace Reasoner }; // end namespace Konclude #endif // !KONCLUDE_REDLAND_INTEGRATION