Debian Codegraph @

Source/Reasoner/Triples/CRedlandStoredTriplesIndividualAssertionIndexCache.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20 #ifdef KONCLUDE_REDLAND_INTEGRATION
21
22 #include "CRedlandStoredTriplesIndividualAssertionIndexCache.h"
23
24
25 namespace Konclude {
26
27 namespace Reasoner {
28
29 namespace Triples {
30
31
32 CRedlandStoredTriplesIndividualAssertionIndexCache::CRedlandStoredTriplesIndividualAssertionIndexCache(const QString& kbName, CRedlandStoredTriplesData* tripleData, CConfigurationBase* config) {
33 mTripleData = tripleData;
34 mConfig = config;
35 mKBName = kbName;
36 initRepresentativeStore();
37 }
38
39
40 CRedlandStoredTriplesIndividualAssertionIndexCache::~CRedlandStoredTriplesIndividualAssertionIndexCache() {
41 delete mIndividualAssertionsIndexCache;
42 delete mIndividualIdAssertionsIndexDataHash;
43 }
44
45
46 CRedlandStoredTriplesIndividualAssertionIndexCache* CRedlandStoredTriplesIndividualAssertionIndexCache::beginIndexing() {
47 return this;
48 }
49
50 CRedlandStoredTriplesIndividualAssertionIndexCache* CRedlandStoredTriplesIndividualAssertionIndexCache::completeIndexing() {
51 for (QHash<cint64, CRedlandStoredTriplesIndividualAssertionIndexCacheData*>::const_iterator it = mIndividualIdAssertionsIndexDataHash->constBegin(), itEnd = mIndividualIdAssertionsIndexDataHash->constEnd(); it != itEnd; ++it) {
52 CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData = it.value();
53 if (cacheData->getExtensionData(false)) {
54 updateCacheData(cacheData);
55 }
56 }
57 return this;
58 }
59
60
61
62 CRedlandStoredTriplesIndividualAssertionIndexCache* CRedlandStoredTriplesIndividualAssertionIndexCache::initRepresentativeStore() {
63
64 cint64 cacheSize = CConfigDataReader::readConfigInteger(mConfig, "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.CacheSize", 1500000);
65 mIndividualAssertionsIndexCache = new QCache<CRedlandNodeHasher, CRedlandStoredTriplesIndividualAssertionIndexCacheData>(cacheSize);
66 mIndividualIdAssertionsIndexDataHash = new QHash<cint64, CRedlandStoredTriplesIndividualAssertionIndexCacheData*>();
67
68 bool externalTriplesDBCaching = CConfigDataReader::readConfigBoolean(mConfig, "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.ExternalTriplesDatabaseCaching", false);
69
70 librdf_world* world = mTripleData->getRedlandWorld();
71
72 librdf_storage* storage = mTripleData->getRedlandIndexedStorage();
73 if (world) {
74 if (externalTriplesDBCaching) {
75 QString dsnConfigString = CConfigDataReader::readConfigString(mConfig, "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.ExternalTriplesDatabaseCaching.DSNConfig");
76 QString dbNameString = CConfigDataReader::readConfigString(mConfig, "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.ExternalTriplesDatabaseCaching.TriplesDatabaseName");
77
78 if (dbNameString.contains("$KnowledgeBaseName")) {
79 dbNameString = dbNameString.replace("$KnowledgeBaseName", mKBName);
80 }
81 if (dbNameString.contains("$PercentEncodedKnowledgeBaseName")) {
82 dbNameString = dbNameString.replace("$PercentEncodedKnowledgeBaseName", QUrl::toPercentEncoding(mKBName));
83 }
84 QByteArray dbNameData = dbNameString.toUtf8();
85 QByteArray dsnConfigData = dsnConfigString.toUtf8();
86 mRepresentativeStorage = librdf_new_storage(world, "virtuoso", dbNameData.constData(), dsnConfigData.constData());
87
88 if (mRepresentativeStorage) {
89 mExternalTripleDataStroing = true;
90 }
91
92 }
93 if (!mRepresentativeStorage) {
94 mRepresentativeStorage = librdf_new_storage(world, "hashes", NULL, "hash-type='memory'");
95 }
96 }
97
98 if (mRepresentativeStorage) {
99 mRepresentativeModel = librdf_new_model(world, mRepresentativeStorage, NULL);
100
101 bool clearAtInit = CConfigDataReader::readConfigBoolean(mConfig, "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.ExternalTriplesDatabaseCaching.ClearAtInit");
102 if (mRepresentativeModel && clearAtInit && mExternalTripleDataStroing) {
103
104 //librdf_stream* stream = librdf_model_as_stream(mRepresentativeModel);
105 //if (stream) {
106 // while (!librdf_stream_end(stream)) {
107 // librdf_statement* statement = librdf_stream_get_object(stream);
108 // librdf_model_remove_statement(mRepresentativeModel, statement);
109 // librdf_free_stream(stream);
110 // librdf_storage_sync(mRepresentativeStorage);
111 // stream = librdf_model_as_stream(mRepresentativeModel);
112 // }
113 // librdf_free_stream(stream);
114 //}
115 //CXLinker<librdf_statement*>* statementLinker = nullptr;
116 librdf_stream* stream = librdf_model_as_stream(mRepresentativeModel);
117 if (stream) {
118 while (!librdf_stream_end(stream)) {
119 librdf_statement* statement = librdf_stream_get_object(stream);
120 librdf_model_remove_statement(mRepresentativeModel, statement);
121 //CXLinker<librdf_statement*>* tmpStatementLinker = new CXLinker<librdf_statement*>(librdf_new_statement_from_statement(statement));
122 //statementLinker = tmpStatementLinker->append(statementLinker);
123 librdf_stream_next(stream);
124 }
125 librdf_free_stream(stream);
126 }
127 //for (CXLinker<librdf_statement*>* statementLinkerIt = statementLinker; statementLinkerIt; statementLinkerIt = statementLinkerIt->getNext()) {
128 // librdf_statement* statement = statementLinkerIt->getData();
129 // librdf_model_remove_statement(mRepresentativeModel, statement);
130 //}
131
132
133
134 }
135
136 }
137
138
139 if (mRepresentativeModel) {
140 mIndividualNodeRetrievalByIdStatement = initPartialFilteringStatement(nullptr, mIndividualIdPredicateUri, nullptr);
141 mIndividualIdRetrievalByNodeStatement = initPartialFilteringStatement(nullptr, mIndividualIdPredicateUri, nullptr);
142 mIndividualIdInsertionStatement = initPartialFilteringStatement(nullptr, mIndividualIdPredicateUri, nullptr);
143 mRepresentativeTypeFilteringStatement = initPartialFilteringStatement(nullptr, mRepresentativeIdObjectPredicateUri, nullptr);
144
145 mRepresentativeNonAnonymousObjectNode = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)mRepresentativeNonAnonymousObjectUri);
146 mIndividualNonAnonymityInsertionStatement = initPartialFilteringStatement(nullptr, mRepresentativeNonAnonymousPredicateUri, nullptr);
147 librdf_statement_set_object(mIndividualNonAnonymityInsertionStatement, librdf_new_node_from_node(mRepresentativeNonAnonymousObjectNode));
148 }
149
150 return this;
151
152 }
153
154
155
156 librdf_statement* CRedlandStoredTriplesIndividualAssertionIndexCache::initPartialFilteringStatement(const char* subjectFilterUri, const char* predicateFilterUri, const char* objectFilterUri) {
157 librdf_statement* partial_statement = librdf_new_statement(mTripleData->getRedlandWorld());
158 librdf_node* subject = nullptr;
159 if (subjectFilterUri) {
160 subject = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)subjectFilterUri);
161 librdf_statement_set_subject(partial_statement, subject);
162 }
163 librdf_node* predicate = nullptr;
164 if (predicateFilterUri) {
165 predicate = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)predicateFilterUri);
166 librdf_statement_set_predicate(partial_statement, predicate);
167 }
168 librdf_node* object = nullptr;
169 if (objectFilterUri) {
170 object = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)objectFilterUri);
171 librdf_statement_set_object(partial_statement, object);
172 }
173 return partial_statement;
174 }
175
176
177
178
179
180 CRedlandStoredTriplesIndividualAssertionIndexCacheDataUpdateHandler* CRedlandStoredTriplesIndividualAssertionIndexCache::releaseCacheData(CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData) {
181 if (cacheData->getExtensionData(false)) {
182 updateCacheData(cacheData);
183 }
184 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* currentRepIndiAssIndData = cacheData->getCurrentRepresentativeIndividualAssertionsIndexData();
185 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* storedRepIndiAssIndData = cacheData->getStoredRepresentativeIndividualAssertionsIndexData();
186 librdf_node* indiNode = cacheData->getIndividualNode();
187 if (currentRepIndiAssIndData != storedRepIndiAssIndData) {
188 // write update to store/model
189
190 if (storedRepIndiAssIndData->getRepresentativeTypeConceptsSet() != currentRepIndiAssIndData->getRepresentativeTypeConceptsSet()) {
191 librdf_statement* representativeTypeStatement = librdf_new_statement_from_statement(mRepresentativeTypeFilteringStatement);
192 librdf_statement_set_subject(representativeTypeStatement, librdf_new_node_from_node(indiNode));
193
194 if (storedRepIndiAssIndData->getRepresentativeTypeConceptsSet() != mTagTypeConceptsSetHash.getBaseTagSet()) {
195 librdf_statement* representativeTypeObjectStatement = librdf_new_statement_from_statement(representativeTypeStatement);
196 QByteArray prevRepTypeIdCharData = QString("t:%1").arg(storedRepIndiAssIndData->getRepresentativeTypeConceptsSet()->getRepresentativeId()).toUtf8();
197 librdf_node* prevRepTypeNode = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)prevRepTypeIdCharData.constData());
198 librdf_statement_set_object(representativeTypeObjectStatement, prevRepTypeNode);
199 librdf_model_remove_statement(mRepresentativeModel, representativeTypeObjectStatement);
200 librdf_free_statement(representativeTypeObjectStatement);
201 }
202
203 if (currentRepIndiAssIndData->getRepresentativeTypeConceptsSet() != mTagTypeConceptsSetHash.getBaseTagSet()) {
204 librdf_statement* representativeTypeObjectStatement = librdf_new_statement_from_statement(representativeTypeStatement);
205 QByteArray newRepTypeIdCharData = QString("t:%1").arg(currentRepIndiAssIndData->getRepresentativeTypeConceptsSet()->getRepresentativeId()).toUtf8();
206 librdf_node* newRepTypeNode = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)newRepTypeIdCharData.constData());
207 librdf_statement_set_object(representativeTypeObjectStatement, newRepTypeNode);
208 librdf_model_add_statement(mRepresentativeModel, representativeTypeObjectStatement);
209 mIndividualDataWritenToStore = true;
210 librdf_free_statement(representativeTypeObjectStatement);
211 }
212
213 //librdf_free_statement(representativeTypeStatement);
214 }
215 currentRepIndiAssIndData->getRepresentativeTypeConceptsSet()->removeIndividualCacheData(cacheData, true);
216
217 writeRepresentativeTagRoleSetToStore('o', cacheData, currentRepIndiAssIndData->getRepresentativeOutgoingObjectRolesSet(), storedRepIndiAssIndData->getRepresentativeOutgoingObjectRolesSet(), mTagOutgoingObjectRolesSetHash.getBaseTagSet());
218 writeRepresentativeTagRoleSetToStore('i', cacheData, currentRepIndiAssIndData->getRepresentativeIncomingObjectRolesSet(), storedRepIndiAssIndData->getRepresentativeIncomingObjectRolesSet(), mTagIncomingObjectRolesSetHash.getBaseTagSet());
219 writeRepresentativeTagRoleSetToStore('d', cacheData, currentRepIndiAssIndData->getRepresentativeOutgoingDataRolesSet(), storedRepIndiAssIndData->getRepresentativeOutgoingDataRolesSet(), mTagOutgoingDataRolesSetHash.getBaseTagSet());
220 } else {
221 currentRepIndiAssIndData->getRepresentativeTypeConceptsSet()->removeIndividualCacheData(cacheData, true);
222 currentRepIndiAssIndData->getRepresentativeOutgoingObjectRolesSet()->removeIndividualCacheData(cacheData, true);
223 currentRepIndiAssIndData->getRepresentativeIncomingObjectRolesSet()->removeIndividualCacheData(cacheData, true);
224 currentRepIndiAssIndData->getRepresentativeOutgoingDataRolesSet()->removeIndividualCacheData(cacheData, true);
225 }
226
227 if (!cacheData->isAnonymous() && !cacheData->isIndividualNonAnonymityStored()) {
228 librdf_statement* indiNonAnonStatement = librdf_new_statement_from_statement(mIndividualNonAnonymityInsertionStatement);
229 librdf_statement_set_subject(indiNonAnonStatement, librdf_new_node_from_node(indiNode));
230 librdf_model_add_statement(mRepresentativeModel, indiNonAnonStatement);
231 //librdf_free_statement(indiNonAnonStatement);
232 mIndividualDataWritenToStore = true;
233 }
234
235 if (!cacheData->isIndividualIdStored()) {
236 librdf_statement* indiIdStatement = librdf_new_statement_from_statement(mIndividualIdInsertionStatement);
237 librdf_statement_set_subject(indiIdStatement, librdf_new_node_from_node(indiNode));
238
239
240 QByteArray indiIdCharData = QString::number(cacheData->getIndividualId()).toUtf8();
241 librdf_node* indiIdNode = librdf_new_node_from_typed_counted_literal(mTripleData->getRedlandWorld(), (const unsigned char*)indiIdCharData.constData(), indiIdCharData.length(), nullptr, 0, nullptr);
242 librdf_statement_set_object(indiIdStatement, indiIdNode);
243 librdf_model_add_statement(mRepresentativeModel, indiIdStatement);
244 //librdf_free_statement(indiIdStatement);
245 mIndividualDataWritenToStore = true;
246 }
247 mIndividualIdAssertionsIndexDataHash->remove(cacheData->getIndividualId());
248 librdf_free_node(indiNode);
249
250 return this;
251 }
252
253
254
255
256 CRedlandStoredTriplesIndividualAssertionIndexCache* CRedlandStoredTriplesIndividualAssertionIndexCache::writeRepresentativeTagRoleSetToStore(char encodingChar, CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData, CRedlandStoredTriplesRepresentativeTagRolesSet* newTagRoleSet, CRedlandStoredTriplesRepresentativeTagRolesSet* prevTagRoleSet, CRedlandStoredTriplesRepresentativeTagRolesSet* baseTagRoleSet) {
257
258 librdf_node* indiNode = cacheData->getIndividualNode();
259 if (newTagRoleSet != prevTagRoleSet) {
260 librdf_statement* representativeTypeStatement = librdf_new_statement_from_statement(mRepresentativeTypeFilteringStatement);
261 librdf_statement_set_subject(representativeTypeStatement, librdf_new_node_from_node(indiNode));
262
263 if (prevTagRoleSet != baseTagRoleSet) {
264 librdf_node*& prevRepTypeNode = prevTagRoleSet->getRedlandTagNode();
265 if (!prevRepTypeNode) {
266 QByteArray prevRepTypeIdCharData = QString("%1:%2").arg(encodingChar).arg(prevTagRoleSet->getRepresentativeId()).toUtf8();
267 prevRepTypeNode = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)prevRepTypeIdCharData.constData());
268 }
269 librdf_statement* representativeTypeObjectStatement = librdf_new_statement_from_statement(representativeTypeStatement);
270 librdf_statement_set_object(representativeTypeObjectStatement, librdf_new_node_from_node(prevRepTypeNode));
271 librdf_model_remove_statement(mRepresentativeModel, representativeTypeObjectStatement);
272 librdf_free_statement(representativeTypeObjectStatement);
273 }
274
275 if (newTagRoleSet != baseTagRoleSet) {
276 librdf_node*& newRepTypeNode = newTagRoleSet->getRedlandTagNode();
277 if (!newRepTypeNode) {
278 QByteArray newRepTypeIdCharData = QString("%1:%2").arg(encodingChar).arg(newTagRoleSet->getRepresentativeId()).toUtf8();
279 newRepTypeNode = librdf_new_node_from_uri_string(mTripleData->getRedlandWorld(), (const unsigned char*)newRepTypeIdCharData.constData());
280 }
281 librdf_statement* representativeTypeObjectStatement = librdf_new_statement_from_statement(representativeTypeStatement);
282 librdf_statement_set_object(representativeTypeObjectStatement, librdf_new_node_from_node(newRepTypeNode));
283 librdf_model_add_statement(mRepresentativeModel, representativeTypeObjectStatement);
284 mIndividualDataWritenToStore = true;
285 librdf_free_statement(representativeTypeObjectStatement);
286 }
287
288 //librdf_free_statement(representativeTypeStatement);
289 }
290 newTagRoleSet->removeIndividualCacheData(cacheData, true);
291 return this;
292 }
293
294
295
296
297 CRedlandStoredTriplesIndividualAssertionIndexCacheDataUpdateHandler* CRedlandStoredTriplesIndividualAssertionIndexCache::updateCacheData(CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData) {
298 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* storedRepIndiAssIndData = cacheData->getStoredRepresentativeIndividualAssertionsIndexData();
299 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* currentRepIndiAssIndData = cacheData->getCurrentRepresentativeIndividualAssertionsIndexData();
300 CRedlandStoredTriplesIndividualAssertionIndexCacheExtensionData* extensionData = cacheData->getExtensionData(false);
301 if (extensionData) {
302 if (storedRepIndiAssIndData == currentRepIndiAssIndData) {
303 currentRepIndiAssIndData = new CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData(storedRepIndiAssIndData);
304 cacheData->setCurrentRepresentativeIndividualAssertionsIndexData(currentRepIndiAssIndData);
305 }
306
307 QMap<cint64, CConcept*>* typeConceptExtensionMap = extensionData->getTypeConceptExtensionMap(false);
308 if (typeConceptExtensionMap) {
309 CRedlandStoredTriplesRepresentativeTagTypeConceptsSet* repConSet = mTagTypeConceptsSetHash.update(currentRepIndiAssIndData->getRepresentativeTypeConceptsSet(), typeConceptExtensionMap, cacheData);
310 currentRepIndiAssIndData->setRepresentativeTypeConceptsSet(repConSet);
311 }
312
313 QMap<cint64, CRole*>* outObjRoleExtensionMap = extensionData->getOutgoingObjectRoleExtensionMap(false);
314 if (outObjRoleExtensionMap) {
315 CRedlandStoredTriplesRepresentativeTagRolesSet* repRoleSet = mTagOutgoingObjectRolesSetHash.update(currentRepIndiAssIndData->getRepresentativeOutgoingObjectRolesSet(), outObjRoleExtensionMap, cacheData);
316 currentRepIndiAssIndData->setRepresentativeOutgoingObjectRolesSet(repRoleSet);
317 }
318
319 QMap<cint64, CRole*>* incObjRoleExtensionMap = extensionData->getIncomingObjectRoleExtensionMap(false);
320 if (incObjRoleExtensionMap) {
321 CRedlandStoredTriplesRepresentativeTagRolesSet* repRoleSet = mTagIncomingObjectRolesSetHash.update(currentRepIndiAssIndData->getRepresentativeIncomingObjectRolesSet(), incObjRoleExtensionMap, cacheData);
322 currentRepIndiAssIndData->setRepresentativeIncomingObjectRolesSet(repRoleSet);
323 }
324
325 QMap<cint64, CRole*>* outDataRoleExtensionMap = extensionData->getOutgoingDataRoleExtensionMap(false);
326 if (outDataRoleExtensionMap) {
327 CRedlandStoredTriplesRepresentativeTagRolesSet* repRoleSet = mTagOutgoingDataRolesSetHash.update(currentRepIndiAssIndData->getRepresentativeOutgoingDataRolesSet(), outDataRoleExtensionMap, cacheData);
328 currentRepIndiAssIndData->setRepresentativeOutgoingDataRolesSet(repRoleSet);
329 }
330
331 cacheData->clearExtensionData();
332 }
333 return this;
334 }
335
336
337
338
339 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::getIndividualAssertionIndexCacheData(cint64 individualId) {
340 CRedlandStoredTriplesIndividualAssertionIndexCacheData*& cacheData = (*mIndividualIdAssertionsIndexDataHash)[individualId];
341 if (!cacheData && mIndividualDataWritenToStore) {
342 librdf_node* individualNode = nullptr;
343
344 // retrieve individual node from model/store
345 QByteArray individualIdCharData = QString::number(individualId).toUtf8();
346 librdf_node* idNode = librdf_new_node_from_typed_counted_literal(mTripleData->getRedlandWorld(), (const unsigned char*)individualIdCharData.constData(), individualIdCharData.length(), nullptr, 0, nullptr);
347
348 librdf_statement* individualNodeRetrievalByIdStatement = librdf_new_statement_from_statement(mIndividualNodeRetrievalByIdStatement);
349 librdf_statement_set_object(individualNodeRetrievalByIdStatement, idNode);
350 librdf_stream* stream = librdf_model_find_statements(mRepresentativeModel, individualNodeRetrievalByIdStatement);
351
352 if (!librdf_stream_end(stream)) {
353 individualNode = librdf_statement_get_subject(librdf_stream_get_object(stream));
354 cacheData = createWithRetrievalIndividualAssertionIndexCacheData(individualNode, &individualId, true);
355 }
356 librdf_free_stream(stream);
357 //librdf_free_statement(individualNodeRetrievalByIdStatement);
358
359 }
360 if (cacheData && cacheData->getExtensionData(false)) {
361 updateCacheData(cacheData);
362 }
363 return cacheData;
364 }
365
366
367 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* CRedlandStoredTriplesIndividualAssertionIndexCache::getRepresentativeIndividualAssertionsIndexData(CRedlandStoredTriplesIndividualAssertionIndexCacheData* indiData) {
368 if (indiData->getExtensionData(false)) {
369 updateCacheData(indiData);
370 }
371 return indiData->getCurrentRepresentativeIndividualAssertionsIndexData();
372 }
373
374
375
376 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::associateIndividualWithId(librdf_node* indiNode, cint64 indiId) {
377 return createWithRetrievalIndividualAssertionIndexCacheData(indiNode, &indiId, false);
378 }
379
380 CRedlandStoredTriplesIndividualAssertionIndexCache* CRedlandStoredTriplesIndividualAssertionIndexCache::setNextIndividualId(cint64 indiId) {
381 mNextIndividualId = indiId;
382 return this;
383 }
384
385
386
387 cint64 CRedlandStoredTriplesIndividualAssertionIndexCache::getIndividualIdFromIndividualName(const QString& indiName) {
388 QByteArray indiNameByteArray = indiName.toUtf8();
389 librdf_uri* indiUri = librdf_new_uri(mTripleData->getRedlandWorld(), (const unsigned char*)indiNameByteArray.data());
390 librdf_node* indiNode = librdf_new_node_from_uri(mTripleData->getRedlandWorld(), indiUri);
391 cint64 indiId = getIndividualIdFromIndividualNode(indiNode);
392 librdf_free_node(indiNode);
393 return indiId;
394 }
395
396
397 cint64 CRedlandStoredTriplesIndividualAssertionIndexCache::getIndividualIdFromIndividualNode(librdf_node* node) {
398 CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData = getIndividualAssertionIndexCacheData(node, false);
399 if (cacheData) {
400 return cacheData->getIndividualId();
401 }
402 return -1;
403 }
404
405
406 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::getIndividualAssertionIndexCacheData(librdf_node* node, bool createIfNotExists) {
407 CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData = mIndividualAssertionsIndexCache->object(CRedlandNodeHasher(node));
408 if (!cacheData) {
409
410 if (mIndividualDataWritenToStore) {
411 librdf_node* indiNode = librdf_new_node_from_node(node);
412 librdf_statement* individualIdRetrievalByNodeStatement = librdf_new_statement_from_statement(mIndividualIdRetrievalByNodeStatement);
413 librdf_statement_set_subject(individualIdRetrievalByNodeStatement, indiNode);
414 librdf_stream* stream = librdf_model_find_statements(mRepresentativeModel, individualIdRetrievalByNodeStatement);
415
416 if (!librdf_stream_end(stream)) {
417 librdf_node* individualIdNode = librdf_statement_get_object(librdf_stream_get_object(stream));
418 cint64 individualId = QString::fromUtf8((const char*)librdf_node_get_literal_value(individualIdNode)).toLongLong();
419
420 cacheData = createWithRetrievalIndividualAssertionIndexCacheData(node, &individualId, true);
421 }
422 librdf_free_stream(stream);
423 //librdf_free_statement(individualIdRetrievalByNodeStatement);
424 }
425
426 if (!cacheData && createIfNotExists) {
427 cacheData = createWithRetrievalIndividualAssertionIndexCacheData(node, nullptr, false);
428 }
429
430 }
431 return cacheData;
432 }
433
434
435
436 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::createWithRetrievalIndividualAssertionIndexCacheData(librdf_node* node, cint64* individualIdPointer, bool idStored) {
437 CRedlandStoredTriplesIndividualAssertionIndexCacheData* cacheData = mIndividualAssertionsIndexCache->object(CRedlandNodeHasher(node));
438 if (!cacheData) {
439 cint64 individualId = 0;
440 if (individualIdPointer) {
441 individualId = *individualIdPointer;
442 } else {
443 individualId = mNextIndividualId++;
444 }
445
446 librdf_node* individualNode = librdf_new_node_from_node(node);
447 cacheData = new CRedlandStoredTriplesIndividualAssertionIndexCacheData(individualNode, individualId, this);
448 if (individualIdPointer && idStored) {
449 cacheData->setIndividualIdStored(true);
450 }
451
452 CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData* repIndiAssIndData = new CRedlandStoredTriplesRepresentativeIndividualAssertionsIndexData();
453 cacheData->setCurrentRepresentativeIndividualAssertionsIndexData(repIndiAssIndData);
454 cacheData->setStoredRepresentativeIndividualAssertionsIndexData(repIndiAssIndData);
455
456 CRedlandStoredTriplesRepresentativeTagTypeConceptsSet* repTypeSet = mTagTypeConceptsSetHash.getBaseTagSet();
457 CRedlandStoredTriplesRepresentativeTagRolesSet* outObjRoleSet = mTagOutgoingObjectRolesSetHash.getBaseTagSet();
458 CRedlandStoredTriplesRepresentativeTagRolesSet* incObjRoleSet = mTagIncomingObjectRolesSetHash.getBaseTagSet();
459 CRedlandStoredTriplesRepresentativeTagRolesSet* outDatRoleSet = mTagOutgoingDataRolesSetHash.getBaseTagSet();
460
461 if (mIndividualDataWritenToStore && idStored) {
462 // retrieve data from model/store
463 librdf_node* subjectNode = librdf_new_node_from_node(node);
464 librdf_statement* representativeTypeStatement = librdf_new_statement_from_statement(mRepresentativeTypeFilteringStatement);
465 librdf_statement_set_subject(representativeTypeStatement, subjectNode);
466 librdf_stream* stream = librdf_model_find_statements(mRepresentativeModel, representativeTypeStatement);
467
468 while (!librdf_stream_end(stream)) {
469 librdf_node* repIdNode = librdf_statement_get_object(librdf_stream_get_object(stream));
470 if (repIdNode == mRepresentativeNonAnonymousObjectNode || librdf_node_equals(mRepresentativeNonAnonymousObjectNode, repIdNode)) {
471 cacheData->setAnonymous(false);
472 cacheData->setIndividualNonAnonymityStored(true);
473 } else {
474 librdf_uri* repIdUri = librdf_node_get_uri(repIdNode);
475 const char* repChar = (const char*)librdf_uri_as_string(repIdUri);
476 size_t repTypeCharLength = strlen(repChar);
477 if (repTypeCharLength > 2) {
478 if (repChar[0] == 't') {
479 // types representative id object
480 cint64 repTypeId = QString::fromUtf8(repChar + 2).toLongLong();
481 repTypeSet = mTagTypeConceptsSetHash.getRepresentativeTagSet(repTypeId);
482 } else if (repChar[0] == 'o') {
483 cint64 repId = QString::fromUtf8(repChar + 2).toLongLong();
484 outObjRoleSet = mTagOutgoingObjectRolesSetHash.getRepresentativeTagSet(repId);
485 } else if (repChar[0] == 'i') {
486 cint64 repId = QString::fromUtf8(repChar + 2).toLongLong();
487 incObjRoleSet = mTagIncomingObjectRolesSetHash.getRepresentativeTagSet(repId);
488 } else if (repChar[0] == 'd') {
489 cint64 repId = QString::fromUtf8(repChar + 2).toLongLong();
490 outDatRoleSet = mTagOutgoingDataRolesSetHash.getRepresentativeTagSet(repId);
491 }
492 }
493 }
494 librdf_stream_next(stream);
495 }
496 librdf_free_stream(stream);
497 //librdf_free_statement(representativeTypeStatement);
498 }
499
500 repIndiAssIndData->setRepresentativeTypeConceptsSet(repTypeSet);
501 repIndiAssIndData->setRepresentativeOutgoingObjectRolesSet(outObjRoleSet);
502 repIndiAssIndData->setRepresentativeIncomingObjectRolesSet(incObjRoleSet);
503 repIndiAssIndData->setRepresentativeOutgoingDataRolesSet(outDatRoleSet);
504 repTypeSet->addIndividualCacheData(cacheData, idStored);
505 outObjRoleSet->addIndividualCacheData(cacheData, idStored);
506 incObjRoleSet->addIndividualCacheData(cacheData, idStored);
507 outDatRoleSet->addIndividualCacheData(cacheData, idStored);
508
509
510 (*mIndividualIdAssertionsIndexDataHash)[individualId] = cacheData;
511 mIndividualAssertionsIndexCache->insert(CRedlandNodeHasher(individualNode), cacheData, 1);
512 }
513 return cacheData;
514 }
515
516
517 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::extendIndividualAssertionIndexCacheDataByTypeConcept(CRedlandStoredTriplesIndividualAssertionIndexCacheData* indiData, CConcept* concept) {
518 if (!indiData->getCurrentRepresentativeIndividualAssertionsIndexData()->getRepresentativeTypeConceptsSet()->hasTagElement(concept->getConceptTag())) {
519 if (concept->getConceptTag() == 1) {
520 bool debug = true;
521 }
522 indiData->getExtensionData(true)->getTypeConceptExtensionMap(true)->insert(concept->getConceptTag(), concept);
523 }
524 return indiData;
525 }
526
527
528
529 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::extendIndividualAssertionIndexCacheDataByOutgoingObjectRole(CRedlandStoredTriplesIndividualAssertionIndexCacheData* indiData, CRole* role) {
530 if (!indiData->getCurrentRepresentativeIndividualAssertionsIndexData()->getRepresentativeOutgoingObjectRolesSet()->hasTagElement(role->getRoleTag())) {
531 indiData->getExtensionData(true)->getOutgoingObjectRoleExtensionMap(true)->insert(role->getRoleTag(), role);
532 }
533 return indiData;
534 }
535
536
537 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::extendIndividualAssertionIndexCacheDataByIncomingObjectRole(CRedlandStoredTriplesIndividualAssertionIndexCacheData* indiData, CRole* role) {
538 if (!indiData->getCurrentRepresentativeIndividualAssertionsIndexData()->getRepresentativeIncomingObjectRolesSet()->hasTagElement(role->getRoleTag())) {
539 indiData->getExtensionData(true)->getIncomingObjectRoleExtensionMap(true)->insert(role->getRoleTag(), role);
540 }
541 return indiData;
542 }
543
544
545 CRedlandStoredTriplesIndividualAssertionIndexCacheData* CRedlandStoredTriplesIndividualAssertionIndexCache::extendIndividualAssertionIndexCacheDataByOutgoingDataRole(CRedlandStoredTriplesIndividualAssertionIndexCacheData* indiData, CRole* role) {
546 if (!indiData->getCurrentRepresentativeIndividualAssertionsIndexData()->getRepresentativeOutgoingDataRolesSet()->hasTagElement(role->getRoleTag())) {
547 indiData->getExtensionData(true)->getOutgoingDataRoleExtensionMap(true)->insert(role->getRoleTag(), role);
548 }
549 return indiData;
550 }
551
552
553
554 QSet<CConcept*>* CRedlandStoredTriplesIndividualAssertionIndexCache::getAssertedConceptSet() {
555 return mTagTypeConceptsSetHash.getOccurringTagElementSet();
556 }
557
558 QSet<CRole*>* CRedlandStoredTriplesIndividualAssertionIndexCache::getAssertedObjectRoleSet() {
559 return mTagOutgoingObjectRolesSetHash.getOccurringTagElementSet();
560 }
561
562 QSet<CRole*>* CRedlandStoredTriplesIndividualAssertionIndexCache::getAssertedDataRoleSet() {
563 return mTagOutgoingDataRolesSetHash.getOccurringTagElementSet();
564 }
565
566 cint64 CRedlandStoredTriplesIndividualAssertionIndexCache::getNextIndividualId() {
567 return mNextIndividualId;
568 }
569
570 QString CRedlandStoredTriplesIndividualAssertionIndexCache::getRepresentativeCacheModelString() {
571 mIndividualAssertionsIndexCache->clear();
572 librdf_uri* uri = librdf_new_uri(mTripleData->getRedlandWorld(), (const unsigned char*)"http://konclude.com/reprasentative-cache/model");
573 unsigned char *string = librdf_model_to_string(mRepresentativeModel, uri, "turtle", NULL, NULL);
574 librdf_free_uri(uri);
575 return QString::fromUtf8((const char*)string);
576 }
577
578
579 }; // end namespace Triples
580
581 }; // end namespace Reasoner
582
583 }; // end namespace Konclude
584
585 #endif // !KONCLUDE_REDLAND_INTEGRATION