Debian Codegraph @

Source/Control/Interface/SPARQL/CSPARQLResultStreamingData.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 "CSPARQLResultStreamingData.h"
22
23
24 namespace Konclude {
25
26 namespace Control {
27
28 namespace Interface {
29
30 namespace SPARQL {
31
32
33
34 CSPARQLResultStreamingData::CSPARQLResultStreamingData(CQueryCommandProvider* queryProvider, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController) {
35 init(sequenceNumber, bufferSize, streamingController);
36 mQueryProvider = queryProvider;
37 mQuery = nullptr;
38 }
39
40 CSPARQLResultStreamingData::CSPARQLResultStreamingData(CQuery* query, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController) {
41 init(sequenceNumber, bufferSize, streamingController);
42 mQuery = query;
43 mQueryProvider = nullptr;
44 }
45
46
47
48 CSPARQLResultStreamingData::~CSPARQLResultStreamingData() {
49 delete mSerializer;
50 delete mBufferMutex;
51 }
52
53
54 CSPARQLResultStreamingData* CSPARQLResultStreamingData::init(cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController) {
55 mBufferMutex = new QMutex(QMutex::Recursive);
56 mStreamingController = streamingController;
57 mInitialBufferSize = 1000000;
58 mBufferSize = mInitialBufferSize;
59 mMaxBufferSize = bufferSize;
60 mSequenceNumber = sequenceNumber;
61 mStreamingResult = nullptr;
62
63 QByteArray* bufferArray = new QByteArray();
64 bufferArray->reserve(mBufferSize + 10000);
65 mSerializer = new CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer(bufferArray, false);
66 mStreamingFinished = false;
67 mStreamingInitialized = false;
68 mFinalized = false;
69 mUsedBufferSize = 0;
70 mFlushId = 0;
71 mContinueSerialization = true;
72 mWritingScheduled = false;
73 mConcurrentFinishCount = 0;
74 return this;
75 }
76
77
78 CQuery* CSPARQLResultStreamingData::getQuery() {
79 if (!mQuery && mQueryProvider) {
80 mQuery = mQueryProvider->getQuery();
81 }
82 if (mQuery) {
83 CComplexAssertionsIndividualVariablesAnsweringQuery* compAssIndVarQuery = dynamic_cast<CComplexAssertionsIndividualVariablesAnsweringQuery*>(mQuery);
84 if (compAssIndVarQuery) {
85 if (!compAssIndVarQuery->getQueryResult()) {
86 if (!compAssIndVarQuery->getResultOrderingLinker() && !compAssIndVarQuery->isBooleanEntailmentResultRequired()) {
87
88 LOG(NOTICE, "::Konclude::Control::Interface::SPARQL::SPARQLResultStreamer", logTr("Enabling results streaming for query '%1'.").arg(mQuery->getQueryName()), this);
89
90 mStreamingResult = new CVariableBindingsAnswersStreamingResult(this);
91 compAssIndVarQuery->setQueryResult(mStreamingResult);
92 }
93 }
94 }
95
96 #ifdef KONCLUDE_REDLAND_INTEGRATION
97 CRedlandRasqalBGPsCompositionQuery* redRasqQuery = dynamic_cast<CRedlandRasqalBGPsCompositionQuery*>(mQuery);
98 if (redRasqQuery) {
99 const QString& queryText = redRasqQuery->getQueryText();
100 cint64 firstSELECTPos = queryText.toUpper().indexOf("SELECT");
101 cint64 firstBracketPos = queryText.indexOf("{");
102 if (firstSELECTPos != -1 && firstSELECTPos < firstBracketPos) {
103 LOG(NOTICE, "::Konclude::Control::Interface::SPARQL::SPARQLResultStreamer", logTr("Enabling results streaming for Redland Rasqal query '%1'.").arg(mQuery->getQueryName()), this);
104 mStreamingResult = new CVariableBindingsAnswersStreamingResult(this);
105 redRasqQuery->setQueryResult(mStreamingResult);
106 }
107 }
108 #endif // KONCLUDE_REDLAND_INTEGRATION
109
110 }
111 return mQuery;
112 }
113
114 CCommand* CSPARQLResultStreamingData::getCommand() {
115 return mQueryProvider->getCommand();
116 }
117
118
119
120
121 bool CSPARQLResultStreamingData::initResultStreaming(const QStringList& varNames) {
122 mVarNames = varNames;
123 if (!mStreamingInitialized) {
124 mStreamingInitialized = true;
125 mSerializer->addResultStreamingStart(mVarNames);
126 }
127 return mStreamingController->canWrite();
128 }
129
130 CVariableBindingsAnswersStreamingHandler* CSPARQLResultStreamingData::streamResultVariableBindings(CVariableBindingsAnswerResult* varBindings, cint64 cardinality) {
131 if (mStreamingInitialized && !mStreamingFinished && mContinueSerialization) {
132 mSerializer->addResultStreamingBindingToTemporaryBuffer(mVarNames, varBindings);
133 for (cint64 i = 0; i < cardinality; ++i) {
134 mSerializer->addTemporaryBuffer();
135 if (mSerializer->getBufferWrittenSize() > mBufferSize) {
136 mWritingScheduled = true;
137 mBufferSize *= 2;
138 if (mBufferSize > mMaxBufferSize) {
139 mBufferSize = mMaxBufferSize;
140 }
141 mContinueSerialization &= streamingFlush();
142 }
143 }
144 mSerializer->clearTemporaryBuffer();
145 }
146 return this;
147 }
148
149
150 bool CSPARQLResultStreamingData::streamingFlush() {
151 if (mSerializer->getBufferWrittenSize() > 0 || !mUsedBufferList.isEmpty()) {
152 mWritingScheduled = true;
153 if (mSerializer->getBufferWrittenSize() > 0) {
154 mSerializer->writeFlush(++mFlushId);
155 QByteArray* bufferArray = new QByteArray();
156 bufferArray->reserve(mBufferSize + 10000);
157 QByteArray* usedBuffer = mSerializer->updateWriteBuffer(bufferArray);
158 mBufferMutex->lock();
159 mUsedBufferSize += usedBuffer->size();
160 mUsedBufferList.append(CSPARQLResultBufferWriteData(1, usedBuffer));
161 mBufferMutex->unlock();
162 }
163 mContinueSerialization &= mStreamingController->notifyWriteRequest(mSequenceNumber);
164 }
165 return mContinueSerialization;
166 }
167
168
169 CVariableBindingsAnswersStreamingHandler* CSPARQLResultStreamingData::finishResultStreaming() {
170 if (mStreamingInitialized && !mStreamingFinished) {
171 streamingFlush();
172 mStreamingFinished = true;
173 mSerializer->addResultSerialization(mVarNames, mStreamingResult);
174 }
175 return this;
176 }
177
178
179 CSPARQLResultStreamingData* CSPARQLResultStreamingData::finalize() {
180 if (!mFinalized) {
181 QByteArray* usedBuffer = mSerializer->updateWriteBuffer(nullptr);
182 mBufferMutex->lock();
183 mUsedBufferSize += usedBuffer->size();
184 mUsedBufferList.append(CSPARQLResultBufferWriteData(1, usedBuffer));
185 mBufferMutex->unlock();
186 mFinalized = true;
187 }
188 return this;
189 }
190
191
192 CSPARQLResultStreamingData* CSPARQLResultStreamingData::handleQueryResult(CQuery* query, CQueryResult* queryResult) {
193 finishResultStreaming();
194 if (mStreamingResult != queryResult) {
195
196 CComplexAnsweringQuery* compAssIndVarQuery = dynamic_cast<CComplexAnsweringQuery*>(query);
197 if (compAssIndVarQuery) {
198 if (dynamic_cast<CBooleanQueryResult*>(queryResult)) {
199 mSerializer->addResultSerialization((CBooleanQueryResult*)queryResult);
200 } else if (dynamic_cast<CVariableBindingsAnswersResult*>(queryResult)) {
201 CVariableBindingsAnswersResult* varBindAnsRes = (CVariableBindingsAnswersResult*)queryResult;
202 QStringList varList;
203 for (auto varExp : varBindAnsRes->getVariableNames()) {
204 varList.append(varExp);
205 }
206 mSerializer->addResultSerialization(varList, varBindAnsRes);
207 }
208 }
209
210
211 }
212 CQueryStatistics* stats = query->getQueryStatistics();
213 if (stats) {
214 mSerializer->addResultStatistics(stats);
215 }
216 return this;
217 }
218
219 CSPARQLResultStreamingData* CSPARQLResultStreamingData::handleQueryError(CQuery* query, const QString& error) {
220 if (mStreamingInitialized && !mStreamingFinished) {
221 mSerializer->addResultSerialization(mVarNames, mStreamingResult);
222 }
223 mSerializer->addResultError(error, "error");
224 return this;
225 }
226
227
228 CSPARQLResultConcurrentStreamingDataBufferReciever* CSPARQLResultStreamingData::transferConcurrentBuffers(QList<CSPARQLResultBufferWriteData>& bufferList, cint64& bufferSize) {
229 mBufferMutex->lock();
230 mUsedBufferList.append(bufferList);
231 mUsedBufferSize += bufferSize;
232 bool flush = false;
233 if (mUsedBufferSize > mBufferSize && !mWritingScheduled) {
234 mBufferSize *= 2;
235 if (mBufferSize > mMaxBufferSize) {
236 mBufferSize = mMaxBufferSize;
237 }
238 flush = true;
239 mWritingScheduled = true;
240 }
241 if (flush) {
242 mContinueSerialization &= streamingFlush();
243 }
244 mBufferMutex->unlock();
245 bufferSize = 0;
246 bufferList.clear();
247 return this;
248 }
249
250 QList<CSPARQLResultBufferWriteData> CSPARQLResultStreamingData::takeWriteableBuffers() {
251 mBufferMutex->lock();
252 mWritingScheduled = false;
253 QList<CSPARQLResultBufferWriteData> tmpList = mUsedBufferList;
254 mUsedBufferList.clear();
255 mUsedBufferSize = 0;
256 mBufferMutex->unlock();
257 return tmpList;
258 }
259
260 cint64 CSPARQLResultStreamingData::getWriteableBufferSize() {
261 return mUsedBufferSize;
262 }
263
264 cint64 CSPARQLResultStreamingData::getWriteableBufferCount() {
265 return mUsedBufferList.size();
266 }
267
268
269 cint64 CSPARQLResultStreamingData::getSequenceNumber() {
270 return mSequenceNumber;
271 }
272
273
274
275
276 CVariableBindingsAnswersConcurrentStreamingHandler* CSPARQLResultStreamingData::getConcurrentStreamingHandler() {
277 CSPARQLResultConcurrentStreamingData* conStreamData = new CSPARQLResultConcurrentStreamingData(mInitialBufferSize, mMaxBufferSize, &mVarNames, &mContinueSerialization, this);
278 return conStreamData;
279 }
280
281
282 CVariableBindingsAnswersStreamingHandler* CSPARQLResultStreamingData::releaseConcurrentStreamingHandler(CVariableBindingsAnswersConcurrentStreamingHandler* handler) {
283 CSPARQLResultConcurrentStreamingData* conStreamData = (CSPARQLResultConcurrentStreamingData*)handler;
284 if (conStreamData->hasData()) {
285 mBufferMutex->lock();
286 ++mConcurrentFinishCount;
287 conStreamData->addBuffers(mUsedBufferList, mUsedBufferSize);
288 bool flush = false;
289 if (mUsedBufferSize > mBufferSize && !mWritingScheduled) {
290 mBufferSize *= 2;
291 if (mBufferSize > mMaxBufferSize) {
292 mBufferSize = mMaxBufferSize;
293 }
294 flush = true;
295 mWritingScheduled = true;
296 }
297 mBufferMutex->unlock();
298 if (flush) {
299 mContinueSerialization &= streamingFlush();
300 }
301 }
302 delete conStreamData;
303 return this;
304 }
305
306
307
308
309 }; // end namespace SPARQL
310
311 }; // end namespace Interface
312
313 }; // end namespace Control
314
315 }; // end namespace Konclude