Debian Codegraph @

Source/Parser/CSPARQLSimpleQueryParser.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 "CSPARQLSimpleQueryParser.h"
22
23
24 namespace Konclude {
25
26 namespace Parser {
27
28
29
30 CSPARQLSimpleQueryParser::CSPARQLSimpleQueryParser(CSPARQLQueryBuilder *queryBuilder, COntologyBuilder* ontoBuilder, CConcreteOntology* ontology) : CSPARQLSimpleBuildingParser(ontoBuilder, ontology) {
31 mQueryBuilder = queryBuilder;
32 }
33
34
35 CSPARQLSimpleQueryParser::~CSPARQLSimpleQueryParser() {
36 }
37
38
39
40 bool CSPARQLSimpleQueryParser::parseQueryFile(const QString& filename) {
41 bool successfullParsed = true;
42
43 // parse file
44 QFile file(filename);
45 if (file.open(QIODevice::ReadOnly)) {
46
47 QStringList partStringList;
48 while (!file.atEnd()) {
49 QString line(file.readLine());
50 cint64 linePos = 0;
51 while (linePos != line.length()) {
52 QString partString = getNextPart(line, linePos);
53 if (!partString.isEmpty()) {
54 if (isKeyword(partString) && !partStringList.isEmpty()) {
55 processParts(partStringList);
56 partStringList.clear();
57 }
58 partStringList.append(partString);
59 }
60 }
61 }
62 if (!partStringList.isEmpty()) {
63 processParts(partStringList);
64 }
65
66 file.close();
67
68 } else {
69 successfullParsed = false;
70 LOG(ERROR,"::Konclude::Parser::SPARQLSimpleQueryParser",logTr("File '%1' not found or couldn't be opened.").arg(filename),this);
71 }
72
73 return successfullParsed;
74 }
75
76
77 bool CSPARQLSimpleQueryParser::parseQueryText(const QString& filetext) {
78 QStringList partStringList;
79 QString line(filetext);
80 cint64 linePos = 0;
81 while (linePos != line.length()) {
82 QString partString = getNextPart(line, linePos);
83 if (!partString.isEmpty()) {
84 if (isKeyword(partString) && !partStringList.isEmpty()) {
85 processParts(partStringList);
86 partStringList.clear();
87 }
88 partStringList.append(partString);
89 }
90 }
91 if (!partStringList.isEmpty()) {
92 processParts(partStringList);
93 }
94 return true;
95 }
96
97
98 bool CSPARQLSimpleQueryParser::parseQueryTextList(const QStringList& queryTextList) {
99 QStringList partStringList;
100 QStringList tmpQueryTextList = queryTextList;
101 cint64 linePos = 0;
102 while (!tmpQueryTextList.isEmpty()) {
103 QString partString = tmpQueryTextList.takeFirst();
104 if (!partString.isEmpty()) {
105 if (isKeyword(partString) && !partStringList.isEmpty()) {
106 processParts(partStringList);
107 partStringList.clear();
108 }
109 partStringList.append(partString);
110 }
111 }
112 if (!partStringList.isEmpty()) {
113 processParts(partStringList);
114 }
115 return true;
116 }
117
118
119
120
121 bool CSPARQLSimpleQueryParser::processParts(QStringList& parsedParts) {
122 if (parsedParts.size() > 0) {
123 QString keyword = parsedParts.takeFirst().toUpper();
124 if (keyword == "BASE") {
125 mBaseIRI = "";
126 if (parsedParts.size() >= 1) {
127 mBaseIRI = getIRI(parsedParts.takeFirst());
128 }
129 } else if (keyword == "PREFIX") {
130 if (parsedParts.size() >= 2) {
131 QString prefix = parsedParts.takeFirst();
132 while (prefix.endsWith(":")) {
133 prefix = prefix.mid(0, prefix.length() - 1);
134 }
135 QString iri = getIRI(parsedParts.takeFirst());
136 mPrefixHash.insert(prefix, iri);
137 }
138 } else if (keyword == "SELECT") {
139 QStringList disVarStringList;
140 bool distinctModifier = false;
141 bool selectVarsFinished = false;
142 bool selectAllVariables = false;
143 bool whereClausesStarting = false;
144 while (!parsedParts.isEmpty() && !selectVarsFinished) {
145 QString varString = parsedParts.takeFirst();
146
147 QString modifierString = varString.toUpper();
148 if (modifierString == "DISTINCT") {
149 distinctModifier = true;
150 }
151
152 int nextVarStartPos = qMax(varString.indexOf(",?"), varString.indexOf(",$"));
153 if (nextVarStartPos != -1) {
154 if (nextVarStartPos == 0) {
155 QString otherPartString = varString.mid(1);
156 parsedParts.prepend(otherPartString);
157 } else {
158 varString = varString.mid(0, nextVarStartPos);
159 QString otherPartString = varString.mid(nextVarStartPos + 1);
160 parsedParts.prepend(otherPartString);
161 }
162 }
163
164 if (varString.startsWith("*")) {
165 selectAllVariables = true;
166 }
167
168 if (varString.startsWith("?") || varString.startsWith("$")) {
169 while (varString.endsWith(",")) {
170 varString = varString.mid(0, varString.length() - 1);
171 }
172 if (!varString.isEmpty()) {
173 varString = varString.mid(1);
174 disVarStringList.append(varString);
175 }
176
177 } else if (varString.toUpper() == "WHERE" || varString.toUpper() == "FROM") {
178 selectVarsFinished = true;
179
180 } else if (varString == "{") {
181 selectVarsFinished = true;
182 whereClausesStarting = true;
183 }
184 }
185
186
187
188
189
190
191 CEXPRESSIONLIST<COrderingTermExpression*> orderingList;
192 QList<CFilteringTermExpression*> filteringList;
193
194 QStringList whereClauseStringList = getBracketContent(parsedParts, '{', '}', whereClausesStarting);
195 QList<QStringList> filterList;
196 QHash<QString, CRDFHahsedSubjectData>* subjectTripleHash = getRDFSubjectHash(whereClauseStringList, filterList);
197 QList<CAxiomExpression*> axiomList = getTripleOWLAxioms(subjectTripleHash, true);
198 delete subjectTripleHash;
199 QList<CExpressionVariable*> varExpList;
200 QList<CExpressionVariable*> disVarList;
201 for (QString varString : disVarStringList) {
202 CExpressionVariable* expVar = mNameVarHash.value(varString);
203 if (expVar) {
204 disVarList.append(expVar);
205 } else {
206 LOG(WARN, "::Konclude::Parser::SPARQLSimpleQueryParser", logTr("Variable '%1' in SELECT does not occur in WHERE clause, variable is ignored.").arg(varString), this);
207 }
208 }
209 for (CExpressionVariable* varExp : mVarExpSet) {
210 varExpList.append(varExp);
211 if (selectAllVariables) {
212 disVarList.append(varExp);
213 }
214 }
215
216 filteringList = getFilters(filterList);
217
218
219
220 cint64 limit = -1;
221 cint64 offset = 0;
222 bool orderingVarsFinished = false;
223 while (!parsedParts.isEmpty() && !orderingVarsFinished) {
224 QString keyString = parsedParts.first();
225 QString keyUpperString = keyString.toUpper();
226 if (keyUpperString == "LIMIT") {
227 parsedParts.removeFirst();
228 if (!parsedParts.isEmpty()) {
229 limit = parsedParts.takeFirst().toLongLong();
230 }
231 } else if (keyUpperString == "OFFSET") {
232 parsedParts.removeFirst();
233 if (!parsedParts.isEmpty()) {
234 offset = parsedParts.takeFirst().toLongLong();
235 }
236 } else if (keyUpperString == "ORDER" || keyUpperString == "BY") {
237 parsedParts.removeFirst();
238 } else {
239 parsedParts.removeFirst();
240 QString varString;
241
242 bool variableBracketed = false;
243 bool ascOrdered = true;
244 if (keyUpperString == "ASC") {
245 ascOrdered = true;
246 variableBracketed = true;
247 } else if (keyUpperString == "DESC") {
248 ascOrdered = false;
249 variableBracketed = true;
250 } else {
251 varString = keyString;
252 }
253
254 if (variableBracketed) {
255 QStringList variableClauseStringList = getBracketContent(parsedParts, '(', ')');
256 if (!variableClauseStringList.isEmpty()) {
257 varString = variableClauseStringList.first();
258 }
259 }
260
261 if (varString.startsWith("?") || varString.startsWith("$")) {
262 varString = varString.mid(1);
263 CExpressionVariable* expVar = mNameVarHash.value(varString);
264 if (expVar) {
265 COrderingTermExpression* orderingVarExp = mQueryBuilder->getOrderingVariableExpression(expVar, ascOrdered);
266 orderingList.append(orderingVarExp);
267 }
268 }
269
270 }
271 }
272
273 CQuerySPARQLBasicGraphPatternExpression* sparqlQuery = mQueryBuilder->getSPARQLBasicGraphPatternIndividualSelectQuery(axiomList, disVarList, orderingList, filteringList, distinctModifier, limit, offset);
274 mSPARQLBGPQueryList.append(sparqlQuery);
275
276
277 } else if (keyword == "ASK") {
278
279 QStringList askClauseStringList = getBracketContent(parsedParts, '{', '}', false);
280 QList<QStringList> filterList;
281 QHash<QString, CRDFHahsedSubjectData>* subjectTripleHash = getRDFSubjectHash(askClauseStringList, filterList);
282 QList<CAxiomExpression*> axiomList = getTripleOWLAxioms(subjectTripleHash, true);
283 QList<CFilteringTermExpression*> filteringList;
284 filteringList = getFilters(filterList);
285
286 CQuerySPARQLBasicGraphPatternExpression* sparqlQuery = mQueryBuilder->getSPARQLBasicGraphPatternIndividualAskQuery(axiomList, filteringList);
287 mSPARQLBGPQueryList.append(sparqlQuery);
288 }
289 }
290 return true;
291 }
292
293
294
295
296 QList<CFilteringTermExpression*> CSPARQLSimpleQueryParser::getFilters(QList<QStringList>& filterList) {
297 QList<CFilteringTermExpression*> filterExpList;
298 while (!filterList.isEmpty()) {
299 QStringList filterParts = filterList.takeFirst();
300 CBuildExpression* filterExp = getFilterORExpression(filterParts);
301 if (filterExp && dynamic_cast<CFilteringTermExpression*>(filterExp)) {
302 filterExpList.append((CFilteringTermExpression*)filterExp);
303 }
304 }
305 return filterExpList;
306 }
307
308
309 CBuildExpression* CSPARQLSimpleQueryParser::getExpression(QStringList& filterParts) {
310 QString filterString = filterParts.takeFirst();
311 if (filterString == "(") {
312 QStringList innerFilterParts = getBracketContent(filterParts, '(', ')', true);
313 return getFilterORExpression(innerFilterParts);
314 } else if (filterString.startsWith("?") || filterString.startsWith("$")) {
315 QString varString = filterString.mid(1);
316 CExpressionVariable* var = mNameVarHash.value(varString, nullptr);
317 if (var) {
318 if (dynamic_cast<CDataLiteralVariableExpression*>(var)) {
319 return (CDataLiteralVariableExpression*)var;
320 }
321 else if (dynamic_cast<CIndividualVariableExpression*>(var)) {
322 return (CIndividualVariableExpression*)var;
323 }
324 }
325 } else if (filterString.startsWith("\"") || filterString.startsWith("'")) {
326 QPair<QString,QString> datatypeLiteralStringPair = extractDataLiteral(filterString);
327 QString datatypeString = datatypeLiteralStringPair.second;
328 QString literalString = datatypeLiteralStringPair.first;
329 CDatatypeExpression* datatypeExp = mOntoBuilder->getDatatype(datatypeString);
330 CDataLexicalValueExpression* lexiValExp = mOntoBuilder->getDataLexicalValue(literalString);
331 CDataLiteralExpression* dataLiteralExp = mOntoBuilder->getDataLiteral(lexiValExp, datatypeExp);
332 return dataLiteralExp;
333 }
334 return nullptr;
335 }
336
337
338 CBuildExpression* CSPARQLSimpleQueryParser::getFilterORExpression(QStringList& filterParts) {
339 QList<CBuildExpression*> expressions;
340 while (!filterParts.isEmpty()) {
341 QString filterString = filterParts.first();
342 if (filterString == "(" || filterString.startsWith("?") || filterString.startsWith("$") || filterString.startsWith("\"") || filterString.startsWith("'")) {
343 CBuildExpression* exp = getExpression(filterParts);
344 if (exp) {
345 expressions.append(exp);
346 }
347 } else if (filterString == "<" || filterString == ">" || filterString == "<=" || filterString == ">=" || filterString == "==" || filterString == "!=") {
348 filterParts.removeFirst();
349 CBuildExpression* secExp = getExpression(filterParts);
350 CBuildExpression* firstExp = nullptr;
351 if (expressions.count() > 0) {
352 firstExp = expressions.takeLast();
353 }
354 if (firstExp && secExp) {
355 if (dynamic_cast<CDataLiteralVariableExpression*>(firstExp) && dynamic_cast<CDataLiteralExpression*>(secExp)) {
356 expressions.append(getDataLiteralComparisonFilter((CDataLiteralVariableExpression*)firstExp, (CDataLiteralExpression*)secExp, filterString, false));
357 } else if (dynamic_cast<CDataLiteralVariableExpression*>(secExp) && dynamic_cast<CDataLiteralExpression*>(firstExp)) {
358 expressions.append(getDataLiteralComparisonFilter((CDataLiteralVariableExpression*)secExp, (CDataLiteralExpression*)firstExp, filterString, true));
359 }
360 }
361 }
362 }
363 if (expressions.count() > 0) {
364 return expressions.first();
365 }
366 return nullptr;
367 }
368
369
370 CFilteringComparisonDataLiteralExpression* CSPARQLSimpleQueryParser::getDataLiteralComparisonFilter(CDataLiteralVariableExpression* dataLitVar, CDataLiteralExpression* dataLiteral, const QString& compareOperatorString, bool reverse) {
371 CFilteringComparisonDataLiteralExpression::COMPARING_TYPE type = CFilteringComparisonDataLiteralExpression::EQUAL;
372 if (compareOperatorString == "==") {
373 type = CFilteringComparisonDataLiteralExpression::EQUAL;
374 } else if (compareOperatorString == "!=") {
375 type = CFilteringComparisonDataLiteralExpression::UNEQUAL;
376 } else if (compareOperatorString == "<=") {
377 if (reverse) {
378 type = CFilteringComparisonDataLiteralExpression::GREATER_EQUAL;
379 } else {
380 type = CFilteringComparisonDataLiteralExpression::LESS_EQUAL;
381 }
382 } else if (compareOperatorString == ">=") {
383 if (reverse) {
384 type = CFilteringComparisonDataLiteralExpression::LESS_EQUAL;
385 } else {
386 type = CFilteringComparisonDataLiteralExpression::GREATER_EQUAL;
387 }
388 } else if (compareOperatorString == "<") {
389 if (reverse) {
390 type = CFilteringComparisonDataLiteralExpression::GREATER;
391 } else {
392 type = CFilteringComparisonDataLiteralExpression::LESS;
393 }
394 } else if (compareOperatorString == ">") {
395 if (reverse) {
396 type = CFilteringComparisonDataLiteralExpression::LESS;
397 } else {
398 type = CFilteringComparisonDataLiteralExpression::GREATER;
399 }
400 }
401 CFilteringComparisonDataLiteralExpression* compDataLiteralFilterExp = new CFilteringComparisonDataLiteralExpression(dataLiteral, dataLitVar, type);
402 return compDataLiteralFilterExp;
403 }
404
405
406 }; // end namespace Parser
407
408 }; // end namespace Konclude