Debian Codegraph @

Source/Reasoner/Generator/CConcreteOntologyQueryExtendedBuilder.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CConcreteOntologyQueryExtendedBuilder.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Generator {
29
30
31 CConcreteOntologyQueryExtendedBuilder::CConcreteOntologyQueryExtendedBuilder(CConcreteOntology* baseOntology, CConcreteOntology* ontology, CConfigurationBase *configuration, COntologyBuilder* ontologyBuilder)
32 : CConcreteOntologyQueryBasicBuilder(ontology,configuration) {
33
34 mBaseOntology = baseOntology;
35 mOntologyBuilder = ontologyBuilder;
36 }
37
38
39
40 CConcreteOntologyQueryExtendedBuilder::~CConcreteOntologyQueryExtendedBuilder() {
41 qDeleteAll(mExpContainer);
42 }
43
44
45
46 CQueryIsEntailedExpression* CConcreteOntologyQueryExtendedBuilder::getIsEntailedQuery(const CEXPRESSIONLIST<CAxiomExpression*>& testAxiomExpressions, const QString& queryName) {
47 CQueryIsEntailedExpression *classEqExp = new CQueryIsEntailedExpression(queryName,testAxiomExpressions);
48 for (CEXPRESSIONLIST<CAxiomExpression*>::const_iterator axiomIt = testAxiomExpressions.constBegin(), axiomEndIt = testAxiomExpressions.constEnd(); axiomIt != axiomEndIt; ++axiomIt) {
49 CAxiomExpression* axiom = *axiomIt;
50 bool queryForAxiomCreated = false;
51
52 CSubClassOfExpression* subClassAxiom = dynamic_cast<CSubClassOfExpression*>(axiom);
53 if (subClassAxiom) {
54 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom);
55 CClassTermExpression* subClassExp = subClassAxiom->getSubClassTermExpression();
56 CClassTermExpression* superClassExp = subClassAxiom->getSuperClassTermExpression();
57 CClassTermExpression* negSuperClassExp = mOntologyBuilder->getObjectComplementOf(superClassExp);
58 CClassTermExpression* buildExp = mOntologyBuilder->getObjectIntersectionOf(CEXPRESSIONLIST<CClassTermExpression*>()<<subClassExp<<negSuperClassExp);
59 entAxiomExpAss->addConstructedTestClass(buildExp);
60 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
61 queryForAxiomCreated = true;
62 }
63
64 CEquivalentClassesExpression* equivClassAxiom = dynamic_cast<CEquivalentClassesExpression*>(axiom);
65 if (equivClassAxiom) {
66 CEXPRESSIONLIST<CClassTermExpression*>* equivClassesList = equivClassAxiom->getClassTermExpressionList();
67 CEXPRESSIONLIST<CClassTermExpression*>::const_iterator clItFirst = equivClassesList->constBegin();
68 CEXPRESSIONLIST<CClassTermExpression*>::const_iterator clItNext = clItFirst;
69 CEXPRESSIONLIST<CClassTermExpression*>::const_iterator clItLast = clItNext;
70 ++clItNext;
71 for (CEXPRESSIONLIST<CClassTermExpression*>::const_iterator clItEnd = equivClassesList->constEnd(); clItNext != clItEnd; ++clItNext) {
72 clItLast = clItNext;
73 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom);
74 CClassTermExpression* classExp1 = *clItLast;
75 CClassTermExpression* classExp2 = *clItNext;
76 CClassTermExpression* negSuperClassExp = mOntologyBuilder->getObjectComplementOf(classExp2);
77 CClassTermExpression* buildExp = mOntologyBuilder->getObjectIntersectionOf(CEXPRESSIONLIST<CClassTermExpression*>()<<classExp1<<negSuperClassExp);
78 entAxiomExpAss->addConstructedTestClass(buildExp);
79 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
80 }
81 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom);
82 CClassTermExpression* classExp1 = *clItLast;
83 CClassTermExpression* classExp2 = *clItFirst;
84 CClassTermExpression* negSuperClassExp = mOntologyBuilder->getObjectComplementOf(classExp2);
85 CClassTermExpression* buildExp = mOntologyBuilder->getObjectIntersectionOf(CEXPRESSIONLIST<CClassTermExpression*>()<<classExp1<<negSuperClassExp);
86 entAxiomExpAss->addConstructedTestClass(buildExp);
87 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
88 queryForAxiomCreated = true;
89 }
90
91 CObjectPropertyDomainExpression* objPropDomainAxiom = dynamic_cast<CObjectPropertyDomainExpression*>(axiom);
92 if (objPropDomainAxiom) {
93 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom);
94 CClassTermExpression* domainClassExp = objPropDomainAxiom->getClassTermExpression();
95 CObjectPropertyTermExpression* objPropExp = objPropDomainAxiom->getObjectPropertyTermExpression();
96 CClassTermExpression* negDomainClassExp = mOntologyBuilder->getObjectComplementOf(domainClassExp);
97 CClassTermExpression* topClassExp = mOntologyBuilder->getTopClass();
98 CClassTermExpression* someObjPropExp = mOntologyBuilder->getObjectSomeValuesFrom(objPropExp,topClassExp);
99 CClassTermExpression* buildExp = mOntologyBuilder->getObjectIntersectionOf(CEXPRESSIONLIST<CClassTermExpression*>()<<someObjPropExp<<negDomainClassExp);
100 entAxiomExpAss->addConstructedTestClass(buildExp);
101 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
102 queryForAxiomCreated = true;
103 }
104
105 CObjectPropertyRangeExpression* objPropRangeAxiom = dynamic_cast<CObjectPropertyRangeExpression*>(axiom);
106 if (objPropRangeAxiom) {
107 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom);
108 CClassTermExpression* rangeClassExp = objPropRangeAxiom->getClassTermExpression();
109 CObjectPropertyTermExpression* objPropExp = objPropRangeAxiom->getObjectPropertyTermExpression();
110 CClassTermExpression* negRangeClassExp = mOntologyBuilder->getObjectComplementOf(rangeClassExp);
111 CClassTermExpression* buildExp = mOntologyBuilder->getObjectSomeValuesFrom(objPropExp,negRangeClassExp);
112 entAxiomExpAss->addConstructedTestClass(buildExp);
113 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
114 queryForAxiomCreated = true;
115 }
116
117 CClassAssertionExpression* classAssAxiom = dynamic_cast<CClassAssertionExpression*>(axiom);
118 if (classAssAxiom) {
119 CEntailmentAxiomExpressionAssociation* entAxiomExpAss = new CEntailmentAxiomExpressionAssociation(axiom,CEntailmentAxiomExpressionAssociation::EAECTAXIOMSPESIFIC);
120 classEqExp->addConstructedTestAxiomExpressions(entAxiomExpAss);
121 queryForAxiomCreated = true;
122 }
123
124
125 if (!queryForAxiomCreated) {
126 LOG(ERROR,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Ignoring not supported axiom type for IsEntailed-Query '%1'.").arg(queryName),this);
127 }
128
129 }
130 container.append(classEqExp);
131 isEntailedExpList.append(classEqExp);
132 return classEqExp;
133 }
134
135
136
137 CQueryAreClassesEquivalentExpression *CConcreteOntologyQueryExtendedBuilder::getAreClassesEquivalenceQuery(const CEXPRESSIONLIST<CClassTermExpression*> &testClassExpressions, const QString& queryName) {
138 CQueryAreClassesEquivalentExpression *classEqExp = new CQueryAreClassesEquivalentExpression(queryName,testClassExpressions);
139 for (CEXPRESSIONLIST<CClassTermExpression*>::const_iterator it0 = testClassExpressions.constBegin(); it0 != testClassExpressions.constEnd(); ++it0) {
140 CEXPRESSIONLIST<CClassTermExpression*>::const_iterator it1 = it0;
141 if (++it1 == testClassExpressions.constEnd()) {
142 it1 = testClassExpressions.constBegin();
143 }
144 CClassTermExpression *buildExp1 = *it0;
145 CClassTermExpression *buildExp2 = *it1;
146 CClassTermExpression *compBuildExp1 = mOntologyBuilder->getObjectComplementOf(buildExp1);
147 CEXPRESSIONLIST<CClassTermExpression*> intersectExpressionsList;
148 intersectExpressionsList.append(compBuildExp1);
149 intersectExpressionsList.append(buildExp2);
150 CClassTermExpression *intersectionCompBuildExp1AndBuildExp2 = mOntologyBuilder->getObjectIntersectionOf(intersectExpressionsList);
151 classEqExp->addConstructedTestClass(intersectionCompBuildExp1AndBuildExp2);
152 }
153 container.append(classEqExp);
154 classEqExpList.append(classEqExp);
155 return classEqExp;
156 }
157
158
159 CQueryAreClassesDisjointExpression *CConcreteOntologyQueryExtendedBuilder::getAreClassesDisjointQuery(const CEXPRESSIONLIST<CClassTermExpression*> &testClassExpressions, const QString& queryName) {
160 CQueryAreClassesDisjointExpression *classEqExp = new CQueryAreClassesDisjointExpression(queryName,testClassExpressions);
161 for (CEXPRESSIONLIST<CClassTermExpression*>::const_iterator it0 = testClassExpressions.constBegin(); it0 != testClassExpressions.constEnd(); ++it0) {
162 for (CEXPRESSIONLIST<CClassTermExpression*>::const_iterator it1 = it0; it1 != testClassExpressions.constEnd(); ++it1) {
163 CClassTermExpression *buildExp1 = *it0;
164 CClassTermExpression *buildExp2 = *it1;
165 CEXPRESSIONLIST<CClassTermExpression*> intersectExpressionsList;
166 intersectExpressionsList.append(buildExp1);
167 intersectExpressionsList.append(buildExp2);
168 CClassTermExpression *intersectionBuildExp1AndBuildExp2 = mOntologyBuilder->getObjectIntersectionOf(intersectExpressionsList);
169 classEqExp->addConstructedTestClass(intersectionBuildExp1AndBuildExp2);
170 }
171 }
172 container.append(classEqExp);
173 classDisjointExpList.append(classEqExp);
174 return classEqExp;
175 }
176
177 CQueryIsClassSubsumedByExpression *CConcreteOntologyQueryExtendedBuilder::getIsClassSubsumedByQuery(CClassTermExpression* subsumerClassExpression, CClassTermExpression* subsumedClassExpression, const QString& queryName) {
178 CQueryIsClassSubsumedByExpression* classEqExp = new CQueryIsClassSubsumedByExpression(queryName,subsumerClassExpression,subsumedClassExpression);
179 CClassTermExpression *compBuildExp2 = mOntologyBuilder->getObjectComplementOf(subsumedClassExpression);
180 CEXPRESSIONLIST<CClassTermExpression*> intersectExpressionsList;
181 intersectExpressionsList.append(compBuildExp2);
182 intersectExpressionsList.append(subsumerClassExpression);
183 CClassTermExpression *intersectionBuildExp1AndCompBuildExp2 = mOntologyBuilder->getObjectIntersectionOf(intersectExpressionsList);
184 classEqExp->setConstructedTestClassExpression(intersectionBuildExp1AndCompBuildExp2);
185 container.append(classEqExp);
186 classSubsumedExpList.append(classEqExp);
187 return classEqExp;
188 }
189
190
191
192
193 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternClassSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, cint64 limit, cint64 offset, const QString& queryName) {
194 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, QList<CExpressionVariable*>(), false, limit, offset);
195 mSparqlClassSelectExpList.append(sparqlQuery);
196 return sparqlQuery;
197 }
198
199 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternObjectPropertiesSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, cint64 limit, cint64 offset, const QString& queryName) {
200 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, QList<CExpressionVariable*>(), false, limit, offset);
201 mSparqlObjPropSelectExpList.append(sparqlQuery);
202 return sparqlQuery;
203 }
204
205 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternDataPropertiesSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, cint64 limit, cint64 offset, const QString& queryName) {
206 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, QList<CExpressionVariable*>(), false, limit, offset);
207 mSparqlDataPropSelectExpList.append(sparqlQuery);
208 return sparqlQuery;
209 }
210
211
212
213 CQuerySPARQLAskBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternClassAskQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QString& queryName) {
214 CEXPRESSIONLIST<CFilteringTermExpression*> filteringList;
215 CQuerySPARQLAskBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLAskBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, filteringList);
216 mSparqlClassAskExpList.append(sparqlQuery);
217 return sparqlQuery;
218 }
219
220 CQuerySPARQLAskBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternObjectPropertiesAskQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QString& queryName) {
221 CEXPRESSIONLIST<CFilteringTermExpression*> filteringList;
222 CQuerySPARQLAskBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLAskBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, filteringList);
223 mSparqlObjectPropAskExpList.append(sparqlQuery);
224 return sparqlQuery;
225 }
226
227 CQuerySPARQLAskBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternDataPropertiesAskQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QString& queryName) {
228 CEXPRESSIONLIST<CFilteringTermExpression*> filteringList;
229 CQuerySPARQLAskBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLAskBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, filteringList);
230 mSparqlDataPropAskExpList.append(sparqlQuery);
231 return sparqlQuery;
232 }
233
234
235
236 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternIndividualSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, const QList<CExpressionVariable*>& ignoreCardVarList, bool distinctModifier, cint64 limit, cint64 offset, const QString& queryName) {
237 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, ignoreCardVarList, distinctModifier, limit, offset);
238 mSparqlIndividualSelectExpList.append(sparqlQuery);
239 return sparqlQuery;
240 }
241
242
243 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternIndividualSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, const CEXPRESSIONLIST<COrderingTermExpression*>& orderingList, const CEXPRESSIONLIST<CFilteringTermExpression*>& filteringList, bool distinctModifier, cint64 limit, cint64 offset, const QString& queryName) {
244 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, orderingList, filteringList, distinctModifier, limit, offset);
245 mSparqlIndividualSelectExpList.append(sparqlQuery);
246 return sparqlQuery;
247 }
248
249
250 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternIndividualSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, const CEXPRESSIONLIST<COrderingTermExpression*>& orderingList, const CEXPRESSIONLIST<CFilteringTermExpression*>& filteringList, bool distinctModifier, const QString& queryName) {
251 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, orderingList, filteringList, distinctModifier);
252 mSparqlIndividualSelectExpList.append(sparqlQuery);
253 return sparqlQuery;
254 }
255
256
257 CQuerySPARQLSelectBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternIndividualMixedSelectQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const QList<CExpressionVariable*>& disVarList, const QList<CExpressionVariable*>& ignoreCardVarList, bool distinctModifier, cint64 limit, cint64 offset, const QString& queryName) {
258 CQuerySPARQLSelectBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLSelectBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, disVarList, ignoreCardVarList, distinctModifier, limit, offset);
259 mSparqlIndividualMixedSelectExpList.append(sparqlQuery);
260 return sparqlQuery;
261 }
262
263 CQuerySPARQLAskBasicGraphPatternExpression* CConcreteOntologyQueryExtendedBuilder::getSPARQLBasicGraphPatternIndividualAskQuery(const QList<CAxiomExpression*>& basicGraphPatternAxiomExp, const CEXPRESSIONLIST<CFilteringTermExpression*>& filteringList, const QString& queryName) {
264 CQuerySPARQLAskBasicGraphPatternExpression* sparqlQuery = new CQuerySPARQLAskBasicGraphPatternExpression(queryName, basicGraphPatternAxiomExp, filteringList);
265 mSparqlIndividualAskExpList.append(sparqlQuery);
266 return sparqlQuery;
267 }
268
269
270
271 COrderingVariableExpression* CConcreteOntologyQueryExtendedBuilder::getOrderingVariableExpression(CExpressionVariable* variable, bool ascOrdering) {
272 COrderingVariableExpression::ORDERING_TYPE orderType = COrderingVariableExpression::ASC;
273 if (!ascOrdering) {
274 orderType = COrderingVariableExpression::DESC;
275 }
276 COrderingVariableExpression* orderingVarExp = new COrderingVariableExpression(variable, orderType);
277 mExpContainer.append(orderingVarExp);
278 return orderingVarExp;
279 }
280
281 CFilteringComparisonDataLiteralExpression* CConcreteOntologyQueryExtendedBuilder::getFilteringComparisonDataLiteralExpression(CDataLiteralVariableExpression* variable, CDataLiteralExpression* dataLiteralExp, CFilteringComparisonDataLiteralExpression::COMPARING_TYPE comparingType) {
282 CFilteringComparisonDataLiteralExpression* compDataLitExp = new CFilteringComparisonDataLiteralExpression(dataLiteralExp, variable, comparingType);
283 mExpContainer.append(compDataLitExp);
284 return compDataLitExp;
285 }
286
287
288
289
290
291 bool CConcreteOntologyQueryExtendedBuilder::requiresPreprocessedOntology() {
292 if (classEqExpList.isEmpty() && classDisjointExpList.isEmpty() && classSubsumedExpList.isEmpty() && isEntailedExpList.isEmpty()) {
293 return false;
294 }
295 return true;
296 }
297
298
299
300
301 CVariableBindingFiltering* CConcreteOntologyQueryExtendedBuilder::createFilterFromExpression(CFilteringTermExpression* filteringTermExpression) {
302 if (filteringTermExpression->getType() == CBuildExpression::BETFILTERINGCOMPARISONDATALITERAL) {
303 CFilteringComparisonDataLiteralExpression* compDataLitExp = (CFilteringComparisonDataLiteralExpression*)filteringTermExpression;
304 CDataLiteralExpression* dataLiteralExp = compDataLitExp->getComparingDataLiteral();
305 CDataLiteralVariableExpression* variable = compDataLitExp->getComparingDataLiteralVariable();
306 CVariableBindingFilteringLiteralComparison::COMPARING_TYPE type = CVariableBindingFilteringLiteralComparison::EQUAL;
307 if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::LESS_EQUAL) {
308 type = CVariableBindingFilteringLiteralComparison::LESS_EQUAL;
309 } else if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::LESS) {
310 type = CVariableBindingFilteringLiteralComparison::LESS;
311 } else if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::EQUAL) {
312 type = CVariableBindingFilteringLiteralComparison::EQUAL;
313 } else if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::UNEQUAL) {
314 type = CVariableBindingFilteringLiteralComparison::UNEQUAL;
315 } else if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::GREATER) {
316 type = CVariableBindingFilteringLiteralComparison::GREATER;
317 } else if (compDataLitExp->getComparingType() == CFilteringComparisonDataLiteralExpression::GREATER_EQUAL) {
318 type = CVariableBindingFilteringLiteralComparison::GREATER_EQUAL;
319 }
320 CVariableBindingFilteringLiteralComparison* filter = new CVariableBindingFilteringLiteralComparison(type, variable, dataLiteralExp);
321 return filter;
322 }
323 return nullptr;
324 }
325
326
327
328
329 QList<CQuery*> CConcreteOntologyQueryExtendedBuilder::generateQuerys() {
330 QList<CQuery*> queryList;
331
332 CSatisfiableCalculationJobGenerator* satCalcJobGenerator = new CSatisfiableCalculationJobGenerator(mOntology);
333
334 bool confBuildQueryStats = CConfigDataReader::readConfigBoolean(config,"Konclude.Query.Statistics.CollectStatistics",false);
335
336
337
338
339
340
341 foreach(CQueryIsClassSatisfiableExpression *classSatExp, classSatExpList) {
342 QString queryName = classSatExp->getName();
343 CClassTermExpression *satBuildExp = classSatExp->getClassTermExpression();
344
345 CComplexSatisfiabilityAnsweringQuery *query = new CComplexSatisfiabilityAnsweringQuery(mBaseOntology, mOntology, satBuildExp, config, queryName);
346 CQueryStatisticsCollectionStrings* queryStats = nullptr;
347 if (confBuildQueryStats) {
348 queryStats = new CQueryStatisticsCollectionStrings();
349 }
350 query->setQueryStatistics(queryStats);
351
352 queryList.append(query);
353 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated IsClassSatisfiable-Query '%1' with question '%2'.").arg(query->getQueryName()).arg(query->getQueryString()), this);
354 }
355
356
357
358
359
360
361
362
363 foreach(CQueryGetSuperClassesExpression* superClassesExp, mSuperClassesExpList) {
364 QString queryName = superClassesExp->getName();
365 CClassTermExpression* classBuildExp = superClassesExp->getClassTermExpression();
366
367 CComplexSuperClassesAnsweringQuery *query = new CComplexSuperClassesAnsweringQuery(mBaseOntology, mOntology, classBuildExp, config, queryName);
368 CQueryStatisticsCollectionStrings* queryStats = nullptr;
369 if (confBuildQueryStats) {
370 queryStats = new CQueryStatisticsCollectionStrings();
371 }
372 query->setQueryStatistics(queryStats);
373 query->setDirect(superClassesExp->isDirect());
374 queryList.append(query);
375 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-SuperClasses-Query '%1'.").arg(query->getQueryName()), this);
376 }
377
378
379
380
381
382 foreach(CQueryGetSubClassesExpression* subClassesExp, mSubClassesExpList) {
383 QString queryName = subClassesExp->getName();
384 CClassTermExpression* classBuildExp = subClassesExp->getClassTermExpression();
385
386 CComplexSubClassesAnsweringQuery *query = new CComplexSubClassesAnsweringQuery(mBaseOntology, mOntology, classBuildExp, config, queryName);
387 CQueryStatisticsCollectionStrings* queryStats = nullptr;
388 if (confBuildQueryStats) {
389 queryStats = new CQueryStatisticsCollectionStrings();
390 }
391 query->setQueryStatistics(queryStats);
392 query->setDirect(subClassesExp->isDirect());
393 queryList.append(query);
394 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-SubClasses-Query '%1'.").arg(query->getQueryName()), this);
395 }
396
397
398
399 foreach(CQueryGetEquivalentClassesExpression* eqClassesExp, mEquivClassesExpList) {
400 QString queryName = eqClassesExp->getName();
401 CClassTermExpression* classBuildExp = eqClassesExp->getClassTermExpression();
402
403 CComplexEquivalentClassesAnsweringQuery *query = new CComplexEquivalentClassesAnsweringQuery(mBaseOntology, mOntology, classBuildExp, config, queryName);
404 CQueryStatisticsCollectionStrings* queryStats = nullptr;
405 if (confBuildQueryStats) {
406 queryStats = new CQueryStatisticsCollectionStrings();
407 }
408 query->setQueryStatistics(queryStats);
409 queryList.append(query);
410 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-EquivalentClasses-Query '%1'.").arg(query->getQueryName()), this);
411 }
412
413 foreach(CQueryGetInstancesExpression* instancesExp, instancesExpList) {
414 QString queryName = instancesExp->getName();
415 CClassTermExpression* classBuildExp = instancesExp->getClassTermExpression();
416
417 CComplexIndividualInstancesAnsweringQuery *query = new CComplexIndividualInstancesAnsweringQuery(mBaseOntology, mOntology, classBuildExp, config, queryName);
418 CQueryStatisticsCollectionStrings* queryStats = nullptr;
419 if (confBuildQueryStats) {
420 queryStats = new CQueryStatisticsCollectionStrings();
421 }
422 query->setQueryStatistics(queryStats);
423 query->setDirect(instancesExp->isDirect());
424 query->setFlattened(false);
425 queryList.append(query);
426 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-Instances-Query '%1'.").arg(query->getQueryName()), this);
427 }
428
429 foreach(CQueryGetFlattenedInstancesExpression* instancesExp, flattenedInstancesExpList) {
430 QString queryName = instancesExp->getName();
431 CClassTermExpression* classBuildExp = instancesExp->getClassTermExpression();
432
433 CComplexIndividualInstancesAnsweringQuery *query = new CComplexIndividualInstancesAnsweringQuery(mBaseOntology, mOntology, classBuildExp, config, queryName);
434 CQueryStatisticsCollectionStrings* queryStats = nullptr;
435 if (confBuildQueryStats) {
436 queryStats = new CQueryStatisticsCollectionStrings();
437 }
438 query->setQueryStatistics(queryStats);
439 query->setDirect(instancesExp->isDirect());
440 query->setFlattened(true);
441 queryList.append(query);
442 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-Flattened-Instances-Query '%1'.").arg(query->getQueryName()), this);
443 }
444
445
446
447
448 foreach(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, mSparqlIndividualSelectExpList) {
449 createSelectQueryFromBGPExpression(sparqlBgpExp, "Individual", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
450 return new CComplexAssertionsIndividualVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
451 }, confBuildQueryStats, queryList);
452 }
453
454 foreach(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, mSparqlClassSelectExpList) {
455 createSelectQueryFromBGPExpression(sparqlBgpExp, "Class", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
456 return new CComplexAxiomsClassVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
457 }, confBuildQueryStats, queryList);
458 }
459
460 foreach(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, mSparqlObjPropSelectExpList) {
461 createSelectQueryFromBGPExpression(sparqlBgpExp, "Object-Property", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
462 return new CComplexAxiomsObjectPropertyVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
463 }, confBuildQueryStats, queryList);
464 }
465
466 foreach(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, mSparqlDataPropSelectExpList) {
467 createSelectQueryFromBGPExpression(sparqlBgpExp, "Data-Property", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
468 return new CComplexAxiomsDataPropertyVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
469 }, confBuildQueryStats, queryList);
470 }
471
472
473 foreach(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, mSparqlIndividualMixedSelectExpList) {
474 createSelectQueryFromBGPExpression(sparqlBgpExp, "Individual-Mixed", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
475 return new CComplexAxiomsIndividualMixedVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
476 }, confBuildQueryStats, queryList);
477 }
478
479
480 foreach(CQuerySPARQLAskBasicGraphPatternExpression* sparqlBgpExp, mSparqlIndividualAskExpList) {
481 createAskQueryFromBGPExpression(sparqlBgpExp, "Individual", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
482 return new CComplexAssertionsIndividualVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
483 }, confBuildQueryStats, queryList);
484 }
485
486 foreach(CQuerySPARQLAskBasicGraphPatternExpression* sparqlBgpExp, mSparqlClassAskExpList) {
487 createAskQueryFromBGPExpression(sparqlBgpExp, "Class", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
488 return new CComplexAxiomsClassVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
489 }, confBuildQueryStats, queryList);
490 }
491
492 foreach(CQuerySPARQLAskBasicGraphPatternExpression* sparqlBgpExp, mSparqlObjectPropAskExpList) {
493 createAskQueryFromBGPExpression(sparqlBgpExp, "Object-Property", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
494 return new CComplexAxiomsObjectPropertyVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
495 }, confBuildQueryStats, queryList);
496 }
497
498 foreach(CQuerySPARQLAskBasicGraphPatternExpression* sparqlBgpExp, mSparqlDataPropAskExpList) {
499 createAskQueryFromBGPExpression(sparqlBgpExp, "Data-Property", [&](CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName) {
500 return new CComplexAxiomsDataPropertyVariablesAnsweringQuery(baseOntology, expressionOntology, axiomExpressions, disVariables, configuration, queryName);
501 }, confBuildQueryStats, queryList);
502 }
503
504
505
506 foreach (CQueryAreClassesEquivalentExpression *classEqExp, classEqExpList) {
507 QString queryName = classEqExp->getName();
508 QStringList conceptNamesStrings;
509 foreach (CClassTermExpression *buildExp, *classEqExp->getClassTermExpressionList()) {
510 CConcept *concept = getConceptFromBuildExpression(buildExp);
511 if (concept) {
512 QString className = getStringFromConcept(concept);
513 conceptNamesStrings.append(className);
514 }
515 }
516 CAreClassesEquivalentQuery *query = new CAreClassesEquivalentQuery(conceptNamesStrings,queryName);
517 CCalculationConfigurationExtension *calcConfig = new CCalculationConfigurationExtension(config,0);
518 CQueryStatisticsCollectionStrings* queryStats = nullptr;
519 if (confBuildQueryStats) {
520 queryStats = new CQueryStatisticsCollectionStrings();
521 }
522 foreach (CClassTermExpression *buildExp, *classEqExp->getConstructedTestClasses()) {
523 CConcept *concept = getConceptFromBuildExpression(buildExp);
524 if (concept) {
525
526 CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,concept->hasMappingNegation());
527 if (confBuildQueryStats) {
528 satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
529 }
530 satCalcJob->setCalculationConfiguration(calcConfig);
531 query->addTestSatisfiableCalculationJob(satCalcJob,false);
532
533
534 }
535 }
536 query->setQueryStatistics(queryStats);
537
538 queryList.append(query);
539 LOG(NOTICE,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Generated AreClassesEquivalent-Query '%1' with question '%2'.").arg(query->getQueryName()).arg(query->getQueryString()),this);
540
541 }
542
543
544
545 foreach (CQueryAreClassesDisjointExpression *classDisjExp, classDisjointExpList) {
546 QString queryName = classDisjExp->getName();
547 QStringList conceptNamesStrings;
548 foreach (CClassTermExpression *buildExp, *classDisjExp->getClassTermExpressionList()) {
549 CConcept *concept = getConceptFromBuildExpression(buildExp);
550 if (concept) {
551 QString className = getStringFromConcept(concept);
552 conceptNamesStrings.append(className);
553 }
554 }
555 CAreClassesDisjointQuery *query = new CAreClassesDisjointQuery(conceptNamesStrings,queryName);
556 CCalculationConfigurationExtension *calcConfig = new CCalculationConfigurationExtension(config,0);
557 CQueryStatisticsCollectionStrings* queryStats = nullptr;
558 if (confBuildQueryStats) {
559 queryStats = new CQueryStatisticsCollectionStrings();
560 }
561 foreach (CClassTermExpression *buildExp, *classDisjExp->getConstructedTestClasses()) {
562 CConcept *concept = getConceptFromBuildExpression(buildExp);
563 if (concept) {
564
565 CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,concept->hasMappingNegation());
566 if (confBuildQueryStats) {
567 satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
568 }
569 satCalcJob->setCalculationConfiguration(calcConfig);
570 query->addTestSatisfiableCalculationJob(satCalcJob,false);
571
572 }
573 }
574 query->setQueryStatistics(queryStats);
575 queryList.append(query);
576 LOG(NOTICE,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Generated AreClassesDisjoint-Query '%1' with question '%2'.").arg(query->getQueryName()).arg(query->getQueryString()),this);
577
578 }
579
580
581
582 foreach (CQueryIsClassSubsumedByExpression *classSubsumedExp, classSubsumedExpList) {
583 QString queryName = classSubsumedExp->getName();
584
585 QString subsumedClassName;
586 QString subsummerClassName;
587
588 CConcept *subsumedConcept = 0;
589 CConcept *subsumerConcept = 0;
590
591 subsumedConcept = getConceptFromBuildExpression(classSubsumedExp->getSubsumedClassExpression());
592 subsumerConcept = getConceptFromBuildExpression(classSubsumedExp->getSubsumerClassExpression());
593
594 subsumedClassName = getStringFromConcept(subsumedConcept);
595 subsummerClassName = getStringFromConcept(subsumerConcept);
596
597 CConcept *concept = getConceptFromBuildExpression(classSubsumedExp->getConstructedTestClassExpression());
598
599 CIsClassSubsumedByQuery *query = new CIsClassSubsumedByQuery(subsumedClassName,subsummerClassName,queryName);
600 CCalculationConfigurationExtension *calcConfig = new CCalculationConfigurationExtension(config,0);
601
602 CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,concept->hasMappingNegation());
603
604 CQueryStatisticsCollectionStrings* queryStats = nullptr;
605 if (confBuildQueryStats) {
606 queryStats = new CQueryStatisticsCollectionStrings();
607 satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
608 }
609 query->setQueryStatistics(queryStats);
610 satCalcJob->setCalculationConfiguration(calcConfig);
611 query->addTestSatisfiableCalculationJob(satCalcJob,false);
612
613
614 queryList.append(query);
615 LOG(NOTICE,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Generated IsClassSubsumedBy-Query '%1' with question '%2'.").arg(query->getQueryName()).arg(query->getQueryString()),this);
616
617 }
618
619
620
621
622
623
624
625
626
627
628
629 foreach (CQueryIsEntailedExpression *isEntailedExp, isEntailedExpList) {
630 QString queryName = isEntailedExp->getName();
631
632
633 QStringList axiomTypeNameStrings;
634 QSet<QString> axiomTypeNameStringSet;
635 CEXPRESSIONLIST<CEntailmentAxiomExpressionAssociation*>* entAxExpAssList = isEntailedExp->getConstructedTestAxiomExpressions();
636 foreach (CEntailmentAxiomExpressionAssociation* entAxiExpAss, *entAxExpAssList) {
637 CAxiomExpression* axiomExpression = entAxiExpAss->getAxiomExpression();
638 CSubClassOfExpression* subClassAxiom = dynamic_cast<CSubClassOfExpression*>(axiomExpression);
639 if (subClassAxiom) {
640 if (!axiomTypeNameStringSet.contains("SubClassOf")) {
641 axiomTypeNameStringSet.insert("SubClassOf");
642 axiomTypeNameStrings += QString("SubClassOf");
643 }
644 }
645 CEquivalentClassesExpression* equivClassAxiom = dynamic_cast<CEquivalentClassesExpression*>(axiomExpression);
646 if (equivClassAxiom) {
647 if (!axiomTypeNameStringSet.contains("EquivalentClasses")) {
648 axiomTypeNameStringSet.insert("EquivalentClasses");
649 axiomTypeNameStrings += QString("EquivalentClasses");
650 }
651 }
652 CObjectPropertyDomainExpression* objPropDomainAxiom = dynamic_cast<CObjectPropertyDomainExpression*>(axiomExpression);
653 if (objPropDomainAxiom) {
654 if (!axiomTypeNameStringSet.contains("ObjectPropertyDomain")) {
655 axiomTypeNameStringSet.insert("ObjectPropertyDomain");
656 axiomTypeNameStrings += QString("ObjectPropertyDomain");
657 }
658 }
659 CObjectPropertyRangeExpression* objPropRangeAxiom = dynamic_cast<CObjectPropertyRangeExpression*>(axiomExpression);
660 if (objPropRangeAxiom) {
661 if (!axiomTypeNameStringSet.contains("ObjectPropertyRange")) {
662 axiomTypeNameStringSet.insert("ObjectPropertyRange");
663 axiomTypeNameStrings += QString("ObjectPropertyRange");
664 }
665 }
666 CClassAssertionExpression* classAssAxiom = dynamic_cast<CClassAssertionExpression*>(axiomExpression);
667 if (classAssAxiom) {
668 if (!axiomTypeNameStringSet.contains("ClassAssertion")) {
669 axiomTypeNameStringSet.insert("ClassAssertion");
670 axiomTypeNameStrings += QString("ClassAssertion");
671 }
672 }
673 }
674 CAreAxiomsEntailedQuery *query = new CAreAxiomsEntailedQuery(axiomTypeNameStrings,queryName);
675 CCalculationConfigurationExtension *calcConfig = new CCalculationConfigurationExtension(config,0);
676 CQueryStatisticsCollectionStrings* queryStats = nullptr;
677 if (confBuildQueryStats) {
678 queryStats = new CQueryStatisticsCollectionStrings();
679 }
680
681
682 foreach (CEntailmentAxiomExpressionAssociation* entAxiExpAss, *entAxExpAssList) {
683 CAxiomExpression* axiomExpression = entAxiExpAss->getAxiomExpression();
684 CEntailmentAxiomExpressionAssociation::ENTAILMENTAXIOMEXPRESSIONCONSTRUCTIONTYPE constructionType = entAxiExpAss->getConstructionType();
685
686 if (constructionType == CEntailmentAxiomExpressionAssociation::EAECTCONCEPTSATISFIABILITY) {
687
688 CConcept* concept = getConceptFromBuildExpression(entAxiExpAss->takeNextConstructedTestClass());
689 if (concept) {
690 CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,concept->hasMappingNegation());
691 if (confBuildQueryStats) {
692 satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
693 }
694 satCalcJob->setCalculationConfiguration(calcConfig);
695 query->addTestSatisfiableCalculationJob(satCalcJob,false);
696 }
697 } else if (constructionType == CEntailmentAxiomExpressionAssociation::EAECTAXIOMSPESIFIC) {
698 CClassAssertionExpression* classAssAxiom = dynamic_cast<CClassAssertionExpression*>(axiomExpression);
699 if (classAssAxiom) {
700 CIndividual* individual = getIndividualFromBuildExpression(classAssAxiom->getIndividualTermExpression());
701 CConcept* concept = getConceptFromBuildExpression(classAssAxiom->getClassTermExpression());
702 if (concept && individual) {
703 CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,!concept->hasMappingNegation(),individual);
704 if (confBuildQueryStats) {
705 satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
706 }
707 satCalcJob->setCalculationConfiguration(calcConfig);
708 query->addTestSatisfiableCalculationJob(satCalcJob,false);
709 }
710 }
711 }
712 }
713 query->setQueryStatistics(queryStats);
714
715 if (!query->getJobList().isEmpty()) {
716 queryList.append(query);
717 LOG(NOTICE,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Generated AreEntailed-Query '%1' with question '%2'.").arg(query->getQueryName()).arg(query->getQueryString()),this);
718 }
719 LOG(NOTICE,"::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder",logTr("Failed to generate AreEntailed-Query '%1'.").arg(query->getQueryName()),this);
720
721 }
722
723
724
725
726
727
728 delete satCalcJobGenerator;
729 qDeleteAll(container);
730
731
732 queryList.append(CConcreteOntologyQueryBasicBuilder::generateQuerys());
733 return queryList;
734 }
735
736 void CConcreteOntologyQueryExtendedBuilder::createAskQueryFromBGPExpression(CQuerySPARQLAskBasicGraphPatternExpression* sparqlBgpExp, const QString& typeString, function<CComplexVariablesAnsweringQuery*(CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName)> queryFunc, bool confBuildQueryStats, QList<CQuery *> &queryList) {
737 QString queryName = sparqlBgpExp->getName();
738 const QList<CAxiomExpression*>& axiomExps = *sparqlBgpExp->getAxiomExpressionList();
739 const QList<CExpressionVariable*> disVarExps;
740 const QList<COrderingTermExpression*> orderingExps;
741 const QList<CFilteringTermExpression*>& filteringExps = *sparqlBgpExp->getFilteringExpressionList();
742
743 CComplexVariablesAnsweringQuery *query = queryFunc(mBaseOntology, mOntology, axiomExps, disVarExps, config, queryName);
744 for (CFilteringTermExpression* filteringExp : filteringExps) {
745 CVariableBindingFiltering* filtering = createFilterFromExpression(filteringExp);
746 query->addResultFiltering(filtering);
747 }
748
749 query->setBooleanEntailmentResultRequired(true);
750 CQueryStatisticsCollectionStrings* queryStats = nullptr;
751 if (confBuildQueryStats) {
752 queryStats = new CQueryStatisticsCollectionStrings();
753 }
754 query->setQueryStatistics(queryStats);
755 queryList.append(query);
756 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-Assertions-%2-Variables-Answering-Query '%1' from SPARQL ASK query.").arg(query->getQueryName()).arg(typeString), this);
757 }
758
759
760
761 void CConcreteOntologyQueryExtendedBuilder::createSelectQueryFromBGPExpression(CQuerySPARQLSelectBasicGraphPatternExpression* sparqlBgpExp, const QString& typeString, function<CComplexVariablesAnsweringQuery*(CConcreteOntology* baseOntology, CConcreteOntology* expressionOntology, const QList<CAxiomExpression*>& axiomExpressions, const QList<CExpressionVariable*>& disVariables, CConfigurationBase* configuration, const QString& queryName)> queryFunc, bool confBuildQueryStats, QList<CQuery *> &queryList) {
762 QString queryName = sparqlBgpExp->getName();
763 const QList<CAxiomExpression*>& axiomExps = *sparqlBgpExp->getAxiomExpressionList();
764 const QList<CExpressionVariable*>& disVarExps = *sparqlBgpExp->getOrderedVariableList();
765 const QList<CExpressionVariable*>& ignoreCardVarExps = *sparqlBgpExp->getIgnoreCardinalityVariableList();
766 const QList<COrderingTermExpression*>& orderingExps = *sparqlBgpExp->getOrderedOrderingTermExpressionList();
767 const QList<CFilteringTermExpression*>& filteringExps = *sparqlBgpExp->getFilteringExpressionList();
768
769 CComplexVariablesAnsweringQuery *query = queryFunc(mBaseOntology, mOntology, axiomExps, disVarExps, config, queryName);
770 for (COrderingTermExpression* orderingExp : orderingExps) {
771 COrderingVariableExpression* orderingVarExp = dynamic_cast<COrderingVariableExpression*>(orderingExp);
772 if (orderingVarExp) {
773 CVariableBindingOrdering::ORDERING_TYPE type = CVariableBindingOrdering::ASC;
774 if (orderingVarExp->getOrderingType() == CVariableBindingOrdering::DESC) {
775 type = CVariableBindingOrdering::DESC;
776 }
777 CVariableBindingOrdering* ordering = new CVariableBindingOrdering(orderingVarExp->getOrderingVariable(), type);
778 query->addResultOrdering(ordering);
779 }
780 }
781 for (CFilteringTermExpression* filteringExp : filteringExps) {
782 CVariableBindingFiltering* filtering = createFilterFromExpression(filteringExp);
783 query->addResultFiltering(filtering);
784 }
785
786 if (!ignoreCardVarExps.isEmpty() && dynamic_cast<CComplexAssertionsIndividualVariablesAnsweringQuery*>(query)) {
787 ((CComplexAssertionsIndividualVariablesAnsweringQuery*)query)->setIgnoreCardinalityVariableExpressions(ignoreCardVarExps);
788 }
789 query->setResultLimit(sparqlBgpExp->getLimit());
790 query->setResultOffset(sparqlBgpExp->getOffset());
791 query->setDistinctRequired(sparqlBgpExp->isDistinct());
792 CQueryStatisticsCollectionStrings* queryStats = nullptr;
793 if (confBuildQueryStats) {
794 queryStats = new CQueryStatisticsCollectionStrings();
795 }
796 query->setQueryStatistics(queryStats);
797 queryList.append(query);
798 LOG(NOTICE, "::Konclude::Reasoner::Generator::ConcreteOntologyQueryBuilder", logTr("Generated Complex-Assertions-%2-Variables-Answering-Query '%1' from SPARQL SELECT query.").arg(query->getQueryName()).arg(typeString), this);
799 }
800
801
802
803 }; // end namespace Generator
804
805 }; // end namespace Reasoner
806
807 }; // end namespace Konclude