Debian Codegraph @

Source/Control/Interface/SPARQL/CSPARQLResultStreamingData.h

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 #ifndef KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H
22 #define KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H
23
24 // Libraries includes
25 #include <QString>
26 #include <QDomDocument>
27 #include <QMap>
28 #include <QVector>
29 #include <QMutex>
30
31 // Namespace includes
32 #include "CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer.h"
33 #include "CSPARQLResultStreamingController.h"
34 #include "CSPARQLResultBufferWriteData.h"
35
36 // Other includes
37 #include "Reasoner/Query/CVariableBindingsAnswersResult.h"
38 #include "Reasoner/Query/CBooleanQueryResult.h"
39 #include "Reasoner/Query/CComplexAssertionsIndividualVariablesAnsweringQuery.h"
40 #include "Reasoner/Query/CVariableBindingsAnswersStreamingHandler.h"
41 #include "Reasoner/Query/CVariableBindingsAnswersConcurrentStreamingHandler.h"
42 #include "Reasoner/Query/CVariableBindingsAnswersStreamingResult.h"
43 #include "Reasoner/Query/CRedlandRasqalBGPsCompositionQuery.h"
44
45
46 #include "Control/Command/Instructions/CQueryCommandProvider.h"
47 #include "Control/Command/CCommand.h"
48
49
50 // Logger includes
51 #include "Logger/CLogger.h"
52
53 using namespace Konclude::Logger;
54
55
56 namespace Konclude {
57
58 using namespace Reasoner::Query;
59
60 namespace Control {
61
62 using namespace Command;
63 using namespace Command::Instructions;
64
65 namespace Interface {
66
67 namespace SPARQL {
68
69
70
71 class CSPARQLResultConcurrentStreamingDataBufferReciever {
72 public:
73
74 virtual CSPARQLResultConcurrentStreamingDataBufferReciever* transferConcurrentBuffers(QList<CSPARQLResultBufferWriteData>& bufferList, cint64& bufferSize) = 0;
75
76 };
77
78 /*!
79 *
80 * \class CSPARQLResultStreamingData
81 * \author Andreas Steigmiller
82 * \version 0.1
83 * \brief TODO
84 *
85 */
86 class CSPARQLResultStreamingData : public CQueryCommandProvider, public CVariableBindingsAnswersStreamingHandler, public CSPARQLResultConcurrentStreamingDataBufferReciever {
87 // public methods
88 public:
89 //! Constructor
90 CSPARQLResultStreamingData(CQueryCommandProvider* queryProvider, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
91 CSPARQLResultStreamingData(CQuery* query, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
92
93 //! Destructor
94 virtual ~CSPARQLResultStreamingData();
95
96
97 virtual CQuery *getQuery();
98 virtual CCommand *getCommand();
99
100
101 virtual bool initResultStreaming(const QStringList& varNames);
102
103 virtual CVariableBindingsAnswersStreamingHandler* streamResultVariableBindings(CVariableBindingsAnswerResult* varBindings, cint64 cardinality = 1);
104
105 virtual bool streamingFlush();
106
107 virtual CVariableBindingsAnswersStreamingHandler* finishResultStreaming();
108
109 virtual CSPARQLResultStreamingData* handleQueryResult(CQuery* query, CQueryResult* queryResult);
110 virtual CSPARQLResultStreamingData* handleQueryError(CQuery* query, const QString& error);
111
112
113
114 CSPARQLResultStreamingData* finalize();
115
116 QList<CSPARQLResultBufferWriteData> takeWriteableBuffers();
117 cint64 getWriteableBufferSize();
118 cint64 getWriteableBufferCount();
119 cint64 getSequenceNumber();
120
121
122 virtual CVariableBindingsAnswersConcurrentStreamingHandler* getConcurrentStreamingHandler();
123 virtual CVariableBindingsAnswersStreamingHandler* releaseConcurrentStreamingHandler(CVariableBindingsAnswersConcurrentStreamingHandler* handler);
124
125 virtual CSPARQLResultConcurrentStreamingDataBufferReciever* transferConcurrentBuffers(QList<CSPARQLResultBufferWriteData>& bufferList, cint64& bufferSize);
126
127
128 // protected methods
129 protected:
130 class CSPARQLResultConcurrentStreamingData : public CVariableBindingsAnswersConcurrentStreamingHandler {
131 public:
132 CSPARQLResultConcurrentStreamingData(cint64 bufferSize, cint64 maxBufferSize, QStringList* varNames, bool* serialize, CSPARQLResultConcurrentStreamingDataBufferReciever* reciever) {
133 mBufferSize = bufferSize;
134 mMaxBufferSize = maxBufferSize;
135 mVarNames = varNames;
136 mSerializer = nullptr;
137
138 mUsedBufferSize = 0;
139 mSerialize = serialize;
140 mReciever = reciever;
141 mMaxBufferCollectingCount = 10;
142 }
143
144 ~CSPARQLResultConcurrentStreamingData() {
145 if (mSerializer) {
146 delete mSerializer;
147 }
148 }
149
150
151 CVariableBindingsAnswersConcurrentStreamingHandler* concurrentlyStreamResultVariableBindings(CVariableBindingsAnswerResult* varBindings, cint64 cardinality) {
152
153 if (*mSerialize) {
154 if (!mSerializer) {
155 QByteArray* bufferArray = new QByteArray();
156 bufferArray->reserve(mBufferSize + 10000);
157 mSerializer = new CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer(bufferArray, this);
158 }
159 mSerializer->addResultStreamingBindingToTemporaryBuffer(*mVarNames, varBindings);
160 bool onlyVarBindWritten = false;
161 cint64 onlyVarBindCount = 0;
162 if (mSerializer->getBufferWrittenSize() <= 0) {
163 onlyVarBindWritten = true;
164 }
165 while (cardinality > 0) {
166 mSerializer->addTemporaryBuffer();
167 ++onlyVarBindCount;
168 --cardinality;
169 if (mSerializer->getBufferWrittenSize() > mBufferSize) {
170 mBufferSize *= 2;
171 if (mBufferSize > mMaxBufferSize) {
172 mBufferSize = mMaxBufferSize;
173 }
174 cint64 bufferWriteCount = 1;
175 if (onlyVarBindWritten) {
176 while (cardinality > onlyVarBindCount) {
177 cardinality -= onlyVarBindCount;
178 ++bufferWriteCount;
179 }
180 }
181 QByteArray* bufferArray = new QByteArray();
182 bufferArray->reserve(mBufferSize + 10000);
183 QByteArray* usedBuffer = mSerializer->updateWriteBuffer(bufferArray);
184 mUsedBufferSize += usedBuffer->size();
185 mUsedBufferList.append(CSPARQLResultBufferWriteData(bufferWriteCount, usedBuffer));
186 onlyVarBindWritten = true;
187 onlyVarBindCount = 0;
188 if (mUsedBufferList.size() >= mMaxBufferCollectingCount) {
189 mReciever->transferConcurrentBuffers(mUsedBufferList, mUsedBufferSize);
190 }
191 }
192 }
193 mSerializer->clearTemporaryBuffer();
194 }
195
196 return this;
197 }
198
199
200 bool hasData() {
201 return mSerializer && (mSerializer->getBufferWrittenSize() > 0 || mUsedBufferSize > 0);
202 }
203
204 CSPARQLResultConcurrentStreamingData* addBuffers(QList<CSPARQLResultBufferWriteData>& bufferList, cint64& bufferSize) {
205 if (mSerializer && mSerializer->getBufferWrittenSize() > 0) {
206 QByteArray* usedBuffer = mSerializer->updateWriteBuffer(nullptr);
207 CSPARQLResultBufferWriteData usedBufferData(1, usedBuffer);
208 mUsedBufferSize += usedBuffer->size();
209 mUsedBufferList.append(usedBufferData);
210 }
211 bufferList.append(mUsedBufferList);
212 bufferSize += mUsedBufferSize;
213 return this;
214 }
215
216
217 CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer* mSerializer;
218
219 QList<CSPARQLResultBufferWriteData> mUsedBufferList;
220 cint64 mUsedBufferSize;
221 cint64 mBufferSize;
222 cint64 mMaxBufferSize;
223 QStringList* mVarNames;
224 bool* mSerialize = nullptr;
225
226 CSPARQLResultConcurrentStreamingDataBufferReciever* mReciever;
227 cint64 mMaxBufferCollectingCount;
228
229 };
230
231
232 CSPARQLResultStreamingData* init(cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
233
234 // protected variables
235 protected:
236 CSPARQLResultStreamingController* mStreamingController;
237 CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer* mSerializer;
238 CQueryCommandProvider* mQueryProvider;
239 CQuery* mQuery;
240 cint64 mSequenceNumber;
241 CVariableBindingsAnswersStreamingResult* mStreamingResult;
242 QStringList mVarNames;
243 cint64 mMaxBufferSize;
244 cint64 mBufferSize;
245 cint64 mInitialBufferSize;
246 bool mStreamingFinished;
247 bool mStreamingInitialized;
248 bool mFinalized;
249 bool mContinueSerialization;
250
251 cint64 mFlushId;
252
253 QList<CSPARQLResultBufferWriteData> mUsedBufferList;
254 cint64 mUsedBufferSize;
255 bool mWritingScheduled;
256 cint64 mConcurrentFinishCount;
257
258 QMutex* mBufferMutex;
259
260 // private methods
261 private:
262
263 // private variables
264 private:
265
266 };
267
268 }; // end namespace SPARQL
269
270 }; // end namespace Interface
271
272 }; // end namespace Control
273
274 }; // end namespace Konclude
275
276 #endif // KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H