/*
* 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 .
*
*/
#include "COptimizedComplexExpressionAnsweringHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Answerer {
COptimizedComplexExpressionAnsweringHandler::COptimizedComplexExpressionAnsweringHandler(COptimizedComplexExpressionOntologyAnsweringItem* ontoAnsweringItem) : CAnsweringHandler(), CLogDomain("::Konclude::Reasoner::Kernel::ComplexExpressionQueryAnswerer") {
mOntoAnsweringItem = ontoAnsweringItem;
mConfDebugTestingOntologyWriting = false;
mConfInterpretNonAnswerIndividualVariablesAsAnonymousVariables = false;
mConfDirectPossibleRealizationRequesting = false;
mConfFailOnUnknownEntity = false;
mConfAnonymousToDistinguishedVariablesConversion = true;
mConfAnonymousToDistinguishedVariablesOnlyFullConversion = true;
mConfUnsatisfiableNonInstanceStatisticsChecking = false;
mConfOccurrenceStatisticsCollection = false;
mConfRedundantlyRestrictedVariablesElimination = true;
mConfAllowBindingReduction = true;
mConfAllowJoiningBindingReduction = true;
mConfMappingSizeBindingReduction = 5000;
mConfDebugWriteVariableCompositionItems = false;
mConfSamplingBasedJoinMappingSize = 1000;
mConfBindingReducingForNonDistinctAnswerQueries = true;
mConfDetailedMissingEntityReporting = true;
mConfDistinctUnecessaryVariablesReduction = true;
mConfAlwaysUnecessaryVariablesReduction = false;
mConfConceptItemExpectedCountSamplingSize = 30;
mConfConceptItemExpectedCountSamplingRetrievedPercentageLimit = 75.;
cint64 computationThreadCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentComputationThreadPoolSize", 0);
if (computationThreadCount != 0) {
QThreadPool::globalInstance()->setMaxThreadCount(computationThreadCount);
}
mConfInterpretQueriesAsDistinct = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.InterpretQueriesAsDistinct", false);
mConfInterpretNonAnswerIndividualVariablesAsAnonymousVariables = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.InterpretNonAnswerIndividualVariablesAsAnonymousVariables", false);
mConfNonAnswerIndividualVariablesAsAnonymousVariablesInterpretingPrefixString = CConfigDataReader::readConfigString(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NonAnswerIndividualVariablesAsAnonymousVariablesInterpretingPrefixString", "");
mConfDebugWriteVariableCompositionItems = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Debugging.WriteAnsweringVariableCompositionItems", false);
mConfSamplingBasedJoinMappingSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.SamplingBasedJoinMappingSize", 1000);
mConfFailOnUnknownEntity = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.FailOnUnknownEntity", false);
mConfExtendedLogging = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ExtendedLogging", false);
mConfVariablePreAbsorption = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.QueryAbsorption.Preabsorption", true);
mConfRedundantTermReduction = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.RedundantTermElimination", true);
mConfAllowBindingReduction = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AllowBindingReduction", true);
mConfAllowJoiningBindingReduction = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ImplicitJoiningBindingReduction", true);
mConfBindingReducingForNonDistinctAnswerQueries = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.BindingReducingForNonDistinctAnswerQueries", true);
mConfMappingSizeBindingReduction = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.BindingReductionMappingSize", 5000);
mConfPropagationJoining = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.PropagationJoining", true);
mConfPropagationReplacement = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.PropagationReplacement", false);
mConfAnonymousToDistinguishedVariablesConversion = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AnonymousToDistinguishedVariableConversion", true);
mConfAnonymousToDistinguishedVariablesOnlyFullConversion = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AnonymousToDistinguishedVariableOnlyFullConversion", true);
mConfOccurrenceStatisticsCollection = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Calculation.Optimization.OccurrenceStatisticsCollecting", true);
if (mConfOccurrenceStatisticsCollection) {
mConfUnsatisfiableNonInstanceStatisticsChecking = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.UnsatisfiableNonInstanceStatisticsChecking", true);
}
mConfRedundantlyRestrictedVariablesElimination = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.RedundantlyRestrictedVariablesElimination", true);
mConfMaximumBatchMappingsComputationSize = 100000000;
mConfBatchMappingsComputationSizeIncreasingFactor = 10.;
mConfFirstBatchMappingsComputationSize = 10;
mConfMinimalMappingsComputationSize = 1;
mConfMappingsRepeatedlyInsufficientDependencyComputationIncreasingFactor = 1.3;
mConfMappingsComputationUnlimitedInterpretationSize = Q_UINT64_C(100000000000000);
mConfMaximumBatchMappingsComputationSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MaximumBatchMappingsComputationSize", 100000000);
mConfBatchMappingsComputationSizeIncreasingFactor = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.BatchMappingsComputationSizeIncreasingFactorPercent", 1000) / 100.;
mConfFirstBatchMappingsComputationSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.FirstBatchMappingsComputationSize", 10);
mConfMinimalMappingsComputationSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MinimalMappingsComputationSize", 1);
mConfMappingsRepeatedlyInsufficientDependencyComputationIncreasingFactor = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MappingsRepeatedlyInsufficientDependencyComputationIncreasingFactorPercent", 130) / 100.;
mConfMappingsComputationUnlimitedInterpretationSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MappingsComputationUnlimitedInterpretationSize", Q_UINT64_C(100000000000000));
mConfContinueMappingsCompuationWhenResultsNotWriteable = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ContinueMappingsCompuationWhenResultsNotWriteable", false);
mConfLazyExistentialPartAbsorption = true;
mConfBooleanQueryExistentialPartOrdinaryEvaluation = true;
mConfLazyExistentialPartAbsorption = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.LazyExistentialQueryPartAbsorption", true);
mConfBooleanQueryExistentialPartOrdinaryEvaluation = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.BooleanQueryExistentialPartOrdinaryEvaluation", true);
mConfConceptItemInstanceCandiateRetrievingSizeIncreaseFactor = 1.3;
mConfConceptItemInstanceCandiateRetrievingMaxSize = 10000;
mConfFullQueryMaterialization = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.FullQueryMaterialization", true);
mConfConceptItemExpectedCountSamplingSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConceptItemExpectedCountSamplingSize", 30);
mConfConceptItemExpectedCountSamplingRetrievedPercentageLimit = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConceptItemExpectedCountSamplingRetrievedPercentageLimit", 75) / 100.;
mConfDistinctUnecessaryVariablesReduction = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.DistinctUnecessaryVariablesReductionBeforeAnswerGeneration", true);
mConfAlwaysUnecessaryVariablesReduction = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AlwaysUnecessaryVariablesReductionBeforeAnswerGeneration", false);
mConfMaxVariableBindingPropagationsInitializationIndividualCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MaxVariableMappingsPropagationsInitializationIndividualCount", 50000);
mConfMaxCandidateInstancePropagationsInitializationIndividualCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MaxCandidateInstancePropagationsInitializationIndividualCount", 10000);
mConfSplitVariableMappingPropagationTestMaxIntegrationLimit = 10000;
mConfSplitVariableMappingPropagationTestIntegrationLimitIncreaseFactor = 2.;
mConfSplitVariableMappingPropagationTestInitialVariableIntegrationLimit = 2000;
mConfSplitVariableMappingPropagationTestInitialTotalIntegrationLimit = 3000;
//mConfSplitVariableMappingPropagationTestInitialVariableIntegrationLimit = 1500000;
//mConfSplitVariableMappingPropagationTestInitialTotalIntegrationLimit = 20000000;
mConfAbsorbedIndividualActivationInstanceCandidatePropagationSplitting = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Calculation.Answering.AbsorbedIndividualActivationCandidateInstancePropagationSplitting", true);
mConfQueryEntailmentTestRestrictedTopPropertyPropagationSplitting = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.QueryEntailmentTestRestrictedTopPropertyPropagationSplitting", true);
mConfAllowLastStepSplitComputation = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AllowLastStepSplitComputation", true);
mConfLastStepSplitComputationMappingsRequirement = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.LastStepSplitComputationMappingsRequirement", 5000000);
mConfSkipConceptItemsIntegrationForPropagationOverVariables = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.SkipConceptItemsIntegrationForPropagationOverVariables", true);
mAnsweringStartTime.start();
mTestingOntologyPreprocessor = new COntologyQueryExtendedConfigDependedPreProcesser();
mTestingOntologyBuilder = new CConcreteOntologyRebuildingPreparationBuilder(ontoAnsweringItem->getTestingOntology(true));
mDefaultRealizationSorting = CRealizationIndividualSorting(CRealizationIndividualSorting::SORT_TYPE_INDIVIDUAL_ID, CRealizationIndividualSorting::SORT_ORDER_ASCENDING, CRealizationIndividualSorting::SORT_GROUP_SAME_UNIQUE);
mRoleFillerRealizationSorting = CRealizationIndividualSorting(CRealizationIndividualSorting::SORT_TYPE_NOTHING, CRealizationIndividualSorting::SORT_ORDER_NOTHING, CRealizationIndividualSorting::SORT_GROUP_SAME_UNIQUE);
mConfNonDeterministicSatisfiableCalculationContinuation = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Calculation.Answering.NonDeterministicCachedCompletionGraphContinuationPropagationTests", true);
mConfConcurrentJoining = true;
mConfAutomaticConcurrentComputationActivation = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AutomaticConcurrentComputationActivation", true);
if (mConfAutomaticConcurrentComputationActivation) {
mConfAutomaticConcurrentComputationActivation = false;
mConfAutomaticConcurrentComputationActivation = getWorkerCountConcurrentActivation(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Calculation.WorkerCount") || getWorkerCountConcurrentActivation(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Calculation.ProcessorCount");
}
mConcurrentJoinComputationTaskCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentJoinComputationTaskCount", 50);
mConfConcurrentJoining = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentJoinComputation", true) || mConfAutomaticConcurrentComputationActivation;
if (mConfConcurrentJoining) {
mJoinComputer = new CQtConcurrentVariableMappingsCompositionJoinComputator();
} else {
mJoinComputer = new CSequentialVariableMappingsCompositionJoinComputator();
}
mConfConcurrentPropagation = false;
mConcurrentPropagationComputationTaskCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentPropagationComputationTaskCount", 50);
mConfConcurrentPropagation = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentPropagationComputation", true) || mConfAutomaticConcurrentComputationActivation;
if (mConfConcurrentPropagation) {
mPropagationComputer = new CQtConcurrentVariableMappingsCompositionPropagationComputator();
} else {
mPropagationComputer = new CSequentialVariableMappingsCompositionPropagationComputator();
}
mConfConcurrentAnswerGeneration = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.ConcurrentAnswerGeneration", true) || mConfAutomaticConcurrentComputationActivation;
mConfNextVariablePropagationHandlingReducibleFactorIntegration = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.ReducibleFactorIntegration", true);
mConfNextVariablePropagationHandlingPropertyScoresIntegration = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertyScoresIntegration", true);
mConfNextVariablePropagationHandlingPropertyPriorization = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertyPriorization", true);
mConfVariableCompositionItemRoleSampling = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertyScore.VariableCompositionItemRoleSuccessorCountSampling", true);
mConfForceAlwaysVariableCompositionItemRoleSampling = CConfigDataReader::readConfigBoolean(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertyScore.ForceAlwaysVariableCompositionItemRoleSuccessorCountSampling", false);
mConfNextVariablePropagationHandlingReducibleFactor = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.ReducibleFactorPercent", 80) / 100.;
mConfNextVariablePropagationHandlingPropertyTotalScoreIntegrationPercent = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertyTotalScoreIntegrationPercent", 5);
mConfNextVariablePropagationHandlingPropertyInOutFactorIntegrationPercent = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.PropertySuccessorStatisticsSamplingFactorIntegrationPercent", 50);
mConfVariableCompositionItemRoleSamplingCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.VariableCompositionItemRoleSuccessorSamplingCount", 20);
mConfVariableCompositionItemRoleSamplingMappingsIncreaseSize = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.NextVariablePropagationHandlingChoise.VariableCompositionItemRoleSuccessorSamplingExpectedMappingIncreaseSize", 10000);
mConfAnswersCacheMaximumSizeBytes = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AnswersCacheMaximumSizeBytes", -1);
mConfAnswersCacheMaximumCount = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AnswersCacheMaximumCount", -1);
mConfAnswersCacheUsageWeightIncrease = CConfigDataReader::readConfigDouble(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.AnswersCacheUsageWeightIncreaseFactor", 1.03);
readConfig();
}
bool COptimizedComplexExpressionAnsweringHandler::getWorkerCountConcurrentActivation(CCalculationConfigurationExtension* calcConfig, const QString& configName) {
bool configErrorFlag = false;
QString workerCountString = CConfigDataReader::readConfigString(calcConfig, configName, QString(), &configErrorFlag);
if (!configErrorFlag) {
if (workerCountString == "AUTO" && CThread::idealThreadCount() > 1) {
return true;
} else {
qint64 convertedWorkerCount = workerCountString.toInt(&configErrorFlag);
if (configErrorFlag && convertedWorkerCount > 1) {
return true;
}
}
}
return false;
}
COptimizedComplexExpressionAnsweringHandler::~COptimizedComplexExpressionAnsweringHandler() {
delete mOntoAnsweringItem;
delete mTestingOntologyPreprocessor;
delete mTestingOntologyBuilder;
}
bool COptimizedComplexExpressionAnsweringHandler::canAnsweringComplexQuery(bool composedQuery) {
return !composedQuery;
}
bool COptimizedComplexExpressionAnsweringHandler::canAnsweringComplexQuery(CComplexAnsweringQuery* complexAnsweringQuery) {
if (dynamic_cast(complexAnsweringQuery)) {
return true;
}
return false;
}
bool COptimizedComplexExpressionAnsweringHandler::addAnsweringComplexQuery(CComplexAnsweringQuery* complexAnsweringQuery, CCallbackData* callback) {
mPendingQueryProcessingList.append(new CComplexQueryExpressionProcessingData((CComplexAnsweringExpressionQuery*)complexAnsweringQuery, callback));
return true;
}
bool COptimizedComplexExpressionAnsweringHandler::initializeProcessing(CAnswererContext* answererContext) {
if (!mOntoAnsweringItem->isOntologyBuildingAndPreprocessingPrepared()) {
prepareProcessing(answererContext);
}
while (!mPendingQueryProcessingList.isEmpty()) {
CComplexQueryExpressionProcessingData* queryData = mPendingQueryProcessingList.takeFirst();
CAnsweringHandlingStatistics* stats = mOntoAnsweringItem->getAnsweringHandlingStatistics();
if (stats) {
CAnsweringHandlingStatistics* initStats = new CAnsweringHandlingStatistics();
*initStats = *stats;
queryData->setQueryProcessingInitializedAnsweringStatistics(initStats);
}
initializeQueryProcessing(queryData,answererContext);
}
return true;
}
bool COptimizedComplexExpressionAnsweringHandler::prepareProcessing(CAnswererContext* answererContext) {
if (!mOntoAnsweringItem->isOntologyBuildingAndPreprocessingPrepared()) {
LOG(INFO, getDomain(), logTr("Preparing query answering handler."), this);
mTestingOntologyBuilder->prepareRebuildingUpdates();
CConcreteOntology* testingOnto = mOntoAnsweringItem->getTestingOntology(true);
mTestingOntologyPreprocessor->preprocess(testingOnto, testingOnto->getConfiguration());
LOG(INFO, getDomain(), logTr("Query answering hanlder prepared."), this);
mOntoAnsweringItem->setOntologyBuildingAndPreprocessingPrepared(true);
}
return true;
}
bool nodeSortLessPredecessorsThan(const CHierarchyNode* item1, const CHierarchyNode* item2) {
return item1->getPredecessorNodeCount() < item2->getPredecessorNodeCount();
}
bool nodeSortMorePredecessorsThan(const CHierarchyNode* item1, const CHierarchyNode* item2) {
return item1->getPredecessorNodeCount() > item2->getPredecessorNodeCount();
}
bool COptimizedComplexExpressionAnsweringHandler::initializeComplexConceptQueryProcessing(CComplexQueryExpressionProcessingData* queryProcessingData, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CClassTermExpression* classTermExpOfInt, bool satisfiableComputationRequired, bool superClassNodesComputationRequired, bool subClassNodesComputationRequired, bool equivalentClassNodesComputationRequired, bool subClassRealizationRequired, cint64 instanceComputationRequiredCount, COptimizedComplexConceptItem** assocConceptItem) {
CConcept* testingConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classTermExpOfInt);
bool testingNegation = testingConcept->hasMappingNegation();
return initializeComplexConceptQueryProcessing(queryProcessingData, buildingVarItem, testingConcept, testingNegation, satisfiableComputationRequired, superClassNodesComputationRequired, subClassNodesComputationRequired, equivalentClassNodesComputationRequired, subClassRealizationRequired, instanceComputationRequiredCount, assocConceptItem);
}
bool COptimizedComplexExpressionAnsweringHandler::initializeComplexConceptQueryProcessing(CComplexQueryExpressionProcessingData* queryProcessingData, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CConcept* testingConcept, bool testingNegation, bool satisfiableComputationRequired, bool superClassNodesComputationRequired, bool subClassNodesComputationRequired, bool equivalentClassNodesComputationRequired, bool subClassRealizationRequired, cint64 instanceComputationRequiredCount, COptimizedComplexConceptItem** assocConceptItem) {
bool created = false;
COptimizedComplexConceptItem* conceptItem = mOntoAnsweringItem->getComplexConceptItem(testingConcept, testingNegation, true, &created);
if (assocConceptItem) {
*assocConceptItem = conceptItem;
}
if (buildingVarItem) {
buildingVarItem->addUsedComplexConceptItem(conceptItem);
}
conceptItem->incCacheWeightedUsageFactor(mOntoAnsweringItem->getNextUsageWeight());
if (created) {
mOntoAnsweringItem->getAnsweringHandlingStatistics()->incCreatedComplexConceptItemsCount();
if (!mOntoAnsweringItem->getTestingOntology()->getABox()->hasUniversalConnectionIndividual()) {
bool usesTopRolePropagation = checkHasNewTopRolePropagation(testingConcept, testingNegation);
if (usesTopRolePropagation) {
conceptItem->setTopObjectPropertyUsage(usesTopRolePropagation);
}
}
extractAtomicSubsumerExpressions(conceptItem);
searchTrivialSuperSubConceptItems(conceptItem);
}
if (queryProcessingData) {
conceptItem->incQueryUsageCount();
queryProcessingData->setConceptItem(conceptItem);
}
CComplexConceptItemComputationProcess* computationProcess = conceptItem->getComputationProcess();
bool instancesDirectResolveable = true;
if (instanceComputationRequiredCount != 0) {
instancesDirectResolveable = false;
if (checkConceptInstancesCompletelyResolveable(conceptItem, nullptr)) {
instancesDirectResolveable = true;
}
}
bool requiresProcessing = false;
subClassNodesComputationRequired |= equivalentClassNodesComputationRequired || subClassRealizationRequired;
superClassNodesComputationRequired |= subClassNodesComputationRequired || !instancesDirectResolveable;
satisfiableComputationRequired |= superClassNodesComputationRequired;
if (satisfiableComputationRequired) {
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getSatisfiableClassNodesComputationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
}
if (superClassNodesComputationRequired) {
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getSuperClassNodesComputationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
}
if (subClassNodesComputationRequired) {
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getSubClassNodesComputationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
}
if (equivalentClassNodesComputationRequired) {
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getEquivalentClassNodesComputationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
}
if (subClassRealizationRequired) {
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getSubClassRealizationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
}
if (instanceComputationRequiredCount == -1) {
CComplexConceptStepInstanceComputationProcess* instanceCompStep = computationProcess->getInstancesComputationProcess(true);
instanceCompStep->setAllInstanceComputationRequired(true);
requiresProcessing |= initializeQueryProcessingStep(computationProcess->getInstancesComputationProcess(true), conceptItem, queryProcessingData, buildingVarItem);
} else if (instanceComputationRequiredCount > 0) {
CComplexConceptStepInstanceComputationProcess* instanceCompStep = computationProcess->getInstancesComputationProcess(true);
if (instanceComputationRequiredCount > instanceCompStep->getComputedInstancesCount()) {
CComputedItemDataNotificationLinker* notLinker = nullptr;
if (queryProcessingData) {
if (!notLinker) {
notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
}
notLinker->setQueryProcessingData(queryProcessingData);
queryProcessingData->setComputationStepWaiting(instanceCompStep);
}
if (buildingVarItem) {
if (!notLinker) {
notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
}
notLinker->setBuildingVariableItemProcessingItem(buildingVarItem);
buildingVarItem->setComputationStepWaiting(instanceCompStep);
}
if (notLinker) {
instanceCompStep->addComputedInstancesCountRequirement(instanceComputationRequiredCount, notLinker);
}
queueConceptItemProcessing(conceptItem, instanceCompStep);
requiresProcessing = true;
}
}
return requiresProcessing;
}
bool COptimizedComplexExpressionAnsweringHandler::initializeQueryProcessingStep(CComplexConceptStepComputationProcess* compStep, COptimizedComplexConceptItem* conceptItem, CComplexQueryExpressionProcessingData* queryProcessingData, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem) {
if (compStep->isComputationProcessFinished()) {
return false;
} else {
compStep->setComputationProcessRequired(true);
CComputedItemDataNotificationLinker* notLinker = nullptr;
if (queryProcessingData) {
if (!notLinker) {
notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
}
notLinker->setQueryProcessingData(queryProcessingData);
queryProcessingData->setComputationStepWaiting(compStep);
}
if (buildingVarItem) {
if (!notLinker) {
notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
}
notLinker->setBuildingVariableItemProcessingItem(buildingVarItem);
buildingVarItem->setComputationStepWaiting(compStep);
}
if (notLinker) {
compStep->addNotificationLinker(notLinker);
}
queueConceptItemProcessing(conceptItem, compStep);
return true;
}
}
bool COptimizedComplexExpressionAnsweringHandler::checkHasNewTopRolePropagation(CConcept* concept, bool conceptNegation) {
CRole* topRole = mOntoAnsweringItem->getTestingOntology()->getRBox()->getTopObjectRole();
QList testingList;
QSet testedSet;
testingList.append(concept);
testedSet.insert(concept);
while (!testingList.isEmpty()) {
CConcept* testingConcept = testingList.takeFirst();
cint64 opCode = testingConcept->getOperatorCode();
CConceptOperator* conceptOperator = testingConcept->getConceptOperator();
if (conceptOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_TYPE | CConceptOperator::CCFS_SOME_TYPE)) {
CRole* role = testingConcept->getRole();
if (role == topRole) {
return true;
}
}
if (opCode != CCEQ && opCode != CCSUB) {
for (CSortedNegLinker* opConLinkerIt = testingConcept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
if (!testedSet.contains(opConcept)) {
testedSet.insert(opConcept);
testingList.append(opConcept);
}
}
}
}
return false;
}
COptimizedComplexExpressionAnsweringHandler* COptimizedComplexExpressionAnsweringHandler::readConfig() {
CCalculationConfigurationExtension* config = mOntoAnsweringItem->getCalculationConfiguration();
mConfDebugTestingOntologyWriting = config->isDebuggingWriteDataActivated();
mJoinComputer->configureComputator(mOntoAnsweringItem, this, mAnswererContext);
mPropagationComputer->configureComputator(mOntoAnsweringItem, this, mAnswererContext);
return this;
}
bool COptimizedComplexExpressionAnsweringHandler::checkUsesQueryOnlyKnownEntities(CConcreteOntology* expressionOntology) {
COntologyBuildData* expressionOntologyBuildData = expressionOntology->getBuildData();
COntologyBuildData* baseOntologyBuildData = mOntoAnsweringItem->getOntology()->getBuildData();
if (baseOntologyBuildData->getClassEntityBuildHash()->size() != expressionOntologyBuildData->getClassEntityBuildHash()->size()) {
if (mConfDetailedMissingEntityReporting) {
for (CBUILDHASH::const_iterator it = expressionOntologyBuildData->getClassEntityBuildHash()->constBegin(), itEnd = expressionOntologyBuildData->getClassEntityBuildHash()->constEnd(); it != itEnd; ++it) {
CClassExpression* classEx = it.value();
if (!baseOntologyBuildData->getClassEntityBuildHash()->contains(classEx->getName())) {
LOG(WARN, getDomain(), logTr("Class %1 not used in queried ontology.").arg(classEx->getName()), this);
return false;
}
}
}
return false;
}
if (baseOntologyBuildData->getDataPropertyEntityBuildHash()->size() != expressionOntologyBuildData->getDataPropertyEntityBuildHash()->size()) {
return false;
}
if (baseOntologyBuildData->getObjectPropertyEntityBuildHash()->size() != expressionOntologyBuildData->getObjectPropertyEntityBuildHash()->size()) {
if (mConfDetailedMissingEntityReporting) {
for (CBUILDHASH::const_iterator it = expressionOntologyBuildData->getObjectPropertyEntityBuildHash()->constBegin(), itEnd = expressionOntologyBuildData->getObjectPropertyEntityBuildHash()->constEnd(); it != itEnd; ++it) {
CObjectPropertyExpression* objPropEx = it.value();
if (!baseOntologyBuildData->getObjectPropertyEntityBuildHash()->contains(objPropEx->getName())) {
LOG(WARN, getDomain(), logTr("Object property %1 not used in queried ontology.").arg(objPropEx->getName()), this);
return false;
}
}
}
return false;
}
if (baseOntologyBuildData->getIndividualEntityBuildHash()->size() != expressionOntologyBuildData->getIndividualEntityBuildHash()->size()) {
COntologyTriplesAssertionsAccessor* indexedTriplesAssertionAccessor = mOntoAnsweringItem->getOntology()->getOntologyTriplesData()->getTripleAssertionAccessor();
if (indexedTriplesAssertionAccessor) {
CBUILDHASH* baseIndiEntHash = baseOntologyBuildData->getIndividualEntityBuildHash();
CBUILDHASH* expIndiEntHash = expressionOntologyBuildData->getIndividualEntityBuildHash();
for (CBUILDHASH::const_iterator it = expIndiEntHash->constBegin(), itEnd = expIndiEntHash->constEnd(); it != itEnd; ++it) {
if (!baseIndiEntHash->contains(it.key())) {
// check whether the individual is indexed in the triple stored data
CNamedIndividualExpression* namedIndiEntExp = it.value();
if (!indexedTriplesAssertionAccessor->hasIndividualId(namedIndiEntExp->getName())) {
return false;
}
}
}
} else {
CBUILDHASH* baseIndiEntHash = baseOntologyBuildData->getIndividualEntityBuildHash();
CBUILDHASH* expIndiEntHash = expressionOntologyBuildData->getIndividualEntityBuildHash();
COntologyStringMapping* stringMapping = mOntoAnsweringItem->getOntology()->getStringMapping();
for (CBUILDHASH::const_iterator it = expIndiEntHash->constBegin(), itEnd = expIndiEntHash->constEnd(); it != itEnd; ++it) {
if (!baseIndiEntHash->contains(it.key())) {
// check whether the individual is indexed in the triple stored data
CNamedIndividualExpression* namedIndiEntExp = it.value();
if (!stringMapping->getIndividualFromName(namedIndiEntExp->getName())) {
return false;
}
}
}
}
}
if (baseOntologyBuildData->getDatatypeIRIBuildHash()->size() != expressionOntologyBuildData->getDatatypeIRIBuildHash()->size()) {
return false;
}
if (baseOntologyBuildData->getAnonymousIndividualBuildHash()->size() != expressionOntologyBuildData->getAnonymousIndividualBuildHash()->size()) {
return false;
}
return true;
}
static bool itemSortMoreHierachyDepthThan(const TDepthTermPair& item1, const TDepthTermPair& item2) {
return item1.first > item2.first;
}
bool COptimizedComplexExpressionAnsweringHandler::tryEmbedVariableRestrictions(CExpressionVariable* varTesting, CExpressionVariable* varEmbedding, QHash& varExpEmbeddingHash,
const QHash& varExpAxiomExpHash, const QSet& anonymousIndiVariableSet, const QSet& answerIndiVariableSet, CAnswererContext* answererContext) {
if (varExpEmbeddingHash.value(varTesting) == varEmbedding) {
return true;
} else if (varExpEmbeddingHash.contains(varTesting)) {
return false;
}
if (varExpEmbeddingHash.contains(varEmbedding)) {
return false;
}
if (answerIndiVariableSet.contains(varTesting)) {
return false;
}
if (!anonymousIndiVariableSet.contains(varTesting)) {
if (anonymousIndiVariableSet.contains(varEmbedding)) {
return false;
}
}
QSet> testingObjPropExpSet;
QSet testingClassExpSet;
QList remainingEmbedObjPropList;
QList availEmbedObjPropList;
CTaxonomy* classHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getClassConceptClassification()->getClassConceptTaxonomy();
CRolePropertiesHierarchy* rolePropertyHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getObjectPropertyRoleClassification()->getRolePropertiesHierarchy();
for (CAxiomExpression* axExp : varExpAxiomExpHash.values(varTesting)) {
CClassAssertionExpression* classAssExp = dynamic_cast(axExp);
if (classAssExp) {
CClassTermExpression* classExp = classAssExp->getClassTermExpression();
testingClassExpSet.insert(classExp);
} else {
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(axExp);
if (propAssExp) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
if (varTesting == dynamic_cast(propAssExp->getFirstIndividualTermExpression())) {
testingObjPropExpSet.insert(QPair(propExp, false));
} else {
testingObjPropExpSet.insert(QPair(propExp, true));
}
remainingEmbedObjPropList.append(propAssExp);
} else {
// TODO: extend to data values/assertions
return false;
}
}
}
if (!testingObjPropExpSet.isEmpty() || !testingClassExpSet.isEmpty()) {
QSet> embeddingObjPropExpSet;
QSet embeddingClassExpSet;
for (CAxiomExpression* axExp : varExpAxiomExpHash.values(varEmbedding)) {
CClassAssertionExpression* classAssExp = dynamic_cast(axExp);
if (classAssExp) {
if (!testingClassExpSet.isEmpty()) {
CClassTermExpression* classExp = classAssExp->getClassTermExpression();
embeddingClassExpSet.insert(classExp);
}
} else {
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(axExp);
if (propAssExp) {
if (!testingObjPropExpSet.isEmpty()) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
if (varEmbedding == dynamic_cast(propAssExp->getFirstIndividualTermExpression())) {
embeddingObjPropExpSet.insert(QPair(propExp, false));
} else {
embeddingObjPropExpSet.insert(QPair(propExp, true));
}
availEmbedObjPropList.append(propAssExp);
}
} else {
// TODO: extend to data values/assertions
}
}
}
for (QSet::iterator it = testingClassExpSet.begin(), itEnd = testingClassExpSet.end(); it != itEnd; ) {
CClassTermExpression* testingClassExp = *it;
if (embeddingClassExpSet.contains(testingClassExp)) {
it = testingClassExpSet.erase(it);
} else {
++it;
}
}
for (QSet>::iterator it = testingObjPropExpSet.begin(), itEnd = testingObjPropExpSet.end(); it != itEnd; ) {
QPair propInvPair = *it;
CObjectPropertyTermExpression* testingObjPropExp = propInvPair.first;
bool inversed = propInvPair.second;
if (embeddingObjPropExpSet.contains(propInvPair)) {
it = testingObjPropExpSet.erase(it);
} else {
++it;
}
}
if (!testingClassExpSet.isEmpty()) {
QSet embeddingHierNodeSet;
for (QSet::iterator it = embeddingClassExpSet.begin(), itEnd = embeddingClassExpSet.end(); it != itEnd; ++it) {
CClassTermExpression* classExp = *it;
if (classHierarchy && dynamic_cast(classExp)) {
CConcept* concept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classExp);
if (concept) {
CHierarchyNode* hierNode = classHierarchy->getHierarchyNode(concept, false);
if (hierNode) {
embeddingHierNodeSet.insert(hierNode);
for (CHierarchyNode* predHierNode : *hierNode->getPredecessorNodeSet()) {
embeddingHierNodeSet.insert(predHierNode);
}
}
}
}
}
for (QSet::iterator it = testingClassExpSet.begin(), itEnd = testingClassExpSet.end(); classHierarchy && it != itEnd; ++it) {
CClassTermExpression* classExp = *it;
if (!dynamic_cast(classExp)) {
return false;
} else {
CConcept* concept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classExp);
if (!concept) {
return false;
} else {
CHierarchyNode* hierNode = classHierarchy->getHierarchyNode(concept, false);
if (!hierNode) {
return false;
} else if (!embeddingHierNodeSet.contains(hierNode)) {
return false;
}
}
}
}
}
if (!remainingEmbedObjPropList.isEmpty()) {
QHash embeddingHierNodeObjectPropAssHash;
QHash embeddingHierNodeInvObjectPropAssHash;
for (CObjectPropertyAssertionExpression* propAssExp : availEmbedObjPropList) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
bool inversed = true;
if (varEmbedding == dynamic_cast(propAssExp->getFirstIndividualTermExpression())) {
inversed = false;
}
if (rolePropertyHierarchy) {
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp);
if (inversed && role) {
role = role->getInverseRole();
}
if (role) {
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
if (hierNode) {
embeddingHierNodeObjectPropAssHash.insertMulti(hierNode, propAssExp);
for (CRolePropertiesHierarchyNode* predHierNode : *hierNode->getPredecessorNodeSet()) {
embeddingHierNodeObjectPropAssHash.insertMulti(predHierNode, propAssExp);
}
}
CRolePropertiesHierarchyNode* invHierNode = rolePropertyHierarchy->getHierarchyNode(role->getInverseRole());
if (invHierNode) {
embeddingHierNodeInvObjectPropAssHash.insertMulti(invHierNode, propAssExp);
for (CRolePropertiesHierarchyNode* predHierNode : *invHierNode->getPredecessorNodeSet()) {
embeddingHierNodeInvObjectPropAssHash.insertMulti(predHierNode, propAssExp);
}
}
}
}
}
if (!testingObjPropExpSet.isEmpty()) {
for (QSet>::iterator it = testingObjPropExpSet.begin(), itEnd = testingObjPropExpSet.end(); it != itEnd; ++it) {
QPair propInvPair = *it;
CObjectPropertyTermExpression* testingObjPropExp = propInvPair.first;
bool inversed = propInvPair.second;
if (!dynamic_cast(testingObjPropExp)) {
return false;
} else {
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(testingObjPropExp);
if (inversed && role) {
role = role->getInverseRole();
}
if (!role) {
return false;
} else {
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
if (hierNode) {
if (!embeddingHierNodeObjectPropAssHash.contains(hierNode)) {
return false;
}
} else {
CRolePropertiesHierarchyNode* invHierNode = rolePropertyHierarchy->getHierarchyNode(role->getInverseRole());
if (invHierNode) {
if (!embeddingHierNodeInvObjectPropAssHash.contains(invHierNode)) {
return false;
}
}
}
}
}
}
}
// assume embedding
QHash newVarExpEmbeddingHash(varExpEmbeddingHash);
newVarExpEmbeddingHash.insert(varTesting, varEmbedding);
if (!tryEmbedVariablesObjectPropertyAssertionList(varTesting, varEmbedding, remainingEmbedObjPropList, embeddingHierNodeObjectPropAssHash, embeddingHierNodeInvObjectPropAssHash, newVarExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
return false;
}
varExpEmbeddingHash = newVarExpEmbeddingHash;
}
}
return true;
}
bool COptimizedComplexExpressionAnsweringHandler::tryEmbedVariablesObjectPropertyAssertionList(CExpressionVariable* varTesting, CExpressionVariable* varEmbedding, const QList& remainingEmbedObjPropList, const QHash& embeddingHierNodeObjectPropAssHash, const QHash& embeddingHierNodeInvObjectPropAssHash,
QHash& varExpEmbeddingHash, const QHash& varExpAxiomExpHash, const QSet& anonymousIndiVariableSet, const QSet& answerIndiVariableSet, CAnswererContext* answererContext) {
if (!remainingEmbedObjPropList.isEmpty()) {
QList embedObjPropList(remainingEmbedObjPropList);
CRolePropertiesHierarchy* rolePropertyHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getObjectPropertyRoleClassification()->getRolePropertiesHierarchy();
CObjectPropertyAssertionExpression* propAssExp = embedObjPropList.takeFirst();
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
CIndividualTermExpression* otherIndiExp = propAssExp->getFirstIndividualTermExpression();
bool inversed = true;
if (varTesting == dynamic_cast(propAssExp->getFirstIndividualTermExpression())) {
inversed = false;
otherIndiExp = propAssExp->getSecondIndividualTermExpression();
}
CExpressionVariable* otherVarExp = dynamic_cast(otherIndiExp);
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp);
if (inversed && role) {
role = role->getInverseRole();
}
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
QList embeddingPropAssExpList;
if (hierNode) {
embeddingPropAssExpList = embeddingHierNodeObjectPropAssHash.values(hierNode);
} else {
CRolePropertiesHierarchyNode* invHierNode = rolePropertyHierarchy->getHierarchyNode(role->getInverseRole());
if (invHierNode) {
embeddingPropAssExpList = embeddingHierNodeInvObjectPropAssHash.values(invHierNode);
}
}
for (CObjectPropertyAssertionExpression* embeddingPropAssExp : embeddingPropAssExpList) {
CObjectPropertyTermExpression* embeddingObjPropExp = embeddingPropAssExp->getObjectPropertyTermExpression();
bool embeddingInversed = true;
CIndividualTermExpression* embeddingOtherIndiExp = embeddingPropAssExp->getFirstIndividualTermExpression();
if (varEmbedding == dynamic_cast(embeddingPropAssExp->getFirstIndividualTermExpression())) {
embeddingInversed = false;
embeddingOtherIndiExp = embeddingPropAssExp->getSecondIndividualTermExpression();
}
CExpressionVariable* embeddingOtherVarExp = dynamic_cast(embeddingOtherIndiExp);
if (embeddingOtherVarExp && otherVarExp) {
if (embeddingOtherVarExp == otherVarExp && (!varExpEmbeddingHash.contains(embeddingOtherVarExp) || varExpEmbeddingHash.value(embeddingOtherVarExp) == otherVarExp)) {
QHash newVarExpEmbeddingHash(varExpEmbeddingHash);
newVarExpEmbeddingHash.insert(embeddingOtherVarExp, otherVarExp);
if (tryEmbedVariablesObjectPropertyAssertionList(varTesting, varEmbedding, embedObjPropList, embeddingHierNodeObjectPropAssHash, embeddingHierNodeInvObjectPropAssHash, newVarExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
varExpEmbeddingHash = newVarExpEmbeddingHash;
return true;
}
} else {
QHash newVarExpEmbeddingHash(varExpEmbeddingHash);
if (tryEmbedVariableRestrictions(otherVarExp, embeddingOtherVarExp, newVarExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
if (tryEmbedVariablesObjectPropertyAssertionList(varTesting, varEmbedding, embedObjPropList, embeddingHierNodeObjectPropAssHash, embeddingHierNodeInvObjectPropAssHash, newVarExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
varExpEmbeddingHash = newVarExpEmbeddingHash;
return true;
}
}
}
} else if (otherIndiExp == embeddingOtherIndiExp) {
if (tryEmbedVariablesObjectPropertyAssertionList(varTesting, varEmbedding, embedObjPropList, embeddingHierNodeObjectPropAssHash, embeddingHierNodeInvObjectPropAssHash, varExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
return true;
}
}
}
} else {
return true;
}
return false;
}
QList COptimizedComplexExpressionAnsweringHandler::getRedundantlyEmbeddedVariables(QHash& varExpAxiomExpHash, const QSet& anonymousIndiVariableSet, const QSet& answerIndiVariableSet, CComplexQueryExpressionProcessingData* queryProcessingData, CAnswererContext* answererContext) {
CRolePropertiesHierarchy* rolePropertyHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getObjectPropertyRoleClassification()->getRolePropertiesHierarchy();
QHash varExpEmbeddingHash;
QSet redundantVariableSet;
CExpressionVariable* testingVarExp = nullptr;
QList propAssExpList;
for (QHash::iterator it = varExpAxiomExpHash.begin(), itEnd = varExpAxiomExpHash.end(); it != itEnd; ++it) {
CExpressionVariable* varExp = it.key();
if (varExp != testingVarExp) {
if (testingVarExp && propAssExpList.size() >= 2) {
qSort(propAssExpList.begin(), propAssExpList.end(), itemSortMoreHierachyDepthThan);
QList::const_iterator itProp1 = propAssExpList.constBegin(), itPropEnd = propAssExpList.constEnd();
while (itProp1 != itPropEnd) {
TDepthTermPair item1 = *itProp1;
++itProp1;
CObjectPropertyAssertionExpression* propAssExp1 = (CObjectPropertyAssertionExpression*)item1.second;
CObjectPropertyTermExpression* propExp1 = propAssExp1->getObjectPropertyTermExpression();
CRole* role1 = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp1);
CExpressionVariable* otherVarExp1 = dynamic_cast(propAssExp1->getSecondIndividualTermExpression());
bool inversed1 = false;
if (testingVarExp == otherVarExp1) {
inversed1 = true;
otherVarExp1 = dynamic_cast(propAssExp1->getFirstIndividualTermExpression());
role1 = role1->getInverseRole();
}
if (!varExpEmbeddingHash.contains(otherVarExp1)) {
CRolePropertiesHierarchyNode* hierNode1 = rolePropertyHierarchy->getHierarchyNode(role1);
CRolePropertiesHierarchyNode* invHierNode1 = rolePropertyHierarchy->getHierarchyNode(role1->getInverseRole());
QList::const_iterator itProp2 = propAssExpList.constBegin();
while (itProp2 != itPropEnd) {
TDepthTermPair item2 = *itProp2;
++itProp2;
CObjectPropertyAssertionExpression* propAssExp2 = (CObjectPropertyAssertionExpression*)item2.second;
if (propAssExp2 != propAssExp1) {
CObjectPropertyTermExpression* propExp2 = propAssExp2->getObjectPropertyTermExpression();
CRole* role2 = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp2);
CExpressionVariable* otherVarExp2 = dynamic_cast(propAssExp2->getSecondIndividualTermExpression());
bool inversed2 = false;
if (testingVarExp == otherVarExp2) {
inversed2 = true;
otherVarExp2 = dynamic_cast(propAssExp2->getFirstIndividualTermExpression());
role2 = role2->getInverseRole();
}
CRolePropertiesHierarchyNode* hierNode2 = rolePropertyHierarchy->getHierarchyNode(role2);
CRolePropertiesHierarchyNode* invHierNode2 = rolePropertyHierarchy->getHierarchyNode(role2->getInverseRole());
if (!varExpEmbeddingHash.contains(otherVarExp2)) {
if (otherVarExp1 != otherVarExp2 && (hierNode1 && hierNode2 && hierNode2->hasPredecessorNode(hierNode1) || invHierNode1 && invHierNode2 && invHierNode2->hasPredecessorNode(invHierNode1))) {
if (tryEmbedVariableRestrictions(otherVarExp1, otherVarExp2, varExpEmbeddingHash, varExpAxiomExpHash, anonymousIndiVariableSet, answerIndiVariableSet, answererContext)) {
break;
}
}
}
}
}
}
}
}
propAssExpList.clear();
testingVarExp = varExp;
}
CAxiomExpression* axExp = it.value();
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(axExp);
if (propAssExp) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
CExpressionVariable* otherVarExp1 = dynamic_cast(propAssExp->getSecondIndividualTermExpression());
CExpressionVariable* otherVarExp2 = dynamic_cast(propAssExp->getFirstIndividualTermExpression());
if (otherVarExp1 && otherVarExp2 && otherVarExp1 != otherVarExp2) {
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp);
if (role && rolePropertyHierarchy) {
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
if (hierNode) {
propAssExpList.append(TDepthTermPair(hierNode->getPredecessorNodeSet()->count(), propAssExp));
}
}
}
}
}
QList redEmbVarList;
for (QHash::const_iterator it = varExpEmbeddingHash.constBegin(), itEnd = varExpEmbeddingHash.constEnd(); it != itEnd; ++it) {
CExpressionVariable* varExp = it.key();
CExpressionVariable* embeddedIntoVarExp = it.value();
if (varExp != embeddedIntoVarExp) {
redEmbVarList.append(varExp);
}
}
return redEmbVarList;
}
QList COptimizedComplexExpressionAnsweringHandler::eliminateRedundantQueryTerms(const QList& assExps, CComplexQueryExpressionProcessingData* queryProcessingData, CAnswererContext* answererContext) {
QList redElimAssExpList;
typedef QPair TConceptIndiTermPair;
typedef QPair > TRoleIndiTermsPair;
QSet< TConceptIndiTermPair > redundantClassAssertionSet;
QSet< TRoleIndiTermsPair > redundantRoleAssertionSet;
QList depthTermAxiomPairList;
CTaxonomy* classHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getClassConceptClassification()->getClassConceptTaxonomy();
CRolePropertiesHierarchy* rolePropertyHierarchy = mOntoAnsweringItem->getOntology()->getClassification()->getObjectPropertyRoleClassification()->getRolePropertiesHierarchy();
for (CAxiomExpression* assExp : assExps) {
CClassAssertionExpression* classAssExp = dynamic_cast(assExp);
if (classAssExp) {
CClassTermExpression* classExp = classAssExp->getClassTermExpression();
bool foundHierNode = false;;
if (classHierarchy && dynamic_cast(classExp)) {
CConcept* concept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classExp);
if (concept) {
CHierarchyNode* hierNode = classHierarchy->getHierarchyNode(concept, false);
if (hierNode) {
depthTermAxiomPairList.append(TDepthTermPair(hierNode->getPredecessorNodeCount(), classAssExp));
foundHierNode = true;
}
}
}
if (!foundHierNode) {
redElimAssExpList.append(classAssExp);
}
} else {
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(assExp);
if (propAssExp) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp);
bool foundHierNode = false;
if (role && rolePropertyHierarchy) {
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
if (hierNode) {
depthTermAxiomPairList.append(TDepthTermPair(hierNode->getPredecessorNodeSet()->count(), propAssExp));
foundHierNode = true;
}
}
if (!foundHierNode) {
redElimAssExpList.append(classAssExp);
}
} else {
redElimAssExpList.append(assExp);
}
}
}
qSort(depthTermAxiomPairList.begin(), depthTermAxiomPairList.end(), itemSortMoreHierachyDepthThan);
for (TDepthTermPair depthTermPair : depthTermAxiomPairList) {
CAxiomExpression* assExp = depthTermPair.second;
CClassAssertionExpression* classAssExp = dynamic_cast(assExp);
if (classAssExp) {
CClassTermExpression* classExp = classAssExp->getClassTermExpression();
CConcept* concept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classExp);
CHierarchyNode* hierNode = classHierarchy->getHierarchyNode(concept, false);
if (!redundantClassAssertionSet.contains(TConceptIndiTermPair(hierNode, classAssExp->getIndividualTermExpression()))) {
redundantClassAssertionSet.insert(TConceptIndiTermPair(hierNode, classAssExp->getIndividualTermExpression()));
redElimAssExpList.append(assExp);
for (CHierarchyNode* predHierNode : *hierNode->getPredecessorNodeSet()) {
redundantClassAssertionSet.insert(TConceptIndiTermPair(predHierNode, classAssExp->getIndividualTermExpression()));
}
}
} else {
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(assExp);
if (propAssExp) {
CObjectPropertyTermExpression* propExp = propAssExp->getObjectPropertyTermExpression();
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(propExp);
CRolePropertiesHierarchyNode* hierNode = rolePropertyHierarchy->getHierarchyNode(role);
TRoleIndiTermsPair roleIndisPair(hierNode->getOneEquivalentElement(), QPair(propAssExp->getFirstIndividualTermExpression(), propAssExp->getSecondIndividualTermExpression()));
if (!redundantRoleAssertionSet.contains(roleIndisPair)) {
redundantRoleAssertionSet.insert(roleIndisPair);
CRole* invRole = hierNode->getOneEquivalentElement()->getInverseRole();
if (invRole) {
redundantRoleAssertionSet.insert(TRoleIndiTermsPair(invRole, QPair(propAssExp->getSecondIndividualTermExpression(), propAssExp->getFirstIndividualTermExpression())));
}
redElimAssExpList.append(assExp);
for (CRolePropertiesHierarchyNode* predHierNode : *hierNode->getPredecessorNodeSet()) {
CRole* invPredRole = predHierNode->getOneEquivalentElement()->getInverseRole();
redundantRoleAssertionSet.insert(TRoleIndiTermsPair(predHierNode->getOneEquivalentElement(), QPair(propAssExp->getFirstIndividualTermExpression(), propAssExp->getSecondIndividualTermExpression())));
if (invPredRole) {
redundantRoleAssertionSet.insert(TRoleIndiTermsPair(invPredRole, QPair(propAssExp->getSecondIndividualTermExpression(), propAssExp->getFirstIndividualTermExpression())));
}
}
}
}
}
}
return redElimAssExpList;
}
COptimizedComplexExpressionAnsweringHandler* COptimizedComplexExpressionAnsweringHandler::initializeQueryProcessing(CComplexQueryExpressionProcessingData* queryProcessingData, CAnswererContext* answererContext) {
CComplexAnsweringExpressionQuery* query = queryProcessingData->getQuery();
CConcreteOntology* expOnto = query->getExrpessionOntology();
CConcreteOntology* baseOnto = query->getBaseOntology();
mAnswererContext = answererContext;
mOntoAnsweringItem->incCurrentlyAnsweringQueryCount();
bool queryProcessing = false;
bool queryCompleted = false;
if (!queryProcessingData->isProcessingStarted()) {
queryProcessingData->setProcessingStarted();
}
CComplexAnsweringExpressionQuery* complAnsQuery = dynamic_cast(query);
if (!checkUsesQueryOnlyKnownEntities(complAnsQuery->getExrpessionOntology())) {
if (mConfFailOnUnknownEntity) {
failQueryProcessing(queryProcessingData, new CQueryUnknownEntityReferenceError(baseOnto));
queryCompleted = true;
} else {
finishQueryProcessingAsUnsatisfaible(queryProcessingData);
queryCompleted = true;
}
} else {
increaseUsageWeight();
CConcreteOntology* testingOnto = mOntoAnsweringItem->getTestingOntology();
if (testingOnto) {
CComplexConceptAnsweringQuery* compConQuery = dynamic_cast(query);
if (compConQuery) {
CBuildExpression* expOfInt = compConQuery->getExpressionOfInterest();
mTestingOntologyBuilder->initializeBuilding();
CBuildExpression* testingExpOfInt = mTestingOntologyBuilder->rebuildExpression(expOfInt);
mTestingOntologyBuilder->completeBuilding();
mTestingOntologyPreprocessor->preprocess(testingOnto, testingOnto->getConfiguration());
CClassTermExpression* classTermExpOfInt = dynamic_cast(testingExpOfInt);
if (classTermExpOfInt) {
bool instanceComputationRequired = compConQuery->isInstancesComputationRequired();
bool equivalentClassNodesComputationRequired = compConQuery->isEquivalentClassNodesComputationRequired();
bool subClassNodesComputationRequired = compConQuery->isSubClassNodesComputationRequired();
bool superClassNodesComputationRequired = compConQuery->isSuperClassNodesComputationRequired();
bool satisfiableComputationRequired = compConQuery->isSatisfiableComputationRequired();
bool direct = compConQuery->isDirect();
queryProcessing |= initializeComplexConceptQueryProcessing(queryProcessingData, nullptr, classTermExpOfInt, satisfiableComputationRequired, superClassNodesComputationRequired, subClassNodesComputationRequired, equivalentClassNodesComputationRequired, direct, instanceComputationRequired? -1 : 0, nullptr);
}
}
CComplexAxiomsClassVariablesAnsweringQuery* compAxClassVarQuery = dynamic_cast(query);
if (compAxClassVarQuery) {
initComplexAxiomsClassVariablesQuery(compAxClassVarQuery, answererContext, queryProcessingData, queryCompleted, testingOnto, queryProcessing);
}
CComplexAxiomsObjectPropertyVariablesAnsweringQuery* compAxPropVarQuery = dynamic_cast(query);
if (compAxPropVarQuery) {
initComplexAxiomsObjectPropertyVariablesQuery(compAxPropVarQuery, answererContext, queryProcessingData, queryCompleted, testingOnto, queryProcessing);
}
CComplexAxiomsDataPropertyVariablesAnsweringQuery* compAxDataVarQuery = dynamic_cast(query);
if (compAxDataVarQuery) {
initComplexAxiomsDataPropertyVariablesQuery(compAxDataVarQuery, answererContext, queryProcessingData, queryCompleted, testingOnto, queryProcessing);
}
CComplexAssertionsIndividualVariablesAnsweringQuery* compAssIndVarQuery = dynamic_cast(query);
if (compAssIndVarQuery) {
initComplexAssertionsIndividualVariablesQuery(compAssIndVarQuery, answererContext, queryProcessingData, queryCompleted, testingOnto, queryProcessing);
}
CComplexAxiomsIndividualMixedVariablesAnsweringQuery* compAxIndMixedVarQuery = dynamic_cast(query);
if (compAxIndMixedVarQuery) {
initComplexAxiomsIndividualMixedVariablesQuery(compAxIndMixedVarQuery, answererContext, queryProcessingData, queryCompleted, testingOnto, queryProcessing);
}
}
}
if (!queryCompleted && !queryProcessing) {
finishQueryProcessing(queryProcessingData);
}
return this;
}
CRole* COptimizedComplexExpressionAnsweringHandler::getResolvedDataPropertyRole(CDataPropertyTermExpression* exp) {
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getDataPropertyTermRoleMappingHash()->value(exp);
return role;
}
CRole* COptimizedComplexExpressionAnsweringHandler::getInverseResolvedObjectPropertyRole(CObjectPropertyTermExpression* exp) {
bool inversed = false;
exp = getInverseResolvedObjectPropertyTermExpression(exp, inversed);
CRole* role = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(exp);
if (inversed) {
role = role->getInverseRole();
}
return role;
}
CObjectPropertyTermExpression* COptimizedComplexExpressionAnsweringHandler::getInverseResolvedObjectPropertyTermExpression(CObjectPropertyTermExpression* exp, bool& inversed) {
inversed = false;
while (dynamic_cast(exp)) {
CInverseObjectPropertyOfExpression* invObjPropEx = dynamic_cast(exp);
exp = invObjPropEx->getInverseOfExpression();
inversed = !inversed;
}
return exp;
}
void COptimizedComplexExpressionAnsweringHandler::initComplexAxiomsDataPropertyVariablesQuery(CComplexAxiomsDataPropertyVariablesAnsweringQuery* compAxPropVarQuery, CAnswererContext* answererContext, CComplexQueryExpressionProcessingData* queryProcessingData, bool &queryCompleted, CConcreteOntology* testingOnto, bool &queryProcessing) {
QList assExps = *compAxPropVarQuery->getAxiomExpressions();
QList dataPropSubAxiomExpsEntList;
CExpressionVariable* lastVarExpression = nullptr;
QSet varExpSet;
bool unsupportedWarning = false;
QHash varSuperDataPropRestrictionExpHash;
QHash varSubDataPropRestrictionExpHash;
QHash varSubVarSuperRestHash;
for (CAxiomExpression* assExp : assExps) {
bool supported = false;
CSubDataPropertyOfExpression* subDataPropOfAssExp = dynamic_cast(assExp);
if (subDataPropOfAssExp) {
supported = true;
bool hasVariable = false;
CDataPropertyVariableExpression* subDataPropVarExp = dynamic_cast(subDataPropOfAssExp->getSubDataPropertyTermExpression());
if (subDataPropVarExp) {
hasVariable = true;
lastVarExpression = subDataPropVarExp;
varExpSet.insert(subDataPropVarExp);
}
CObjectPropertyVariableExpression* superDataPropVarExp = dynamic_cast(subDataPropOfAssExp->getSuperDataPropertyTermExpression());
if (superDataPropVarExp) {
hasVariable = true;
lastVarExpression = superDataPropVarExp;
varExpSet.insert(superDataPropVarExp);
}
if (subDataPropVarExp && !superDataPropVarExp) {
varSuperDataPropRestrictionExpHash.insertMulti(subDataPropVarExp, subDataPropOfAssExp->getSuperDataPropertyTermExpression());
} else if (!subDataPropVarExp && superDataPropVarExp) {
varSubDataPropRestrictionExpHash.insertMulti(superDataPropVarExp, subDataPropOfAssExp->getSubDataPropertyTermExpression());
} else if (subDataPropVarExp && superDataPropVarExp) {
varSubVarSuperRestHash.insertMulti(subDataPropVarExp, superDataPropVarExp);
}
if (!hasVariable) {
dataPropSubAxiomExpsEntList.append(subDataPropOfAssExp);
}
}
if (!supported) {
if (!unsupportedWarning) {
LOG(WARN, getDomain(), logTr("Query uses unsupported axiom types, which will be ignored."), this);
}
unsupportedWarning = true;
}
}
if (!dataPropSubAxiomExpsEntList.isEmpty()) {
for (CSubDataPropertyOfExpression* subDataPropOfAssExp : dataPropSubAxiomExpsEntList) {
CRole* subRole = getResolvedDataPropertyRole(subDataPropOfAssExp->getSubDataPropertyTermExpression());
CRole* superRole = getResolvedDataPropertyRole(subDataPropOfAssExp->getSuperDataPropertyTermExpression());
queryProcessing |= checkEntailmentRoleSubDataPropertyAxiom(subRole, superRole, queryProcessingData, answererContext);
}
}
COptimizedComplexBuildingObjectPropertyVariableCompositionsItem* varBuildItem = new COptimizedComplexBuildingObjectPropertyVariableCompositionsItem(queryProcessingData);
for (CExpressionVariable* varExp : varExpSet) {
QList superDataPropRestrictionExps = varSuperDataPropRestrictionExpHash.values(varExp);
QList subDataPropRestrictionExps = varSubDataPropRestrictionExpHash.values(varExp);
for (CDataPropertyTermExpression* superDataPropRestrictionExp : superDataPropRestrictionExps) {
CRole* superRole = getResolvedDataPropertyRole(superDataPropRestrictionExp);
varBuildItem->addVariableComplexSuperRole((CPropertyVariableExpression*)varExp, superRole);
}
for (CDataPropertyTermExpression* subDataPropRestrictionExp : subDataPropRestrictionExps) {
CRole* subrRole = getResolvedDataPropertyRole(subDataPropRestrictionExp);
varBuildItem->addVariableComplexSubRole((CPropertyVariableExpression*)varExp, subrRole);
}
QList superVarList = varSubVarSuperRestHash.values(varExp);
for (CExpressionVariable* superVarExp : superVarList) {
varBuildItem->addVariableSubSuperPropagation(varExp, superVarExp);
}
}
queryProcessingData->setVariableBuildingItem(varBuildItem);
queryProcessingData->incBuildingVariableItem();
if (!queryProcessing) {
varBuildItem->setProcessingQueued(true);
mOntoAnsweringItem->addProcessingVariableBuildingItem(varBuildItem);
queryProcessing = true;
}
}
COptimizedComplexBuildingObjectPropertyVariableCompositionsItem* COptimizedComplexExpressionAnsweringHandler::initComplexAxiomsObjectPropertyVariablesQuery(CComplexAxiomsObjectPropertyVariablesAnsweringQuery* compAxPropVarQuery, CAnswererContext* answererContext, CComplexQueryExpressionProcessingData* queryProcessingData, bool &queryCompleted, CConcreteOntology* testingOnto, bool &queryProcessing) {
QList assExps = *compAxPropVarQuery->getAxiomExpressions();
QList objectPropSubAxiomExpsEntList;
CExpressionVariable* lastVarExpression = nullptr;
QSet varExpSet;
bool unsupportedWarning = false;
QHash varSuperObjPropRestrictionExpHash;
QHash varSubObjPropRestrictionExpHash;
QHash varSubVarSuperRestHash;
for (CAxiomExpression* assExp : assExps) {
bool supported = false;
CSubObjectPropertyOfExpression* subObjPropOfAssExp = dynamic_cast(assExp);
if (subObjPropOfAssExp) {
bool hasVariable = false;
CEXPRESSIONLIST* subObjPropList = subObjPropOfAssExp->getSubObjectPropertyTermExpressionList();
if (subObjPropList->size() == 1) {
supported = true;
CObjectPropertyVariableExpression* subObjPropVarExp = dynamic_cast(subObjPropList->first());
if (subObjPropVarExp) {
hasVariable = true;
lastVarExpression = subObjPropVarExp;
varExpSet.insert(subObjPropVarExp);
}
CObjectPropertyVariableExpression* superObjPropVarExp = dynamic_cast(subObjPropOfAssExp->getSuperObjectPropertyTermExpression());
if (superObjPropVarExp) {
hasVariable = true;
lastVarExpression = superObjPropVarExp;
varExpSet.insert(superObjPropVarExp);
}
if (subObjPropVarExp && !superObjPropVarExp) {
varSuperObjPropRestrictionExpHash.insertMulti(subObjPropVarExp, subObjPropOfAssExp->getSuperObjectPropertyTermExpression());
} else if (!subObjPropVarExp && superObjPropVarExp) {
varSubObjPropRestrictionExpHash.insertMulti(superObjPropVarExp, subObjPropOfAssExp->getSubObjectPropertyTermExpressionList()->first());
} else if (subObjPropVarExp && superObjPropVarExp) {
varSubVarSuperRestHash.insertMulti(subObjPropVarExp, superObjPropVarExp);
}
if (!hasVariable) {
objectPropSubAxiomExpsEntList.append(subObjPropOfAssExp);
}
}
}
if (!supported) {
if (!unsupportedWarning) {
LOG(WARN, getDomain(), logTr("Query uses unsupported axiom types, which will be ignored."), this);
}
unsupportedWarning = true;
}
}
if (!objectPropSubAxiomExpsEntList.isEmpty()) {
for (CSubObjectPropertyOfExpression* subObjPropOfAssExp : objectPropSubAxiomExpsEntList) {
CRole* subRole = getInverseResolvedObjectPropertyRole(subObjPropOfAssExp->getSubObjectPropertyTermExpressionList()->first());
CRole* superRole = getInverseResolvedObjectPropertyRole(subObjPropOfAssExp->getSuperObjectPropertyTermExpression());
queryProcessing |= checkEntailmentRoleSubObjectPropertyAxiom(subRole, superRole, queryProcessingData, answererContext);
}
}
COptimizedComplexBuildingObjectPropertyVariableCompositionsItem* varBuildItem = new COptimizedComplexBuildingObjectPropertyVariableCompositionsItem(queryProcessingData);
for (CExpressionVariable* varExp : varExpSet) {
QList superObjPropRestrictionExps = varSuperObjPropRestrictionExpHash.values(varExp);
QList subObjPropRestrictionExps = varSubObjPropRestrictionExpHash.values(varExp);
for (CObjectPropertyTermExpression* superObjPropRestrictionExp : superObjPropRestrictionExps) {
CRole* superRole = getInverseResolvedObjectPropertyRole(superObjPropRestrictionExp);
varBuildItem->addVariableComplexSuperRole((CPropertyVariableExpression*)varExp, superRole);
}
for (CObjectPropertyTermExpression* subObjPropRestrictionExp : subObjPropRestrictionExps) {
CRole* subrRole = getInverseResolvedObjectPropertyRole(subObjPropRestrictionExp);
varBuildItem->addVariableComplexSubRole((CPropertyVariableExpression*)varExp, subrRole);
}
QList superVarList = varSubVarSuperRestHash.values(varExp);
for (CExpressionVariable* superVarExp : superVarList) {
varBuildItem->addVariableSubSuperPropagation(varExp, superVarExp);
}
}
queryProcessingData->setVariableBuildingItem(varBuildItem);
queryProcessingData->incBuildingVariableItem();
if (!queryProcessing) {
varBuildItem->setProcessingQueued(true);
mOntoAnsweringItem->addProcessingVariableBuildingItem(varBuildItem);
queryProcessing = true;
}
return varBuildItem;
}
COptimizedComplexBuildingClassVariableCompositionsItem* COptimizedComplexExpressionAnsweringHandler::initComplexAxiomsClassVariablesQuery(CComplexAxiomsClassVariablesAnsweringQuery* compAxClassVarQuery, CAnswererContext* answererContext, CComplexQueryExpressionProcessingData* queryProcessingData, bool &queryCompleted, CConcreteOntology* testingOnto, bool &queryProcessing) {
QList assExps = *compAxClassVarQuery->getAxiomExpressions();
QList assExpsVarList;
QList classSubClassExpsEntList;
CExpressionVariable* lastVarExpression = nullptr;
QSet varExpSet;
bool unsupportedWarning = false;
for (CAxiomExpression* assExp : assExps) {
CSubClassOfExpression* subClasOfAssExp = dynamic_cast(assExp);
if (subClasOfAssExp) {
bool hasVariable = false;
CClassVariableExpression* subClassVarExp = dynamic_cast(subClasOfAssExp->getFirstClassTermExpression());
if (subClassVarExp) {
hasVariable = true;
lastVarExpression = subClassVarExp;
varExpSet.insert(subClassVarExp);
}
CClassVariableExpression* superClassVarExp = dynamic_cast(subClasOfAssExp->getSecondClassTermExpression());
if (superClassVarExp) {
hasVariable = true;
lastVarExpression = superClassVarExp;
varExpSet.insert(superClassVarExp);
}
if (!hasVariable) {
classSubClassExpsEntList.append(subClasOfAssExp);
} else {
assExpsVarList.append(subClasOfAssExp);
}
} else {
if (!unsupportedWarning) {
LOG(WARN, getDomain(), logTr("Query uses unsupported axiom types, which will be ignored."), this);
}
unsupportedWarning = true;
}
}
if (!classSubClassExpsEntList.isEmpty()) {
QList> subSuperClassTestExpList;
if (!classSubClassExpsEntList.isEmpty()) {
mTestingOntologyBuilder->initializeBuilding();
for (CSubClassOfExpression* subClasOfAssExp : classSubClassExpsEntList) {
CClassTermExpression* subClassTermExp = subClasOfAssExp->getFirstClassTermExpression();
CClassTermExpression* superClassTermExp = subClasOfAssExp->getSecondClassTermExpression();
subSuperClassTestExpList.append(QPair((CClassTermExpression*)mTestingOntologyBuilder->rebuildExpression(subClassTermExp), (CClassTermExpression*)mTestingOntologyBuilder->rebuildExpression(superClassTermExp)));
}
mTestingOntologyBuilder->completeBuilding();
mTestingOntologyPreprocessor->preprocess(testingOnto, testingOnto->getConfiguration());
}
for (QPair classIndiPair : subSuperClassTestExpList) {
CClassTermExpression* subClassTermExp = classIndiPair.first;
CClassTermExpression* superClassTermExp = classIndiPair.second;
CConcept* subConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(subClassTermExp);
CConcept* superConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(superClassTermExp);
bool subConNegation = subConcept->hasMappingNegation();
bool superConNegation = superConcept->hasMappingNegation();
queryProcessing |= checkEntailmentConceptSubClassAxiom(subConcept, subConNegation, superConcept, superConNegation, queryProcessingData, answererContext);
}
}
QHash varSuperClassRestrictionExpHash;
QHash varSubClassRestrictionExpHash;
QHash varSubVarSuperRestHash;
for (CExpressionVariable* varExp : varExpSet) {
for (CAxiomExpression* assExp : assExpsVarList) {
CSubClassOfExpression* subClasOfAssExp = dynamic_cast(assExp);
if (subClasOfAssExp) {
CClassVariableExpression* subClassVarExp = dynamic_cast(subClasOfAssExp->getFirstClassTermExpression());
CClassVariableExpression* superClassVarExp = dynamic_cast(subClasOfAssExp->getSecondClassTermExpression());
if (subClassVarExp && !superClassVarExp) {
varSuperClassRestrictionExpHash.insertMulti(subClassVarExp, subClasOfAssExp->getSecondClassTermExpression());
}
if (!subClassVarExp && superClassVarExp) {
varSubClassRestrictionExpHash.insertMulti(superClassVarExp, subClasOfAssExp->getFirstClassTermExpression());
}
if (varExp == subClassVarExp && subClassVarExp && superClassVarExp) {
varSubVarSuperRestHash.insertMulti(subClassVarExp, superClassVarExp);
}
}
}
}
mTestingOntologyBuilder->initializeBuilding();
for (CExpressionVariable* varExp : varExpSet) {
QList superClassRestrictionExps = varSuperClassRestrictionExpHash.values(varExp);
QList subClassRestrictionExps = varSubClassRestrictionExpHash.values(varExp);
if (!superClassRestrictionExps.isEmpty()) {
QList instTestingExpList;
CBuildExpression* instTestingExp = nullptr;
for (CBuildExpression* superClassExp : superClassRestrictionExps) {
instTestingExpList.append(mTestingOntologyBuilder->rebuildExpression(superClassExp));
}
if (instTestingExpList.size() > 1) {
instTestingExp = mTestingOntologyBuilder->getObjectIntersectionOf(instTestingExpList);
varSuperClassRestrictionExpHash.insert(varExp, instTestingExp);
}
}
if (!subClassRestrictionExps.isEmpty()) {
QList instTestingExpList;
CBuildExpression* instTestingExp = nullptr;
for (CBuildExpression* subClassExp : subClassRestrictionExps) {
instTestingExpList.append(mTestingOntologyBuilder->rebuildExpression(subClassExp));
}
if (instTestingExpList.size() > 1) {
instTestingExp = mTestingOntologyBuilder->getObjectIntersectionOf(instTestingExpList);
varSubClassRestrictionExpHash.insert(varExp, instTestingExp);
}
}
}
mTestingOntologyBuilder->completeBuilding();
mTestingOntologyPreprocessor->preprocess(testingOnto, testingOnto->getConfiguration());
COptimizedComplexBuildingClassVariableCompositionsItem* varBuildItem = new COptimizedComplexBuildingClassVariableCompositionsItem(queryProcessingData);
for (CExpressionVariable* varExp : varExpSet) {
CBuildExpression* superClassRestrictionExp = varSuperClassRestrictionExpHash.value(varExp);
CBuildExpression* subClassRestrictionExp = varSubClassRestrictionExpHash.value(varExp);
if (superClassRestrictionExp) {
CConcept* superResConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value((CClassTermExpression*)superClassRestrictionExp);
bool superResConceptNegation = superResConcept->hasMappingNegation();
COptimizedComplexConceptItem* assocConceptItem = nullptr;
queryProcessing |= initializeComplexConceptQueryProcessing(nullptr, varBuildItem, superResConcept, superResConceptNegation, false, false, true, false, false, 0, &assocConceptItem);
varBuildItem->addVariableComplexSuperConceptItem((CClassVariableExpression*)varExp, assocConceptItem);
}
if (subClassRestrictionExp) {
CConcept* subResConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value((CClassTermExpression*)subClassRestrictionExp);
bool subResConceptNegation = subResConcept->hasMappingNegation();
COptimizedComplexConceptItem* assocConceptItem = nullptr;
queryProcessing |= initializeComplexConceptQueryProcessing(nullptr, varBuildItem, subResConcept, subResConceptNegation, false, true, false, false, false, 0, &assocConceptItem);
varBuildItem->addVariableComplexSubConceptItem((CClassVariableExpression*)varExp, assocConceptItem);
}
QList superVarList = varSubVarSuperRestHash.values(varExp);
for (CExpressionVariable* superVarExp : superVarList) {
varBuildItem->addVariableSubSuperPropagation(varExp, superVarExp);
}
}
queryProcessingData->setVariableBuildingItem(varBuildItem);
queryProcessingData->incBuildingVariableItem();
if (!queryProcessing) {
varBuildItem->setProcessingQueued(true);
mOntoAnsweringItem->addProcessingVariableBuildingItem(varBuildItem);
queryProcessing = true;
}
return varBuildItem;
}
COptimizedComplexBuildingIndividualMixedVariableCompositionsItem* COptimizedComplexExpressionAnsweringHandler::initComplexAxiomsIndividualMixedVariablesQuery(CComplexAxiomsIndividualMixedVariablesAnsweringQuery* compAxIndMixedVarQuery, CAnswererContext* answererContext, CComplexQueryExpressionProcessingData* queryProcessingData, bool &queryCompleted, CConcreteOntology* testingOnto, bool &queryProcessing) {
QList axExps = *compAxIndMixedVarQuery->getAxiomExpressions();
QList* disVarList = compAxIndMixedVarQuery->getDistinguishedVariableExpressions();
QSet disVarSet = disVarList->toSet();
COptimizedComplexBuildingIndividualMixedVariableCompositionsItem* varBuildItem = new COptimizedComplexBuildingIndividualMixedVariableCompositionsItem(queryProcessingData);
bool unsupportedWarning = false;
QList propExtSubQueryPropAssList;
QList subQueryIndiAssExps;
QList subQueryClassAxExps;
QList subQueryDisjClassAxExps;
QSet extensionIndiVarExpSet;
QSet extensionClassVarExpSet;
QSet extensionPropertyVarExpSet;
QSet subQueryIndiVarExpSet;
QHash varExpOccurenceCountHash;
QList propExtSingleOccCheckingPropAssList;
for (CAxiomExpression* assExp : axExps) {
bool supported = false;
bool assertionAxiom = false;
CSubClassOfExpression* subClassAxExp = dynamic_cast(assExp);
if (subClassAxExp) {
supported = true;
subQueryClassAxExps.append(subClassAxExp);
}
//CEquivalentClassesExpression* eqClassAxExp = dynamic_cast(assExp);
//if (eqClassAxExp) {
// supported = true;
// subQueryClassAxExps.append(eqClassAxExp);
//}
CSubObjectPropertyOfExpression* subPropAxExp = dynamic_cast(assExp);
if (subPropAxExp) {
CEXPRESSIONLIST* subObjPropList = subPropAxExp->getSubObjectPropertyTermExpressionList();
if (subObjPropList->size() == 1) {
supported = true;
propExtSubQueryPropAssList.append(subPropAxExp);
}
}
CClassAssertionExpression* classAssExp = dynamic_cast(assExp);
if (classAssExp) {
CIndividualVariableExpression* indiVarExp = dynamic_cast(classAssExp->getIndividualTermExpression());
CClassVariableExpression* classVarExp = dynamic_cast(classAssExp->getClassTermExpression());
if (indiVarExp) {
varExpOccurenceCountHash[indiVarExp]++;
}
if (classVarExp) {
varExpOccurenceCountHash[classVarExp]++;
}
if (indiVarExp && classVarExp) {
extensionIndiVarExpSet.insert(indiVarExp);
extensionClassVarExpSet.insert(classVarExp);
varBuildItem->addIndividualVariableTypeVariableExtension(indiVarExp, classVarExp);
supported = true;
} else if (!classVarExp) {
assertionAxiom = true;
supported = true;
subQueryIndiAssExps.append(classAssExp);
if (indiVarExp) {
subQueryIndiVarExpSet.insert(indiVarExp);
}
}
}
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(assExp);
if (propAssExp) {
bool hasVariable = false;
CIndividualVariableExpression* firstVarExp = dynamic_cast(propAssExp->getFirstIndividualTermExpression());
CIndividualVariableExpression* secondVarExp = dynamic_cast(propAssExp->getSecondIndividualTermExpression());
CPropertyVariableExpression* propVarExp = dynamic_cast(propAssExp->getObjectPropertyTermExpression());
if (firstVarExp) {
varExpOccurenceCountHash[firstVarExp]++;
}
if (secondVarExp) {
varExpOccurenceCountHash[secondVarExp]++;
}
if (propVarExp) {
varExpOccurenceCountHash[propVarExp]++;
}
if (!propVarExp) {
assertionAxiom = true;
supported = true;
subQueryIndiAssExps.append(propAssExp);
if (firstVarExp) {
subQueryIndiVarExpSet.insert(firstVarExp);
}
if (secondVarExp) {
subQueryIndiVarExpSet.insert(secondVarExp);
}
} else if (propVarExp && firstVarExp && secondVarExp) {
if (compAxIndMixedVarQuery->isDistinctRequired() && (!disVarSet.contains(secondVarExp) || !disVarSet.contains(firstVarExp))) {
propExtSingleOccCheckingPropAssList.append(propAssExp);
supported = true;
}
}
}
CDataPropertyAssertionExpression* dataPropAssExp = dynamic_cast(assExp);
if (dataPropAssExp) {
assertionAxiom = true;
bool hasVariable = false;
CIndividualVariableExpression* indiVarExp = dynamic_cast(dataPropAssExp->getIndividualTermExpression());
CDataLiteralVariableExpression* dataVarExp = dynamic_cast(dataPropAssExp->getDataLiteralTermExpression());
CPropertyVariableExpression* propVarExp = dynamic_cast(dataPropAssExp->getDataPropertyTermExpression());
if (indiVarExp) {
varExpOccurenceCountHash[indiVarExp]++;
}
if (dataVarExp) {
varExpOccurenceCountHash[dataVarExp]++;
}
if (propVarExp) {
varExpOccurenceCountHash[propVarExp]++;
}
if (!propVarExp) {
assertionAxiom = true;
supported = true;
subQueryIndiAssExps.append(dataPropAssExp);
if (indiVarExp) {
subQueryIndiVarExpSet.insert(indiVarExp);
}
if (dataVarExp) {
subQueryIndiVarExpSet.insert(dataVarExp);
}
}
}
if (!supported) {
if (!unsupportedWarning) {
LOG(WARN, getDomain(), logTr("Query uses unsupported axiom types, which will be ignored."), this);
}
unsupportedWarning = true;
}
}
for (CObjectPropertyAssertionExpression* propAssExp : propExtSingleOccCheckingPropAssList) {
bool supported = true;
CIndividualVariableExpression* firstVarExp = dynamic_cast(propAssExp->getFirstIndividualTermExpression());
CIndividualVariableExpression* secondVarExp = dynamic_cast(propAssExp->getSecondIndividualTermExpression());
CPropertyVariableExpression* propVarExp = dynamic_cast(propAssExp->getObjectPropertyTermExpression());
CIndividualVariableExpression* indiVarExp = nullptr;
if (varExpOccurenceCountHash[firstVarExp] > 1) {
indiVarExp = firstVarExp;
} else {
indiVarExp = secondVarExp;
}
if (varExpOccurenceCountHash[firstVarExp] > 1 && varExpOccurenceCountHash[secondVarExp] > 1) {
supported = false;
} else {
extensionIndiVarExpSet.insert(indiVarExp);
extensionPropertyVarExpSet.insert(propVarExp);
varBuildItem->addIndividualVariablePropertyVariableExtension(indiVarExp, propVarExp);
}
if (!supported) {
if (!unsupportedWarning) {
LOG(WARN, getDomain(), logTr("Query uses unsupported axiom types, which will be ignored."), this);
}
unsupportedWarning = true;
}
}
if (subQueryIndiAssExps.isEmpty() && !extensionIndiVarExpSet.isEmpty()) {
mTestingOntologyBuilder->initializeBuilding();
CClassTermExpression* topClassExp = mOntoAnsweringItem->getTestingOntology(false)->getBuildData()->getTopClassExpression();
CIndividualVariableExpression* indiVarExp = (CIndividualVariableExpression*)*extensionIndiVarExpSet.begin();
CAxiomExpression* axiom = mTestingOntologyBuilder->getClassAssertion(indiVarExp, topClassExp);
mTestingOntologyBuilder->completeBuilding();
subQueryIndiAssExps.append(axiom);
}
if (!subQueryIndiAssExps.isEmpty()) {
QList subQueryDisIndiVarList;
for (CExpressionVariable* varExp : subQueryIndiVarExpSet) {
if (disVarSet.contains(varExp) || extensionIndiVarExpSet.contains(varExp)) {
subQueryDisIndiVarList.append(varExp);
}
}
CComplexAssertionsIndividualVariablesAnsweringQuery* subIndiVarQuery = new CComplexAssertionsIndividualVariablesAnsweringQuery(mOntoAnsweringItem->getOntology(), testingOnto, subQueryIndiAssExps, subQueryDisIndiVarList, mOntoAnsweringItem->getCalculationConfiguration(), compAxIndMixedVarQuery->getQueryName() + "-Assertion-Individual-Sub-Variables-Query");
bool subQueryCompleted = false;
bool subQueryProcessing = false;
COptimizedComplexBuildingIndividualVariableCompositionsItem* subQueryIndiBuildItem = initComplexAssertionsIndividualVariablesQuery(subIndiVarQuery, answererContext, queryProcessingData, subQueryCompleted, testingOnto, subQueryProcessing, true);
varBuildItem->addIndividualVariableSubQueryItem(subIndiVarQuery, subQueryIndiBuildItem);
if (!subQueryCompleted) {
CComputedItemDataNotificationLinker* notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
notLinker->setBuildingVariableItemProcessingItem(varBuildItem);
subQueryIndiBuildItem->addNotificationLinker(notLinker);
varBuildItem->incWaitingSubVariableBuildingItemCount();
}
if (subQueryProcessing) {
queryProcessing = true;
}
cint64 classSubQueryId = 0;
function nextSubQueryClassAxExps, QList subQueryDisClassVarList, QSet handledVarExpSet)> classSubQueryHandlerFunc = [&](QSet nextSubQueryClassAxExps, QList subQueryDisClassVarList, QSet handledVarExpSet) {
CComplexAxiomsClassVariablesAnsweringQuery* subClassVarQuery = new CComplexAxiomsClassVariablesAnsweringQuery(mOntoAnsweringItem->getOntology(), testingOnto, nextSubQueryClassAxExps.toList(), subQueryDisClassVarList, mOntoAnsweringItem->getCalculationConfiguration(), QString("%1-Assertion-Class-Sub-Variables-Query-%1").arg(compAxIndMixedVarQuery->getQueryName()).arg(classSubQueryId++));
bool classSubQueryCompleted = false;
bool classSubQueryProcessing = false;
COptimizedComplexBuildingClassVariableCompositionsItem* subQueryClassBuildItem = initComplexAxiomsClassVariablesQuery(subClassVarQuery, answererContext, queryProcessingData, classSubQueryCompleted, testingOnto, classSubQueryProcessing);
varBuildItem->addClassVariableSubQueryItem(subClassVarQuery, subQueryClassBuildItem);
for (CExpressionVariable* varExp : handledVarExpSet) {
varBuildItem->setExtensionClassVariableSubQueryBuildingItem((CClassVariableExpression*)varExp, subQueryClassBuildItem);
}
if (!classSubQueryCompleted) {
CComputedItemDataNotificationLinker* notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
notLinker->setBuildingVariableItemProcessingItem(varBuildItem);
subQueryClassBuildItem->addNotificationLinker(notLinker);
varBuildItem->incWaitingSubVariableBuildingItemCount();
}
if (classSubQueryProcessing) {
queryProcessing = true;
}
};
createIndividualMixedVariableConnectedSplitSubQueries(extensionClassVarExpSet, subQueryClassAxExps, disVarSet, extensionIndiVarExpSet, classSubQueryHandlerFunc);
cint64 propertySubQueryId = 0;
function nextSubQueryPropertyAxExps, QList subQueryDisClassVarList, QSet handledVarExpSet)> propertySubQueryHandlerFunc = [&](QSet nextSubQueryPropertyAxExps, QList subQueryDisClassVarList, QSet handledVarExpSet) {
CComplexAxiomsObjectPropertyVariablesAnsweringQuery* subPropertyVarQuery = new CComplexAxiomsObjectPropertyVariablesAnsweringQuery(mOntoAnsweringItem->getOntology(), testingOnto, nextSubQueryPropertyAxExps.toList(), subQueryDisClassVarList, mOntoAnsweringItem->getCalculationConfiguration(), QString("%1-Assertion-Property-Sub-Variables-Query-%1").arg(compAxIndMixedVarQuery->getQueryName()).arg(classSubQueryId++));
bool classSubQueryCompleted = false;
bool classSubQueryProcessing = false;
COptimizedComplexBuildingPropertyVariableCompositionsItem* subQueryPropertyBuildItem = initComplexAxiomsObjectPropertyVariablesQuery(subPropertyVarQuery, answererContext, queryProcessingData, classSubQueryCompleted, testingOnto, classSubQueryProcessing);
varBuildItem->addPropertyVariableSubQueryItem(subPropertyVarQuery, subQueryPropertyBuildItem);
for (CExpressionVariable* varExp : handledVarExpSet) {
varBuildItem->setExtensionPropertyVariableSubQueryBuildingItem((CPropertyVariableExpression*)varExp, subQueryPropertyBuildItem);
}
if (!classSubQueryCompleted) {
CComputedItemDataNotificationLinker* notLinker = mOntoAnsweringItem->createComputedItemDataNotificationLinker();
notLinker->setBuildingVariableItemProcessingItem(varBuildItem);
subQueryPropertyBuildItem->addNotificationLinker(notLinker);
varBuildItem->incWaitingSubVariableBuildingItemCount();
}
if (classSubQueryProcessing) {
queryProcessing = true;
}
};
createIndividualMixedVariableConnectedSplitSubQueries(extensionPropertyVarExpSet, propExtSubQueryPropAssList, disVarSet, extensionIndiVarExpSet, propertySubQueryHandlerFunc);
queryProcessingData->incBuildingVariableItem();
queryProcessingData->setVariableBuildingItem(varBuildItem);
if (!queryProcessing) {
mOntoAnsweringItem->addProcessingVariableBuildingItem(varBuildItem);
varBuildItem->setProcessingQueued(true);
}
}
return varBuildItem;
}
void COptimizedComplexExpressionAnsweringHandler::createIndividualMixedVariableConnectedSplitSubQueries(QSet extensionVarExpSet, QList subQueryAxExps, QSet &disVarSet, QSet &extensionIndiVarExpSet, function nextSubQueryClassAxExps, QList subQueryDisClassVarList, QSet handledVarExpSet)> subQueryHandlerFunc) {
QSet handledExtensionVarExpSet;
for (CExpressionVariable* extVarExp : extensionVarExpSet) {
if (!handledExtensionVarExpSet.contains(extVarExp)) {
QSet handledVarExpSet;
QList handlingVarExpList;
handlingVarExpList.append(extVarExp);
handledVarExpSet.insert(extVarExp);
QSet nextSubQueryAxExps;
while (!handlingVarExpList.isEmpty()) {
CExpressionVariable* handleIndiVar = handlingVarExpList.takeFirst();
for (CAxiomExpression* subQuAx : subQueryAxExps) {
if (!nextSubQueryAxExps.contains(subQuAx)) {
CSubClassOfExpression* subClassAxExp = dynamic_cast(subQuAx);
if (subClassAxExp) {
CClassVariableExpression* firstClassVarExp = dynamic_cast(subClassAxExp->getFirstClassTermExpression());
CClassVariableExpression* secondClassVarExp = dynamic_cast(subClassAxExp->getSecondClassTermExpression());
if (handledVarExpSet.contains(firstClassVarExp) || handledVarExpSet.contains(secondClassVarExp)) {
nextSubQueryAxExps.insert(subClassAxExp);
if (firstClassVarExp && !handledVarExpSet.contains(firstClassVarExp)) {
handledVarExpSet.insert(firstClassVarExp);
handlingVarExpList.append(firstClassVarExp);
}
if (secondClassVarExp && !handledVarExpSet.contains(secondClassVarExp)) {
handledVarExpSet.insert(secondClassVarExp);
handlingVarExpList.append(secondClassVarExp);
}
}
}
CSubObjectPropertyOfExpression* subPropAxExp = dynamic_cast(subQuAx);
if (subPropAxExp) {
CEXPRESSIONLIST* subObjPropList = subPropAxExp->getSubObjectPropertyTermExpressionList();
if (subObjPropList->size() == 1) {
CObjectPropertyVariableExpression* subObjPropVarExp = dynamic_cast(subObjPropList->first());
CObjectPropertyVariableExpression* superObjPropVarExp = dynamic_cast(subPropAxExp->getSuperObjectPropertyTermExpression());
if (handledVarExpSet.contains(subObjPropVarExp) || handledVarExpSet.contains(superObjPropVarExp)) {
nextSubQueryAxExps.insert(subPropAxExp);
if (subObjPropVarExp && !handledVarExpSet.contains(subObjPropVarExp)) {
handledVarExpSet.insert(subObjPropVarExp);
handlingVarExpList.append(subObjPropVarExp);
}
if (superObjPropVarExp && !handledVarExpSet.contains(superObjPropVarExp)) {
handledVarExpSet.insert(superObjPropVarExp);
handlingVarExpList.append(superObjPropVarExp);
}
}
}
}
}
}
}
if (!nextSubQueryAxExps.isEmpty()) {
QList subQueryDisVarList;
for (CExpressionVariable* varExp : extensionVarExpSet) {
if (handledVarExpSet.contains(varExp) && (disVarSet.contains(varExp) || extensionIndiVarExpSet.contains(varExp))) {
subQueryDisVarList.append(varExp);
}
}
subQueryHandlerFunc(nextSubQueryAxExps, subQueryDisVarList, handledVarExpSet);
}
}
}
}
COptimizedComplexBuildingIndividualVariableCompositionsItem* COptimizedComplexExpressionAnsweringHandler::initComplexAssertionsIndividualVariablesQuery(CComplexAssertionsIndividualVariablesAnsweringQuery* compAssIndVarQuery, CAnswererContext* answererContext, CComplexQueryExpressionProcessingData* queryProcessingData, bool &queryCompleted, CConcreteOntology* testingOnto, bool &queryProcessing, bool forceBuildingItem) {
QList assExps = *compAssIndVarQuery->getAxiomExpressions();
QList* disVarList = compAssIndVarQuery->getDistinguishedVariableExpressions();
QSet varExpSet;
QList classAssExpsEntList;
QList compClassAssExpsEntList;
QList roleAssExpsEntList;
QList dataRoleAssExpsEntList;
QList assExpsVarList;
CExpressionVariable* lastVarExpression = nullptr;
QSet answerIndiVariableSet(disVarList->toSet());
bool nonInstantiatedTerm = false;
if (mConfUnsatisfiableNonInstanceStatisticsChecking) {
nonInstantiatedTerm = identifyNonInstantiation(assExps, answerIndiVariableSet, answererContext);
}
if (nonInstantiatedTerm) {
finishQueryProcessingAsUnsatisfaible(queryProcessingData);
queryCompleted = true;
} else {
if (mConfInterpretQueriesAsDistinct) {
compAssIndVarQuery->setDistinctRequired(true);
}
if (mConfRedundantTermReduction) {
cint64 prevCount = assExps.count();
assExps = eliminateRedundantQueryTerms(assExps, queryProcessingData, answererContext);
cint64 newCount = assExps.count();
if (prevCount != newCount && mConfExtendedLogging) {
LOG(INFO, getDomain(), logTr("Eliminated %1 redundant query terms.").arg(prevCount - newCount), this);
}
}
for (CAxiomExpression* assExp : assExps) {
CClassAssertionExpression* classAssExp = dynamic_cast(assExp);
if (classAssExp) {
CIndividualVariableExpression* varExp = dynamic_cast(classAssExp->getIndividualTermExpression());
if (!varExp) {
if (classAssExp->getClassTermExpression()->getType() == CBuildExpression::BETCLASS) {
classAssExpsEntList.append(classAssExp);
} else {
compClassAssExpsEntList.append(classAssExp);
}
} else {
lastVarExpression = varExp;
assExpsVarList.append(classAssExp);
}
}
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(assExp);
if (propAssExp) {
bool hasVariable = false;
CIndividualVariableExpression* firstVarExp = dynamic_cast(propAssExp->getFirstIndividualTermExpression());
if (firstVarExp) {
hasVariable = true;
lastVarExpression = firstVarExp;
}
CIndividualVariableExpression* secondVarExp = dynamic_cast(propAssExp->getSecondIndividualTermExpression());
if (secondVarExp) {
hasVariable = true;
lastVarExpression = secondVarExp;
}
if (!hasVariable) {
roleAssExpsEntList.append(propAssExp);
} else {
assExpsVarList.append(propAssExp);
}
}
CDataPropertyAssertionExpression* dataPropAssExp = dynamic_cast(assExp);
if (dataPropAssExp) {
bool hasVariable = false;
CIndividualVariableExpression* indiVarExp = dynamic_cast(dataPropAssExp->getIndividualTermExpression());
if (indiVarExp) {
hasVariable = true;
lastVarExpression = indiVarExp;
}
CDataLiteralVariableExpression* dataVarExp = dynamic_cast(dataPropAssExp->getDataLiteralTermExpression());
if (dataVarExp) {
hasVariable = true;
lastVarExpression = dataVarExp;
}
if (!hasVariable) {
dataRoleAssExpsEntList.append(dataPropAssExp);
} else {
assExpsVarList.append(dataPropAssExp);
}
}
}
QList dataLitCompFilterList;
for (CVariableBindingFiltering* filteringLinker = compAssIndVarQuery->getResultFilteringLinker(); filteringLinker; filteringLinker = filteringLinker->getNext()) {
CVariableBindingFilteringLiteralComparison* dataLiteralCompFilter = dynamic_cast(filteringLinker);
if (dataLiteralCompFilter && !dataLiteralCompFilter->getDataLiteral()) {
dataLitCompFilterList.append(dataLiteralCompFilter);
}
}
if (!classAssExpsEntList.isEmpty() || !compClassAssExpsEntList.isEmpty() || !roleAssExpsEntList.isEmpty() || !dataRoleAssExpsEntList.isEmpty() || !dataLitCompFilterList.isEmpty()) {
QList> indClassInstTestExpList;
QList> dataFilterDataLiteralExpList;
if (!compClassAssExpsEntList.isEmpty() || !dataRoleAssExpsEntList.isEmpty() || !dataLitCompFilterList.isEmpty()) {
mTestingOntologyBuilder->initializeBuilding();
for (CClassAssertionExpression* assExp : compClassAssExpsEntList) {
CClassTermExpression* classTermExp = assExp->getClassTermExpression();
indClassInstTestExpList.append(QPair((CClassTermExpression*)mTestingOntologyBuilder->rebuildExpression(classTermExp), assExp->getIndividualTermExpression()));
}
for (CDataPropertyAssertionExpression* dataRoleAssExp : dataRoleAssExpsEntList) {
CDataPropertyTermExpression* dataPropTermExp = dataRoleAssExp->getDataPropertyTermExpression();
CIndividualTermExpression* indiTermExp = dataRoleAssExp->getIndividualTermExpression();
CDataLiteralExpression* dataLiteralExp = (CDataLiteralExpression*)dataRoleAssExp->getDataLiteralTermExpression();
dataLiteralExp = (CDataLiteralExpression*)mTestingOntologyBuilder->rebuildExpression(dataLiteralExp);
indClassInstTestExpList.append(QPair(mTestingOntologyBuilder->getDataHasValue(dataPropTermExp, dataLiteralExp), indiTermExp));
}
for (CVariableBindingFilteringLiteralComparison* dataLiteralCompFilter : dataLitCompFilterList) {
CDataLiteralExpression* dataLitExp = dataLiteralCompFilter->getDataLiteralExpression();
dataLitExp = (CDataLiteralExpression*)mTestingOntologyBuilder->rebuildExpression(dataLitExp);
dataFilterDataLiteralExpList.append(QPair(dataLiteralCompFilter, dataLitExp));
}
mTestingOntologyBuilder->completeBuilding();
mTestingOntologyPreprocessor->preprocess(testingOnto, testingOnto->getConfiguration());
}
if (!dataFilterDataLiteralExpList.isEmpty()) {
CPreProcessContextBase preprocessingContext(mOntoAnsweringItem->getTestingOntology(), mOntoAnsweringItem->getTestingOntology()->getConfiguration());
CDataLiteralNormalizerPreProcess dataLitNormalizer;
for (QPair dataFilterDataLiteralExpPair : dataFilterDataLiteralExpList) {
CVariableBindingFilteringLiteralComparison* dataLiteralCompFilter = dataFilterDataLiteralExpPair.first;
CDataLiteralExpression* dataLitExp = dataFilterDataLiteralExpPair.second;
CConcept* dataConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getDataRangeTermConceptMappingHash()->value(dataLitExp);
CDataLiteral* dataLiteral = dataConcept->getDataLiteral();
if (dataLiteral) {
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLitNormalizer.preprocessDataConcept(dataConcept, mOntoAnsweringItem->getTestingOntology(), &preprocessingContext);
}
dataLiteralCompFilter->setDataLiteral(dataLiteral);
}
}
}
if (!classAssExpsEntList.isEmpty()) {
for (CClassAssertionExpression* assExp : classAssExpsEntList) {
indClassInstTestExpList.append(QPair(assExp->getClassTermExpression(), assExp->getIndividualTermExpression()));
}
}
for (QPair classIndiPair : indClassInstTestExpList) {
CClassTermExpression* classTermExp = classIndiPair.first;
CIndividualTermExpression* indiTermExp = classIndiPair.second;
CConcept* testingConcept = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value(classTermExp);
CIndividual* testingIndividual = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getIndividulTermIndiMappingHash()->value(indiTermExp);
bool testingNegation = testingConcept->hasMappingNegation();
queryProcessing |= checkEntailmentConceptAssertion(testingConcept, testingNegation, testingIndividual, queryProcessingData, answererContext);
}
for (CObjectPropertyAssertionExpression* roleAssExp : roleAssExpsEntList) {
CObjectPropertyTermExpression* objPropTermExp = roleAssExp->getObjectPropertyTermExpression();
CIndividualTermExpression* indiSourceTermExp = roleAssExp->getFirstIndividualTermExpression();
CIndividualTermExpression* indiDestTermExp = roleAssExp->getSecondIndividualTermExpression();
bool inversed = false;
while (objPropTermExp->getType() == CBuildExpression::BETINVERSEOBJECTPROPERTYOF) {
CInverseObjectPropertyOfExpression* invPropExp = (CInverseObjectPropertyOfExpression*)objPropTermExp;
objPropTermExp = invPropExp->getInverseOfExpression();
inversed = !inversed;
}
if (inversed) {
CIndividualTermExpression* indiTermExp = indiSourceTermExp;
indiSourceTermExp = indiDestTermExp;
indiDestTermExp = indiTermExp;
}
CRole* testingRole = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value(objPropTermExp);
CIndividual* testingIndividualSource = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getIndividulTermIndiMappingHash()->value(indiSourceTermExp);
CIndividual* testingIndividualDestination = mOntoAnsweringItem->getTestingOntology()->getDataBoxes()->getExpressionDataBoxMapping()->getIndividulTermIndiMappingHash()->value(indiDestTermExp);
queryProcessing |= checkEntailmentRoleAssertion(testingRole, testingIndividualSource, testingIndividualDestination, queryProcessingData, answererContext);
}
}
for (CAxiomExpression* assExp : assExpsVarList) {
CClassAssertionExpression* classAssExp = dynamic_cast(assExp);
if (classAssExp) {
CIndividualVariableExpression* varExp = dynamic_cast(classAssExp->getIndividualTermExpression());
if (varExp) {
varExpSet.insert(varExp);
}
}
CObjectPropertyAssertionExpression* propAssExp = dynamic_cast(assExp);
if (propAssExp) {
CIndividualVariableExpression* firstVarExp = dynamic_cast(propAssExp->getFirstIndividualTermExpression());
if (firstVarExp) {
varExpSet.insert(firstVarExp);
}
CIndividualVariableExpression* secondVarExp = dynamic_cast(propAssExp->getSecondIndividualTermExpression());
if (secondVarExp) {
varExpSet.insert(secondVarExp);
}
}
CDataPropertyAssertionExpression* dataPropAssExp = dynamic_cast(assExp);
if (dataPropAssExp) {
CIndividualVariableExpression* indiVarExp = dynamic_cast(dataPropAssExp->getIndividualTermExpression());
if (indiVarExp) {
varExpSet.insert(indiVarExp);
}
CDataLiteralVariableExpression* dataVarExp = dynamic_cast(dataPropAssExp->getDataLiteralTermExpression());
if (dataVarExp) {
varExpSet.insert(dataVarExp);
}
}
}
QSet initialAnonymousIndiVariableSet;
for (CExpressionVariable* varExp : varExpSet) {
CIndividualVariableExpression* indiVarExp = dynamic_cast(varExp);
if (indiVarExp && indiVarExp->isAnonymousVariable()) {
initialAnonymousIndiVariableSet.insert(varExp);
}
if (indiVarExp && mConfInterpretNonAnswerIndividualVariablesAsAnonymousVariables && !answerIndiVariableSet.contains(varExp)) {
if (varExp->getName().startsWith(mConfNonAnswerIndividualVariablesAsAnonymousVariablesInterpretingPrefixString)) {
initialAnonymousIndiVariableSet.insert(varExp);
}
}
}
bool distinct = compAssIndVarQuery->isDistinctRequired();
QSet anonymousIndiVariableSet(initialAnonymousIndiVariableSet);
QSet nonEliminatableIndiVariableSet(answerIndiVariableSet);
if (!distinct) {
for (CExpressionVariable* varExp : varExpSet) {
if (!anonymousIndiVariableSet.contains(varExp) && !answerIndiVariableSet.contains(varExp)) {
nonEliminatableIndiVariableSet.insert(varExp);
}
}
}
QList