Debian Codegraph @

Source/Reasoner/Answerer/Conclusion/CAbstractStreamingComplexQueryFinishingHandler.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
21 #include "CAbstractStreamingComplexQueryFinishingHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Answerer {
29
30 namespace Conclusion {
31
32 CAbstractStreamingComplexQueryFinishingHandler::CAbstractStreamingComplexQueryFinishingHandler(CComplexQueryExpressionProcessingData* queryProcessingData, COptimizedComplexExpressionOntologyAnsweringItem* ontoAnsweringItem, bool confExtendedLogging, const QString& logDomain, cint64 confMaximumBatchMappingsComputationSize, cint64 confFirstBatchMappingsComputationSize, double confBatchMappingsComputationSizeIncreasingFactor, bool confContinueMappingsCompuationWhenResultsNotWriteable, cint64 confMappingsComputationUnlimitedInterpretationSize) {
33 mQueryProcessingData = queryProcessingData;
34 mOntoAnsweringItem = ontoAnsweringItem;
35 mConfExtendedLogging = confExtendedLogging;
36 mLogDomain = logDomain;
37 mConfMaximumBatchMappingsComputationSize = confMaximumBatchMappingsComputationSize;
38
39 mConfFirstBatchMappingsComputationSize = confFirstBatchMappingsComputationSize;
40 mNextMappingRequestingCountLimit = mConfFirstBatchMappingsComputationSize;
41 mConfBatchMappingsComputationSizeIncreasingFactor = confBatchMappingsComputationSizeIncreasingFactor;
42 mNextMappingRequestingCountLimitIncreasingFactor = mConfBatchMappingsComputationSizeIncreasingFactor;
43 mConfContinueMappingsCompuationWhenResultsNotWriteable = confContinueMappingsCompuationWhenResultsNotWriteable;
44 mConfMappingsComputationUnlimitedInterpretationSize = confMappingsComputationUnlimitedInterpretationSize;
45 }
46
47
48 CAbstractStreamingComplexQueryFinishingHandler::~CAbstractStreamingComplexQueryFinishingHandler() {
49 if (mResultGenerator) {
50 delete mResultGenerator;
51 }
52 }
53
54
55
56 bool CAbstractStreamingComplexQueryFinishingHandler::init() {
57 mVarBuildItem = mQueryProcessingData->getVariableBuildingItem();
58 mVarBuildIndividualItem = dynamic_cast<COptimizedComplexBuildingIndividualVariableCompositionsItem*>(mVarBuildItem);
59 mVarBuildClassItem = dynamic_cast<COptimizedComplexBuildingClassVariableCompositionsItem*>(mVarBuildItem);
60 mCompVarQuery = (CComplexVariablesAnsweringQuery*)mQueryProcessingData->getQuery();
61 mCompAssIndVarQuery = nullptr;
62 mCompAxClassVarQuery = nullptr;
63 if (mVarBuildIndividualItem) {
64 mCompAssIndVarQuery = (CComplexAssertionsIndividualVariablesAnsweringQuery*)mCompVarQuery;
65 }
66 if (mVarBuildClassItem) {
67 mCompAxClassVarQuery = (CComplexAxiomsClassVariablesAnsweringQuery*)mCompVarQuery;
68 }
69 mConceptItem = mQueryProcessingData->getConceptItem();
70 cint64 nextId = 0;
71 for (CExpressionVariable* varExp : *mCompVarQuery->getDistinguishedVariableExpressions()) {
72 mDisVarIdHash.insert(varExp, nextId++);
73 mVarList.append(varExp->getName());
74 }
75
76 CVariableBindingFilteringAnswerMapping* lastFilteringAnsweringMapping = nullptr;
77 mDistinct = false;
78 if (mCompAssIndVarQuery) {
79 for (CVariableBindingFiltering* filteringLinker = mCompAssIndVarQuery->getResultFilteringLinker(); filteringLinker; filteringLinker = filteringLinker->getNext()) {
80 CVariableBindingFilteringAnswerMapping* tmpFilteringAnsweringMapping = filteringLinker->createFitleringAnswerMapping(mDisVarIdHash);
81 if (!mFilteringAnsweringMapping) {
82 lastFilteringAnsweringMapping = mFilteringAnsweringMapping = tmpFilteringAnsweringMapping;
83 } else {
84 lastFilteringAnsweringMapping->append(tmpFilteringAnsweringMapping);
85 lastFilteringAnsweringMapping = tmpFilteringAnsweringMapping;
86 }
87 }
88 mDistinct = mCompAssIndVarQuery->isDistinctRequired();
89 }
90
91 cint64 variablesCount = 1;
92 if (mVarBuildIndividualItem) {
93 variablesCount = mVarBuildIndividualItem->getAllVariableSet()->count();
94 }
95
96
97 mBindsAnswersResult = nullptr;
98 mExistBindsAnswersStreamingResult = dynamic_cast<CVariableBindingsAnswersStreamingResult*>(mCompVarQuery->getQueryResult());
99 if (mExistBindsAnswersStreamingResult) {
100 mAnswersWriteable &= mExistBindsAnswersStreamingResult->initResult(mVarList);
101 mBindsAnswersResult = mExistBindsAnswersStreamingResult;
102 } else {
103 if (mCompAssIndVarQuery && mCompAssIndVarQuery->getResultOrderingLinker()) {
104 cint64 orderingVarCount = mCompAssIndVarQuery->getResultOrderingLinker()->getCount();
105 bool mappingDistinct = mDistinct && mVarList.count() != variablesCount;
106 CVariableBindingsAnswerResultMapOrdering* ordering = new CVariableBindingsAnswerResultMapOrdering(orderingVarCount);
107 ordering->setDistinct(mappingDistinct);
108 cint64 orderingVarNum = 0;
109 for (CVariableBindingOrdering* orderingIt = mCompAssIndVarQuery->getResultOrderingLinker(); orderingIt; orderingIt = orderingIt->getNext()) {
110 CExpressionVariable* orderingVarExp = orderingIt->getOrderingVariableExpression();
111 CVariableBindingOrdering::ORDERING_TYPE orderingType = orderingIt->getOrderingType();
112 cint64 orderingVarId = mDisVarIdHash.value(orderingVarExp);
113 ordering->setAscending(orderingVarNum, orderingType == CVariableBindingOrdering::ASC);
114 ordering->setVariableIndex(orderingVarNum, orderingVarId);
115 ++orderingVarNum;
116 }
117 mBindsAnswersResult = new CVariableBindingsAnswersOrderedMapResult(mVarList, ordering);
118 } else {
119 if (mDistinct) {
120 mBindsAnswersResult = new CVariableBindingsAnswersSetResult(mVarList);
121 } else {
122 mBindsAnswersResult = new CVariableBindingsAnswersListResult(mVarList);
123 }
124 }
125 }
126
127
128
129 if (!mQueryProcessingData->isUnsatisfiable()) {
130 if (mVarBuildItem && mVarBuildItem->isSatisfiable()) {
131 CExpressionVariable* lastVarExp = mVarBuildItem->getLastHandledVariableExpression();
132 if (!lastVarExp) {
133 if (mVarBuildIndividualItem) {
134 CVariableBindingsListAnswerResult* bindAnsRes = new CVariableBindingsListAnswerResult();
135 for (CExpressionVariable* varExp : *mCompVarQuery->getDistinguishedVariableExpressions()) {
136 QString varName = varExp->getName();
137 QString anonymousBindingName = varName.replace("?", "").replace("$", "") + "_1";
138 CVariableBindingStringResult* bindingResult = new CVariableBindingStringResult(anonymousBindingName, CVariableBindingResult::VBTANONYMOUSINDIVIDUAL);
139 bindAnsRes->addResultVariableBinding(bindingResult);
140 }
141 mResultWriter.addVariableBindingAnswerToResult(mBindsAnswersResult, bindAnsRes, mFilteringAnsweringMapping, mCompVarQuery);
142 }
143 } else {
144 mLastVarItem = mVarBuildItem->getVariableLastCompositionItem(lastVarExp);
145 COptimizedComplexVariableCompositionItemVariableIndexMapping* itemIndexMapping = mVarBuildItem->getVariableItemIndexMapping(lastVarExp).value(mLastVarItem);
146 QHash<CExpressionVariable*, cint64> varIdxHash;
147
148 QSet<CExpressionVariable*> distinguishedAnswerVariableSet(mCompVarQuery->getDistinguishedVariableExpressions()->toSet());
149 for (COptimizedComplexVariableCompositionItemVariableIndexMapping::const_iterator it = itemIndexMapping->constBegin(), itEnd = itemIndexMapping->constEnd(); it != itEnd; ++it) {
150 cint64 varIdx = it.key();
151 CExpressionVariable* varExp = it.value();
152 if (distinguishedAnswerVariableSet.contains(varExp)) {
153 varIdxHash.insert(varExp, varIdx);
154 } else {
155 mNonAnswerVariableMappingIndexList.append(varIdx);
156 }
157 }
158
159 for (CExpressionVariable* varExp : *mCompVarQuery->getDistinguishedVariableExpressions()) {
160 cint64 varIdx = varIdxHash.value(varExp, -1);
161 if (varIdx >= 0) {
162 mAnswerDistinguishedVariableMappingIndexList.append(varIdx);
163 }
164 }
165
166
167 mSameRealization = mOntoAnsweringItem->getOntology()->getRealization()->getSameRealization();
168
169 mAnswerVarCount = mAnswerDistinguishedVariableMappingIndexList.size();
170
171
172 mBindingResultVectorArray = new CVariableBindingResultVector*[mAnswerVarCount];
173 for (cint64 i = 0; i < mAnswerVarCount; ++i) {
174 mBindingResultVectorArray[i] = new CVariableBindingResultVector();
175 mBindingResultVectorArray[i]->mVectorPos = i;
176 }
177
178
179 mIndiNameResolver = mOntoAnsweringItem->getOntology()->getIndividualNameResolver();
180 mLastVarItemMapping = mLastVarItem->getVariableMapping();
181
182 mLastVarItemProcessingDep = new COptimizedComplexVariableCompositionItemDependence(mLastVarItem);
183
184 mBindResListAnswer = new CVariableBindingsListAnswerResult(mAnswerVarCount);
185
186 }
187 } else if (mConceptItem) {
188 mSameRealization = mOntoAnsweringItem->getOntology()->getRealization()->getSameRealization();
189 mConceptRealization = mOntoAnsweringItem->getOntology()->getRealization()->getConceptRealization();
190 mInstanceItemSet = mConceptItem->getKnownInstanceItems();
191
192 }
193 }
194
195
196 mInitialized = true;
197 return true;
198 }
199
200
201
202 COptimizedComplexVariableCompositionItem* CAbstractStreamingComplexQueryFinishingHandler::getResultUsingLastVariableCompositionItem() {
203 return mLastVarItem;
204 }
205
206
207 bool CAbstractStreamingComplexQueryFinishingHandler::finishQueryProcessing() {
208
209 if (mLastVarItemMapping) {
210 delete mBindResListAnswer;
211 delete[] mBindingResultVectorArray;
212 // TODO: delete all bindings in vector
213
214
215 if (mConfExtendedLogging) {
216 //LOG(INFO, mLogDomain, logTr("Last item cardinality over all variable mappings: %1").arg(mLastItemAllBindingsCardinality), this);
217 cint64 mappingCount = mLastVarItemMapping->getBindingCount();
218 if (mSplitComputedMappingCount > 0) {
219 mappingCount = mSplitComputedMappingCount;
220 }
221 LOG(INFO, mLogDomain, logTr("%2 mappings extended to %1 answers with average cardinality of %3 (maximum %4) and, in average, %5 (maximum %6) replicated answers due to same individuals.")
222 .arg(mBindsAnswersResult->getResultCount()).arg(mappingCount)
223 .arg(QString::number(mImplicitTotalCardinality / (double)mappingCount)).arg(mImplicitMaximalCardinality)
224 .arg(QString::number(mExplicitTotalCardinality / (double)mappingCount)).arg(mExplicitMaximalCardinality)
225 , this);
226 }
227 }
228
229 LOG(INFO, mLogDomain, logTr("Determined %1 answers for complex ABox query with %2 answer variables (%3).").arg(mBindsAnswersResult->getResultCount()).arg(mBindsAnswersResult->getVariableNames().count()).arg(mBindsAnswersResult->getVariableNames().join(", ")), this);
230
231
232 if (!mExistBindsAnswersStreamingResult) {
233 mCompVarQuery->setQueryResult(mBindsAnswersResult);
234 }
235 for (CVariableBindingFilteringAnswerMapping* filteringAnsweringMappingIt = mFilteringAnsweringMapping; filteringAnsweringMappingIt; ) {
236 CVariableBindingFilteringAnswerMapping* tmpFilteringAnsweringMapping = filteringAnsweringMappingIt;
237 filteringAnsweringMappingIt = filteringAnsweringMappingIt->getNext();
238 delete tmpFilteringAnsweringMapping;
239 }
240
241
242 return true;
243 }
244
245
246
247 bool CAbstractStreamingComplexQueryFinishingHandler::processQueryResults() {
248
249 if (!mQueryProcessingData->isUnsatisfiable()) {
250
251
252 function<cint64(cint64)> determineRemainingMappingsFunc = [&](cint64 processedMappings)->cint64 {
253 cint64 currentAnswerCount = mBindsAnswersResult->getResultCount() + mQueryProcessingData->getOffsetSkippedMappingCount();
254 cint64 requiredAnswerCount = mCompVarQuery->getResultLimitIncludingOffset();
255 cint64 remainingRequiredAnswerCount = requiredAnswerCount - currentAnswerCount;
256 cint64 processedMappingCount = processedMappings;
257 cint64 requiredMappingsCount = 0;
258 if (requiredAnswerCount == -1) {
259 requiredMappingsCount = -1;
260 } else {
261 double mappingAnswerFactor = (double)currentAnswerCount / (double)processedMappingCount;
262 requiredMappingsCount = (remainingRequiredAnswerCount / mappingAnswerFactor) + 1;
263 requiredMappingsCount += processedMappingCount;
264 }
265
266 if (requiredMappingsCount == -1) {
267 requiredMappingsCount = mNextMappingRequestingCountLimit;
268 if (mConfMappingsComputationUnlimitedInterpretationSize >= 0 && requiredMappingsCount > mConfMappingsComputationUnlimitedInterpretationSize) {
269 requiredMappingsCount = -1;
270 }
271 } else {
272 requiredMappingsCount = qMin((cint64)mNextMappingRequestingCountLimit, requiredMappingsCount);
273 }
274 cint64 prevMappingRequestingCountLimit = mNextMappingRequestingCountLimit;
275 mNextMappingRequestingCountLimit = prevMappingRequestingCountLimit * mNextMappingRequestingCountLimitIncreasingFactor;
276 if (mNextMappingRequestingCountLimit - prevMappingRequestingCountLimit > mConfMaximumBatchMappingsComputationSize) {
277 mNextMappingRequestingCountLimit = prevMappingRequestingCountLimit + mConfMaximumBatchMappingsComputationSize;
278 }
279 return requiredMappingsCount;
280 };
281
282 ++mComputationBatchNr;
283
284 if (mVarBuildItem && mVarBuildItem->isSatisfiable()) {
285 if (mLastVarItemProcessingDep) {
286
287
288 processUpdatedBindingsCardinalityLinkers();
289
290
291
292 bool dependentItemRescheduled = false;
293 if (mLastVarItem->hasSplitComputations()) {
294 bool moreComputationPossible = mLastVarItem->getRemainingSplitComputationCount() && (mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1);
295
296 bool resultsFurtherUsage = true;
297 if (mExistBindsAnswersStreamingResult && moreComputationPossible) {
298 resultsFurtherUsage = mExistBindsAnswersStreamingResult->flushResults();
299 if (!mAnswersWriteable) {
300 // count answers
301 resultsFurtherUsage = true;
302 }
303 }
304 if (moreComputationPossible) {
305 mLastVarItem->setNextSplitComputationPosition(mLastVarItem->getNextSplitComputationPosition() + 1);
306 dependentItemRescheduled = true;
307
308 LOG(INFO, mLogDomain, logTr("Computation partition %1 resulted in %2 additional answers, scheduling processing next of %3 remaining partitions.").arg(mLastVarItem->getCurrentSplitComputationPosition() + 1).arg(mBindsAnswersResult->getResultCount()).arg(mLastVarItem->getRemainingSplitComputationCount()), this);
309
310 if (!mLastVarItem->isComputationQueued()) {
311 mLastVarItem->setComputationQueued(true);
312 mVarBuildItem->addComputeVariableMappingItem(mLastVarItem);
313 }
314 }
315
316
317 } else {
318
319
320 bool moreComputationPossible = !mLastVarItem->isVariableMappingsComputed() && !mLastVarItemProcessingDep->isProcessingFinished() && (mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1);
321 bool resultsFurtherUsage = true;
322 if (mExistBindsAnswersStreamingResult && moreComputationPossible) {
323 resultsFurtherUsage = mExistBindsAnswersStreamingResult->flushResults();
324 if (!mAnswersWriteable) {
325 // count answers
326 resultsFurtherUsage = true;
327 }
328 }
329
330
331 if (moreComputationPossible) {
332
333 cint64 requiredMappingsCount = determineRemainingMappingsFunc(mLastVarItemProcessingDep->getTotalProcessedBindingsCardinalityLinkerCount());
334
335 //dependentItemRescheduled |= rescheduleVariableCompositionItemComputation(mVarBuildItem, nullptr, mLastVarItem, requiredMappingsCount);
336
337 bool continueComputation = true;
338 if (!resultsFurtherUsage && !mConfContinueMappingsCompuationWhenResultsNotWriteable) {
339 continueComputation = false;
340 LOG(WARN, mLogDomain, logTr("Processing batch %1 resulted in %2 answers from %3 mappings, but no further computation batch scheduled since answers seem no longer writeable/sendable and it has not been configured to continue.").arg(mComputationBatchNr).arg(mBindsAnswersResult->getResultCount()).arg(mLastVarItemMapping->getBindingCount()), this);
341 }
342
343
344 if (continueComputation) {
345 dependentItemRescheduled = true;
346 if (requiredMappingsCount != -1) {
347 mLastVarItem->setVariableMappingsComputationRequirement(qMax(mLastVarItem->getVariableMappingsComputationRequirement(), requiredMappingsCount));
348 } else {
349 mLastVarItem->setVariableMappingsComputationRequirement(requiredMappingsCount);
350 }
351
352 QString nextRequestingString = "all";
353 if (requiredMappingsCount != -1) {
354 nextRequestingString = QString("%1").arg(requiredMappingsCount);
355 }
356 LOG(INFO, mLogDomain, logTr("Processing batch %1 resulted in %2 answers from %3 mappings, scheduling next batch with %4 requested mappings.").arg(mComputationBatchNr).arg(mBindsAnswersResult->getResultCount()).arg(mLastVarItemMapping->getBindingCount()).arg(nextRequestingString), this);
357
358 if (!mLastVarItem->isComputationQueued()) {
359 mLastVarItem->setComputationQueued(true);
360 mVarBuildItem->addComputeVariableMappingItem(mLastVarItem);
361 }
362 }
363
364 }
365 }
366
367 return !dependentItemRescheduled;
368
369
370 }
371 } else if (mConceptItem) {
372
373 if (!mResultGenerator) {
374 mResultGenerator = new CInstanceBindingAddingVisitor(mBindsAnswersResult, mFilteringAnsweringMapping, mCompVarQuery, mOntoAnsweringItem->getOntology()->getIndividualNameResolver(), mQueryProcessingData, &mResultWriter);
375 }
376 if (mInstanceItemSet) {
377 while ((mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && mInstanceItemLastProcessingLinker != mInstanceItemLastProcessedLinker || mInstanceItemLastRetrievedLinker != mInstanceItemSet->getAddedRealizationIndividualInstanceItemReferenceLinker()) {
378 while ((mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && mInstanceItemLastProcessingLinker != mInstanceItemLastProcessedLinker) {
379 ++mInstanceItemLinkerProcessedCount;
380 mSameRealization->visitSameIndividuals(mInstanceItemLastProcessingLinker->getRealizationIndividualInstanceItemReference(), mResultGenerator);
381 mInstanceItemLastProcessingLinker = mInstanceItemLastProcessingLinker->getNext();
382 }
383 if (mInstanceItemLastRetrievedLinker != mInstanceItemSet->getAddedRealizationIndividualInstanceItemReferenceLinker()) {
384 mInstanceItemLastProcessedLinker = mInstanceItemLastRetrievedLinker;
385 mInstanceItemLastRetrievedLinker = mInstanceItemLastProcessingLinker = mInstanceItemSet->getAddedRealizationIndividualInstanceItemReferenceLinker();
386 }
387 }
388
389
390 bool moreInstanceComputationScheduled = false;
391 // TODO: fix computed all check and scheduling
392 // TODO: eliminate duplicated code for determining remaining mappings
393 // TODO: request only one instance for concept item in the beginning
394
395
396 CComplexConceptStepInstanceComputationProcess* instanceCompStep = mConceptItem->getComputationProcess()->getInstancesComputationProcess(true);
397 bool moreComputationPossible = !instanceCompStep->hasAllInstancesComputed() && (mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1);
398 bool resultsFurtherUsage = true;
399 if (mExistBindsAnswersStreamingResult && moreComputationPossible) {
400 resultsFurtherUsage = mExistBindsAnswersStreamingResult->flushResults();
401 if (!mAnswersWriteable) {
402 // count answers
403 resultsFurtherUsage = true;
404 }
405 }
406
407
408 if (!instanceCompStep->hasAllInstancesComputed() && (mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1)) {
409
410 cint64 requiredMappingsCount = determineRemainingMappingsFunc(mInstanceItemLinkerProcessedCount);
411
412 bool continueComputation = true;
413 if (!resultsFurtherUsage && !mConfContinueMappingsCompuationWhenResultsNotWriteable) {
414 continueComputation = false;
415 LOG(WARN, mLogDomain, logTr("Processing batch %1 resulted in %2 answers from %3 instances, but no further computation batch scheduled since answers seem no longer writeable/sendable and it has not been configured to continue.").arg(mComputationBatchNr).arg(mBindsAnswersResult->getResultCount()).arg(mInstanceItemLinkerProcessedCount), this);
416 }
417
418
419 if (continueComputation) {
420
421 moreInstanceComputationScheduled = true;
422 CComputedItemDataNotificationLinker* notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
423 notLinker->setQueryProcessingData(mQueryProcessingData);
424
425 if (requiredMappingsCount >= 0) {
426 instanceCompStep->addComputedInstancesCountRequirement(requiredMappingsCount, notLinker);
427 } else {
428 instanceCompStep->setAllInstanceComputationRequired(true);
429 instanceCompStep->addNotificationLinker(notLinker);
430 }
431
432 mQueryProcessingData->setComputationStepWaiting(instanceCompStep);
433
434 QString nextRequestingString = "all";
435 if (requiredMappingsCount != -1) {
436 nextRequestingString = QString("%1").arg(requiredMappingsCount);
437 }
438 LOG(INFO, mLogDomain, logTr("Processing batch %1 resulted in %2 answers from %3 instances, scheduling next batch with %4 requested instances.").arg(mComputationBatchNr).arg(mBindsAnswersResult->getResultCount()).arg(mInstanceItemLinkerProcessedCount).arg(nextRequestingString), this);
439
440 mConceptItem->setQueuedProcessStep(nullptr);
441 if (!mConceptItem->hasQueuedProcessStep() && !instanceCompStep->isComputationProcessQueued() && !instanceCompStep->isComputationProcessProcessing()) {
442 mConceptItem->setQueuedProcessStep(instanceCompStep);
443 instanceCompStep->setComputationProcessQueued(true);
444 COptimizedComplexConceptStepAnsweringItem* processingStep = mOntoAnsweringItem->getConceptProcessingStepItem(instanceCompStep->getComputationType());
445 processingStep->addQueuedConceptItem(mConceptItem);
446 }
447 }
448
449
450 }
451
452 return !moreInstanceComputationScheduled;
453
454
455 //for (COptimizedComplexConceptInstanziatedIndividualItemLinker* itemLinker = instanceItemSet->getAddedRealizationIndividualInstanceItemReferenceLinker(); itemLinker; itemLinker = itemLinker->getNext()) {
456 // mSameRealization->visitSameIndividuals(itemLinker->getRealizationIndividualInstanceItemReference(), &resultGenerator);
457 //}
458 }
459 //for (auto node : *conceptItem->getDirectSubClassNodeSet()) {
460 // conceptRealization->visitInstances(node->getOneEquivalentConcept(), false, &resultGenerator);
461 //}
462
463 }
464
465 }
466
467
468 return true;
469 }
470
471
472
473
474 void CAbstractStreamingComplexQueryFinishingHandler::processUpdatedBindingsCardinalityLinkers() {
475 while ((mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && (!mLastVarItemProcessingDep->isBatchProcessed() || mLastVarItemProcessingDep->loadNextBatch())) {
476
477 while ((mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() <= mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && mLastVarItemProcessingDep->getBatchCurrentBindingsCardinalityLinker(false)) {
478 COptimizedComplexVariableIndividualBindingsCardinalityLinker* bindingLinker = mLastVarItemProcessingDep->getBatchCurrentBindingsCardinalityLinker(true);
479 COptimizedComplexVariableIndividualBindings* bindings = bindingLinker->getBindings();
480 COptimizedComplexVariableIndividualBindingsCardinality* cardinalites = bindingLinker->getInitialCardinalities();
481
482 handleBindingCardinalityLinker(bindings, cardinalites);
483 }
484
485 while ((mQueryProcessingData->getOffsetSkippedMappingCount() + mBindsAnswersResult->getResultCount() < mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && mLastVarItemProcessingDep->getBatchCurrentUpdatedCardinalityLinker(false)) {
486 COptimizedComplexVariableIndividualUpdateCardinalityLinker* updatedCardinalityLinker = mLastVarItemProcessingDep->getBatchCurrentUpdatedCardinalityLinker(true);
487 if (!mDistinct) {
488 COptimizedComplexVariableIndividualBindingsCardinality* prevCardinalites = updatedCardinalityLinker->getPreviousCardinality();
489 COptimizedComplexVariableIndividualBindingsCardinalityLinker* bindingLinker = updatedCardinalityLinker->getUpdatedBindingsCardinalityLinker();
490 COptimizedComplexVariableIndividualBindingsCardinality* newCardinalites = updatedCardinalityLinker->getNewCardinality();
491 COptimizedComplexVariableIndividualBindings* bindings = bindingLinker->getBindings();
492
493 COptimizedComplexVariableIndividualBindingsCardinality tmpDiffCardinalites = *newCardinalites;
494 tmpDiffCardinalites.substractCardinalities(prevCardinalites);
495
496 handleBindingCardinalityLinker(bindings, &tmpDiffCardinalites);
497 }
498 }
499 }
500 }
501
502 void CAbstractStreamingComplexQueryFinishingHandler::handleBindingCardinalityLinker(COptimizedComplexVariableIndividualBindings* bindings, COptimizedComplexVariableIndividualBindingsCardinality* cardinalities) {
503 handleBindingCardinalityLinker(bindings, cardinalities, mBindsAnswersResult, mBindResListAnswer, mBindingResultVectorArray, mAnswerNr, mImplicitMaximalCardinality, mImplicitTotalCardinality, mExplicitMaximalCardinality, mExplicitTotalCardinality);
504 }
505
506
507
508
509
510 void CAbstractStreamingComplexQueryFinishingHandler::handleBindingCardinalityLinker(COptimizedComplexVariableIndividualBindings* bindings, COptimizedComplexVariableIndividualBindingsCardinality* cardinalities,
511 CVariableBindingsAnswersResult*& useBindsAnswersResult, CVariableBindingsListAnswerResult*& useBindResListAnswer, CAbstractStreamingComplexQueryFinishingHandler::CVariableBindingResultVector**& useBindingResultVectorArray,
512 cint64& useAnswerNr, cint64& useImplicitMaximalCardinality, cint64& useImplicitTotalCardinality, cint64& useExplicitMaximalCardinality, cint64& useExplicitTotalCardinality) {
513
514 useAnswerNr++;
515
516 for (cint64 i = 0; i < mAnswerVarCount; ++i) {
517 useBindingResultVectorArray[i]->mValidBindingCount = 0;
518 useBindingResultVectorArray[i]->mCurrentBindingIdx = 0;
519 useBindingResultVectorArray[i]->mNextIteratingVector = nullptr;
520 }
521
522 cint64 cardinality = 1;
523 if (!mDistinct) {
524 if (cardinalities) {
525 cardinality *= cardinalities->getSameIndividualsSeparatlyConsideredCardinality();
526 }
527 // determine additional cardinality of binding result due to same individuals bound to non-distinguished variables
528 if (!mNonAnswerVariableMappingIndexList.isEmpty()) {
529 for (cint64 varIdx : mNonAnswerVariableMappingIndexList) {
530 COptimizedComplexVariableIndividualMappings::VARIABLE_TYPE bindingType = mLastVarItemMapping->getBindingMapping(varIdx);
531 if (bindingType == COptimizedComplexVariableIndividualMappings::INDIVIDUAL_VARIABLE) {
532 CInstanceBindingIndividualCountingVisitor visitor;
533 mSameRealization->visitSameIndividuals(bindings->getBinding(varIdx).reference, &visitor);
534 if (visitor.individualCount > 1) {
535 cardinality *= visitor.individualCount;
536 }
537 } else if (bindingType == COptimizedComplexVariableIndividualMappings::CLASS_VARIABLE) {
538 cint64 eqConCount = bindings->getBinding(varIdx).classHierNode->getEquivalentConceptCount();
539 if (eqConCount > 1) {
540 cardinality *= eqConCount;
541 }
542 } else if (bindingType == COptimizedComplexVariableIndividualMappings::PROPERTY_VARIABLE) {
543 cint64 eqConCount = bindings->getBinding(varIdx).propertyHierNode->getEquivalentElementCount();
544 if (eqConCount > 1) {
545 cardinality *= eqConCount;
546 }
547 }
548 }
549 }
550 }
551
552 if (!cardinalities) {
553 mLastItemAllBindingsCardinality += 1;
554 } else {
555 mLastItemAllBindingsCardinality += cardinalities->getSameIndividualsSeparatlyConsideredCardinality();
556 }
557
558 useImplicitMaximalCardinality = qMax(useImplicitMaximalCardinality, cardinality);
559 useImplicitTotalCardinality += cardinality;
560
561 cint64 vectorIdx = 0;
562 for (cint64 varIdx : mAnswerDistinguishedVariableMappingIndexList) {
563 COptimizedComplexVariableIndividualMappings::VARIABLE_TYPE bindingType = mLastVarItemMapping->getBindingMapping(varIdx);
564 if (bindingType == COptimizedComplexVariableIndividualMappings::INDIVIDUAL_VARIABLE) {
565
566 CInstanceBindingIndividualLambdaCallingVisitor visitor([&](const CIndividualReference& indiRef) -> bool {
567 QString indiName = mIndiNameResolver->getIndividualName(indiRef);
568 if (!indiName.isEmpty()) {
569 CVariableBindingResultVector* bindingResultVector = useBindingResultVectorArray[vectorIdx];
570 if (bindingResultVector->size() <= bindingResultVector->mValidBindingCount) {
571 bindingResultVector->resize(bindingResultVector->mValidBindingCount + 5);
572 }
573 CVariableBindingResult*& binding = (*bindingResultVector)[bindingResultVector->mValidBindingCount++];
574 if (!binding) {
575 binding = mResultWriter.createVariableBindingResult(indiRef, mCompVarQuery, indiName);
576 } else {
577 binding->initVariableBinding(indiRef, indiName);
578 }
579 }
580 return true;
581 });
582 mSameRealization->visitSameIndividuals(bindings->getBinding(varIdx).reference, &visitor);
583 vectorIdx++;
584
585 } else if (bindingType == COptimizedComplexVariableIndividualMappings::DATA_LITERAL_VARIABLE) {
586
587 TIndividualInstanceItemDataBinding& varBinding = bindings->getBinding(varIdx);
588 CDataLiteral* dataLiteral = (CDataLiteral*)varBinding.pointer;
589
590 CVariableBindingResultVector* bindingResultVector = useBindingResultVectorArray[vectorIdx];
591 if (bindingResultVector->size() <= bindingResultVector->mValidBindingCount) {
592 bindingResultVector->resize(bindingResultVector->mValidBindingCount + 5);
593 }
594 CVariableBindingResult*& binding = (*bindingResultVector)[bindingResultVector->mValidBindingCount++];
595 if (!binding) {
596 binding = mResultWriter.createVariableBindingResult(dataLiteral, mCompVarQuery);
597 } else {
598 binding->initVariableBinding(dataLiteral);
599 }
600 vectorIdx++;
601
602 } else if (bindingType == COptimizedComplexVariableIndividualMappings::CLASS_VARIABLE) {
603 TIndividualInstanceItemDataBinding& varBinding = bindings->getBinding(varIdx);
604 CHierarchyNode* hierNode = varBinding.classHierNode;
605 QList<CConcept*>* eqConList = hierNode->getEquivalentConceptList();
606
607 CVariableBindingResultVector* bindingResultVector = useBindingResultVectorArray[vectorIdx];
608 for (CConcept* eqCon : *eqConList) {
609
610 if (bindingResultVector->size() <= bindingResultVector->mValidBindingCount) {
611 bindingResultVector->resize(qMax(bindingResultVector->mValidBindingCount, (cint64)eqConList->size()) + 5);
612 }
613 CVariableBindingResult*& binding = (*bindingResultVector)[bindingResultVector->mValidBindingCount++];
614 if (!binding) {
615 binding = mResultWriter.createVariableBindingResult(eqCon, mCompVarQuery);
616 } else {
617 binding->initVariableBinding(eqCon);
618 }
619
620
621 }
622 vectorIdx++;
623
624 } else if (bindingType == COptimizedComplexVariableIndividualMappings::PROPERTY_VARIABLE) {
625 TIndividualInstanceItemDataBinding& varBinding = bindings->getBinding(varIdx);
626 CRolePropertiesHierarchyNode* hierNode = varBinding.propertyHierNode;
627 QList<CRole*>* eqRoleList = hierNode->getEquivalentElementList();
628
629 CVariableBindingResultVector* bindingResultVector = useBindingResultVectorArray[vectorIdx];
630 for (CRole* eqRole : *eqRoleList) {
631
632 if (bindingResultVector->size() <= bindingResultVector->mValidBindingCount) {
633 bindingResultVector->resize(qMax(bindingResultVector->mValidBindingCount, (cint64)eqRoleList->size()) + 5);
634 }
635 CVariableBindingResult*& binding = (*bindingResultVector)[bindingResultVector->mValidBindingCount++];
636 if (!binding) {
637 binding = mResultWriter.createVariableBindingResult(eqRole, mCompVarQuery);
638 } else {
639 binding->initVariableBinding(eqRole);
640 }
641
642
643 }
644 vectorIdx++;
645
646 }
647 }
648
649
650 CVariableBindingResultVector* firstIteratingBindingVec = nullptr;
651 CVariableBindingResultVector* lastIteratingBindingVec = nullptr;
652 for (cint64 i = 0; i < mAnswerVarCount; ++i) {
653 CVariableBindingResultVector* bindingVec = useBindingResultVectorArray[i];
654 if (bindingVec->mValidBindingCount > 1) {
655 if (lastIteratingBindingVec) {
656 lastIteratingBindingVec->mNextIteratingVector = bindingVec;
657 }
658 if (firstIteratingBindingVec == nullptr) {
659 firstIteratingBindingVec = bindingVec;
660 }
661 lastIteratingBindingVec = bindingVec;
662 }
663 useBindResListAnswer->setResult(i, (*bindingVec)[bindingVec->mCurrentBindingIdx]);
664 }
665
666 mResultWriter.addReusedVariableBindingAnswerToResultConsideringOffsetLimit(useBindsAnswersResult, useBindResListAnswer, mFilteringAnsweringMapping, mCompVarQuery, mQueryProcessingData, cardinality);
667
668 cint64 explicitCardinality = 1;
669
670 bool isValidBindingCombination = true;
671 while ((useBindsAnswersResult->getResultCount() <= mCompVarQuery->getResultLimitIncludingOffset() || mCompVarQuery->getResultLimitIncludingOffset() == -1) && isValidBindingCombination && firstIteratingBindingVec) {
672
673 firstIteratingBindingVec->mCurrentBindingIdx++;
674
675 if (firstIteratingBindingVec->mCurrentBindingIdx >= firstIteratingBindingVec->mValidBindingCount) {
676 firstIteratingBindingVec->mCurrentBindingIdx = 0;
677 CVariableBindingResultVector* overflowIteratingBindingVec = firstIteratingBindingVec->mNextIteratingVector;
678 if (!overflowIteratingBindingVec) {
679 isValidBindingCombination = false;
680 }
681 while (overflowIteratingBindingVec) {
682 overflowIteratingBindingVec->mCurrentBindingIdx++;
683 CVariableBindingResultVector* nextOverflowIteratingBindingVec = nullptr;
684 if (overflowIteratingBindingVec->mCurrentBindingIdx >= overflowIteratingBindingVec->mValidBindingCount) {
685 overflowIteratingBindingVec->mCurrentBindingIdx = 0;
686 nextOverflowIteratingBindingVec = overflowIteratingBindingVec->mNextIteratingVector;
687 if (!nextOverflowIteratingBindingVec) {
688 isValidBindingCombination = false;
689 }
690 }
691 if (isValidBindingCombination) {
692 useBindResListAnswer->setResult(overflowIteratingBindingVec->mVectorPos, (*overflowIteratingBindingVec)[overflowIteratingBindingVec->mCurrentBindingIdx]);
693 }
694 overflowIteratingBindingVec = nextOverflowIteratingBindingVec;
695 }
696 }
697 if (isValidBindingCombination) {
698 useBindResListAnswer->setResult(firstIteratingBindingVec->mVectorPos, (*firstIteratingBindingVec)[firstIteratingBindingVec->mCurrentBindingIdx]);
699
700 mResultWriter.addReusedVariableBindingAnswerToResultConsideringOffsetLimit(useBindsAnswersResult, useBindResListAnswer, mFilteringAnsweringMapping, mCompVarQuery, mQueryProcessingData, cardinality);
701 explicitCardinality++;
702 }
703
704 }
705
706 useExplicitMaximalCardinality = qMax(useExplicitMaximalCardinality, explicitCardinality);
707 useExplicitTotalCardinality += explicitCardinality;
708
709 };
710
711
712
713
714
715
716 }; // end namespace Conclusion
717
718 }; // end namespace Answerer
719
720 }; // end namespace Reasoner
721
722 }; // end namespace Konclude