Qt 6.x
The Qt SDK
Loading...
Searching...
No Matches
qsql_mimer.cpp
Go to the documentation of this file.
1// Copyright (C) 2022 The Qt Company Ltd.
2// Copyright (C) 2022 Mimer Information Technology
3// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4#include <qcoreapplication.h>
5#include <qvariant.h>
6#include <qmetatype.h>
7#include <qdatetime.h>
8#include <qsqlerror.h>
9#include <qsqlfield.h>
10#include <qsqlindex.h>
11#include <qsqlrecord.h>
12#include <qsqlquery.h>
13#include <qsocketnotifier.h>
14#include <qstringlist.h>
15#include <qlocale.h>
16#if defined(Q_OS_WIN32)
17# include <QtCore/qt_windows.h>
18#endif
19#include <QtSql/private/qsqlresult_p.h>
20#include <QtSql/private/qsqldriver_p.h>
21#include "qsql_mimer.h"
22
23#define MIMER_DEFAULT_DATATYPE 1000
24
25Q_DECLARE_OPAQUE_POINTER(MimerSession)
26Q_DECLARE_METATYPE(MimerSession)
27
28Q_DECLARE_OPAQUE_POINTER(MimerStatement)
29Q_DECLARE_METATYPE(MimerStatement)
30
31QT_BEGIN_NAMESPACE
32
33enum class MimerColumnTypes {
34 Binary,
35 Clob,
36 Blob,
37 String,
38 Int,
39 Long,
40 Float,
41 Double,
42 Boolean,
43 Uuid,
44 Date,
45 Time,
46 Timestamp,
47 Unknown
48};
49
50using namespace Qt::StringLiterals;
51
52class QMimerSQLResultPrivate;
53
54class QMimerSQLResult final : public QSqlResult
55{
56 Q_DECLARE_PRIVATE(QMimerSQLResult)
57public:
58 QMimerSQLResult(const QMimerSQLDriver *db);
59 virtual ~QMimerSQLResult() override;
60 QVariant handle() const override;
61 static constexpr int genericError = -1;
62 static constexpr int lobChunkMaxSizeSet = 1048500;
63 static constexpr int lobChunkMaxSizeFetch = 65536;
64 static constexpr int maxStackStringSize = 200;
65 static constexpr int maxTimeStringSize = 18;
66 static constexpr int maxDateStringSize = 10;
67 static constexpr int maxTimestampStringSize = 29;
68
69private:
70 void cleanup();
71 bool fetch(int i) override;
72 bool fetchFirst() override;
73 bool fetchLast() override;
74 bool fetchNext() override;
75 QVariant data(int i) override;
76 bool isNull(int index) override;
77 bool reset(const QString &query) override;
78 int size() override;
79 int numRowsAffected() override;
80 QSqlRecord record() const override;
81 bool prepare(const QString &query) override;
82 bool execBatch(bool arrayBind = false) override;
83 bool exec() override;
84 qint64 currentRow();
85 QVariant lastInsertId() const override;
86};
87
88class QMimerSQLDriverPrivate final : public QSqlDriverPrivate
89{
90 Q_DECLARE_PUBLIC(QMimerSQLDriver)
91public:
92 QMimerSQLDriverPrivate() : QSqlDriverPrivate(QSqlDriver::MimerSQL), sessionhandle(nullptr) { }
93 MimerSession sessionhandle;
94 QString dbName;
95 QString dbUser;
96 void splitTableQualifier(const QString &qualifier, QString *schema, QString *table) const;
97};
98
99class QMimerSQLResultPrivate : public QSqlResultPrivate
100{
101 Q_DECLARE_PUBLIC(QMimerSQLResult)
102public:
103 Q_DECLARE_SQLDRIVER_PRIVATE(QMimerSQLDriver)
104 QMimerSQLResultPrivate(QMimerSQLResult *q, const QMimerSQLDriver *drv)
105 : QSqlResultPrivate(q, drv),
106 statementhandle(nullptr),
107 lobhandle(nullptr),
108 rowsAffected(0),
109 preparedQuery(false),
110 openCursor(false),
111 openStatement(false),
112 executedStatement(false),
113 callWithOut(false),
114 execBatch(false),
115 currentRow(QSql::BeforeFirstRow)
116 {
117 }
118 MimerStatement statementhandle;
119 MimerLob lobhandle;
120 int rowsAffected;
121 bool preparedQuery;
122 bool openCursor;
123 bool openStatement;
124 bool executedStatement;
125 bool callWithOut;
126 bool execBatch;
127 qint64 currentSize = -1;
128 qint64 currentRow; // Only used when forwardOnly()
129 QVector<QVariant> batch_vector;
130};
131
132static QSqlError qMakeError(const QString &err, const int errCode, QSqlError::ErrorType type,
133 const QMimerSQLDriverPrivate *p)
134{
135 QString msg;
136 if (p) {
137 size_t str_len;
138 int e_code;
139 int rc;
140 str_len = (rc = MimerGetError(p->sessionhandle, &e_code, NULL, 0)) + 1;
141 if (!MIMER_SUCCEEDED(rc)) {
142 msg = QCoreApplication::translate("QMimerSQL", "No Mimer SQL error for code %1")
143 .arg(errCode);
144 } else {
145 QVarLengthArray<wchar_t> tmp_buff((qsizetype)str_len);
146 if (!MIMER_SUCCEEDED(
147 rc = MimerGetError(p->sessionhandle, &e_code, tmp_buff.data(), str_len)))
148 msg = QCoreApplication::translate("QMimerSQL", "No Mimer SQL error for code %1")
149 .arg(errCode);
150 else
151 msg = QString::fromWCharArray(tmp_buff.data());
152 }
153 } else {
154 msg = QCoreApplication::translate("QMimerSQL", "Generic Mimer SQL error");
155 }
156
157 return QSqlError("QMIMER: "_L1 + err, msg, type, QString::number(errCode));
158}
159
160static QString msgCouldNotGet(const char *type, int column)
161{
162 //: Data type, column
163 return QCoreApplication::translate("QMimerSQLResult",
164 "Could not get %1, column %2").arg(QLatin1StringView(type)).arg(column);
165}
166
167static QString msgCouldNotSet(const char *type, int column)
168{
169 //: Data type, parameter
170 return QCoreApplication::translate("QMimerSQLResult",
171 "Could not set %1, parameter %2").arg(QLatin1StringView(type)).arg(column);
172}
173
174QMimerSQLDriver::QMimerSQLDriver(QObject *parent) : QSqlDriver(*new QMimerSQLDriverPrivate, parent)
175{
176}
177
178QMimerSQLDriver::QMimerSQLDriver(MimerSession *conn, QObject *parent)
179 : QSqlDriver(*new QMimerSQLDriverPrivate, parent)
180{
181 Q_D(QMimerSQLDriver);
182 if (conn)
183 d->sessionhandle = *conn;
184}
185
186QMimerSQLDriver::~QMimerSQLDriver()
187{
188 close();
189}
190
191QMimerSQLResult::QMimerSQLResult(const QMimerSQLDriver *db)
192 : QSqlResult(*new QMimerSQLResultPrivate(this, db))
193{
194 Q_D(QMimerSQLResult);
195 d->preparedQuery = db->hasFeature(QSqlDriver::PreparedQueries);
196}
197
198QMimerSQLResult::~QMimerSQLResult()
199{
200 cleanup();
201}
202
203static MimerColumnTypes mimerMapColumnTypes(int32_t t)
204{
205 switch (t) {
206 case MIMER_BINARY:
207 case MIMER_BINARY_VARYING:
208 return MimerColumnTypes::Binary;
209 case MIMER_BLOB:
210 case MIMER_NATIVE_BLOB:
211 return MimerColumnTypes::Blob;
212 case MIMER_CLOB:
213 case MIMER_NCLOB:
214 case MIMER_NATIVE_CLOB:
215 case MIMER_NATIVE_NCLOB:
216 return MimerColumnTypes::Clob;
217 case MIMER_DATE:
218 return MimerColumnTypes::Date;
219 case MIMER_TIME:
220 return MimerColumnTypes::Time;
221 case MIMER_TIMESTAMP:
222 return MimerColumnTypes::Timestamp;
223 case MIMER_INTERVAL_DAY:
224 case MIMER_DECIMAL:
225 case MIMER_INTERVAL_DAY_TO_HOUR:
226 case MIMER_INTERVAL_DAY_TO_MINUTE:
227 case MIMER_INTERVAL_DAY_TO_SECOND:
228 case MIMER_INTERVAL_HOUR:
229 case MIMER_INTERVAL_HOUR_TO_MINUTE:
230 case MIMER_INTERVAL_HOUR_TO_SECOND:
231 case MIMER_INTERVAL_MINUTE:
232 case MIMER_INTERVAL_MINUTE_TO_SECOND:
233 case MIMER_INTERVAL_MONTH:
234 case MIMER_INTERVAL_SECOND:
235 case MIMER_INTERVAL_YEAR:
236 case MIMER_INTERVAL_YEAR_TO_MONTH:
237 case MIMER_NCHAR:
238 case MIMER_CHARACTER:
239 case MIMER_CHARACTER_VARYING:
240 case MIMER_NCHAR_VARYING:
241 case MIMER_UTF8:
242 case MIMER_DEFAULT_DATATYPE:
243 return MimerColumnTypes::String;
244 case MIMER_BOOLEAN:
245 return MimerColumnTypes::Boolean;
246 case MIMER_T_BIGINT:
247 case MIMER_T_UNSIGNED_BIGINT:
248 case MIMER_NATIVE_BIGINT_NULLABLE:
249 case MIMER_NATIVE_BIGINT:
250 return MimerColumnTypes::Long;
251 case MIMER_T_FLOAT:
252 case MIMER_FLOAT:
253 return MimerColumnTypes::Float;
254 case MIMER_NATIVE_REAL_NULLABLE:
255 case MIMER_NATIVE_REAL:
256 case MIMER_T_REAL:
257 case MIMER_NATIVE_DOUBLE_NULLABLE:
258 case MIMER_NATIVE_DOUBLE:
259 case MIMER_T_DOUBLE:
260 return MimerColumnTypes::Double;
261 case MIMER_NATIVE_INTEGER:
262 case MIMER_NATIVE_INTEGER_NULLABLE:
263 case MIMER_INTEGER:
264 case MIMER_NATIVE_SMALLINT_NULLABLE:
265 case MIMER_NATIVE_SMALLINT:
266 case MIMER_T_INTEGER:
267 case MIMER_T_SMALLINT:
268 return MimerColumnTypes::Int;
269 case MIMER_UUID:
270 return MimerColumnTypes::Uuid;
271 default:
272 qWarning() << "QMimerSQLDriver::mimerMapColumnTypes: Unknown data type: " << t;
273 }
274 return MimerColumnTypes::Unknown;
275}
276
277static QMetaType::Type qDecodeMSQLType(int32_t t)
278{
279 switch (t) {
280 case MIMER_BINARY:
281 case MIMER_BINARY_VARYING:
282 case MIMER_BLOB:
283 case MIMER_NATIVE_BLOB:
284 return QMetaType::QByteArray;
285 case MIMER_CLOB:
286 case MIMER_NCLOB:
287 case MIMER_NATIVE_CLOB:
288 case MIMER_NATIVE_NCLOB:
289 case MIMER_INTERVAL_DAY:
290 case MIMER_DECIMAL:
291 case MIMER_INTERVAL_DAY_TO_HOUR:
292 case MIMER_INTERVAL_DAY_TO_MINUTE:
293 case MIMER_INTERVAL_DAY_TO_SECOND:
294 case MIMER_INTERVAL_HOUR:
295 case MIMER_INTERVAL_HOUR_TO_MINUTE:
296 case MIMER_INTERVAL_HOUR_TO_SECOND:
297 case MIMER_INTERVAL_MINUTE:
298 case MIMER_INTERVAL_MINUTE_TO_SECOND:
299 case MIMER_INTERVAL_MONTH:
300 case MIMER_INTERVAL_SECOND:
301 case MIMER_INTERVAL_YEAR:
302 case MIMER_INTERVAL_YEAR_TO_MONTH:
303 case MIMER_NCHAR:
304 case MIMER_CHARACTER:
305 case MIMER_CHARACTER_VARYING:
306 case MIMER_NCHAR_VARYING:
307 case MIMER_UTF8:
308 case MIMER_DEFAULT_DATATYPE:
309 return QMetaType::QString;
310 case MIMER_BOOLEAN:
311 return QMetaType::Bool;
312 case MIMER_T_BIGINT:
313 case MIMER_T_UNSIGNED_BIGINT:
314 case MIMER_NATIVE_BIGINT_NULLABLE:
315 case MIMER_NATIVE_BIGINT:
316 return QMetaType::LongLong;
317 case MIMER_T_FLOAT:
318 case MIMER_FLOAT:
319 return QMetaType::Float;
320 case MIMER_NATIVE_REAL_NULLABLE:
321 case MIMER_NATIVE_REAL:
322 case MIMER_T_REAL:
323 case MIMER_NATIVE_DOUBLE_NULLABLE:
324 case MIMER_NATIVE_DOUBLE:
325 case MIMER_T_DOUBLE:
326 return QMetaType::Double;
327 case MIMER_NATIVE_INTEGER_NULLABLE:
328 case MIMER_T_INTEGER:
329 case MIMER_INTEGER:
330 return QMetaType::Int;
331 case MIMER_NATIVE_SMALLINT_NULLABLE:
332 case MIMER_T_SMALLINT:
333 return QMetaType::Int;
334 case MIMER_DATE:
335 return QMetaType::QDate;
336 case MIMER_TIME:
337 return QMetaType::QTime;
338 break;
339 case MIMER_TIMESTAMP:
340 return QMetaType::QDateTime;
341 case MIMER_UUID:
342 return QMetaType::QUuid;
343 default:
344 qWarning() << "QMimerSQLDriver::qDecodeMSQLType: Unknown data type: " << t;
345 return QMetaType::UnknownType;
346 }
347}
348
349static int32_t qLookupMimDataType(QStringView s)
350{
351 if (s == u"BINARY")
352 return MIMER_BINARY;
353 if (s == u"BINARY VARYING")
354 return MIMER_BINARY_VARYING;
355 if (s == u"BINARY LARGE OBJECT")
356 return MIMER_BLOB;
357 if (s == u"CHARACTER LARGE OBJECT")
358 return MIMER_CLOB;
359 if (s == u"NATIONAL CHAR LARGE OBJECT")
360 return MIMER_NCLOB;
361 if (s == u"INTERVAL DAY")
362 return MIMER_INTERVAL_DAY;
363 if (s == u"DECIMAL")
364 return MIMER_DECIMAL;
365 if (s == u"INTERVAL DAY TO HOUR")
366 return MIMER_INTERVAL_DAY_TO_HOUR;
367 if (s == u"INTERVAL DAY TO MINUTE")
368 return MIMER_INTERVAL_DAY_TO_MINUTE;
369 if (s == u"INTERVAL DAY TO SECOND")
370 return MIMER_INTERVAL_DAY_TO_SECOND;
371 if (s == u"INTERVAL HOUR")
372 return MIMER_INTERVAL_HOUR;
373 if (s == u"INTERVAL HOUR TO MINUTE")
374 return MIMER_INTERVAL_HOUR_TO_MINUTE;
375 if (s == u"INTERVAL HOUR TO SECOND")
376 return MIMER_INTERVAL_HOUR_TO_SECOND;
377 if (s == u"INTERVAL MINUTE")
378 return MIMER_INTERVAL_MINUTE;
379 if (s == u"INTERVAL MINUTE TO SECOND")
380 return MIMER_INTERVAL_MINUTE_TO_SECOND;
381 if (s == u"INTERVAL MONTH")
382 return MIMER_INTERVAL_MONTH;
383 if (s == u"INTERVAL SECOND")
384 return MIMER_INTERVAL_SECOND;
385 if (s == u"INTERVAL YEAR")
386 return MIMER_INTERVAL_YEAR;
387 if (s == u"INTERVAL YEAR TO MONTH")
388 return MIMER_INTERVAL_YEAR_TO_MONTH;
389 if (s == u"NATIONAL CHARACTER")
390 return MIMER_NCHAR;
391 if (s == u"CHARACTER")
392 return MIMER_CHARACTER;
393 if (s == u"CHARACTER VARYING")
394 return MIMER_CHARACTER_VARYING;
395 if (s == u"NATIONAL CHARACTER VARYING")
396 return MIMER_NCHAR_VARYING;
397 if (s == u"UTF-8")
398 return MIMER_UTF8;
399 if (s == u"BOOLEAN")
400 return MIMER_BOOLEAN;
401 if (s == u"BIGINT")
402 return MIMER_T_BIGINT;
403 if (s == u"REAL")
404 return MIMER_T_REAL;
405 if (s == u"FLOAT")
406 return MIMER_T_FLOAT;
407 if (s == u"DOUBLE PRECISION")
408 return MIMER_T_DOUBLE;
409 if (s == u"INTEGER")
410 return MIMER_INTEGER;
411 if (s == u"SMALLINT")
412 return MIMER_T_SMALLINT;
413 if (s == u"DATE")
414 return MIMER_DATE;
415 if (s == u"TIME")
416 return MIMER_TIME;
417 if (s == u"TIMESTAMP")
418 return MIMER_TIMESTAMP;
419 if (s == u"BUILTIN.UUID")
420 return MIMER_UUID;
421 if (s == u"USER-DEFINED")
422 return MIMER_DEFAULT_DATATYPE;
423 qWarning() << "QMimerSQLDriver::qLookupMimDataType: Unhandled data type: " << s;
424 return MIMER_DEFAULT_DATATYPE;
425}
426
427QVariant QMimerSQLResult::handle() const
428{
429 Q_D(const QMimerSQLResult);
430 return QVariant::fromValue(d->statementhandle);
431}
432
433void QMimerSQLResult::cleanup()
434{
435 Q_D(QMimerSQLResult);
436 if (!driver() || !driver()->isOpen()) {
437 d->openCursor = false;
438 d->openStatement = false;
439 return;
440 }
441 if (d->openCursor) {
442 const int32_t err = MimerCloseCursor(d->statementhandle);
443 if (!MIMER_SUCCEEDED(err))
444 setLastError(qMakeError(
445 QCoreApplication::translate("QMimerSQLResult", "Could not close cursor"), err,
446 QSqlError::StatementError, d->drv_d_func()));
447 d->openCursor = false;
448 }
449 if (d->openStatement) {
450 const int32_t err = MimerEndStatement(&d->statementhandle);
451 if (!MIMER_SUCCEEDED(err))
452 setLastError(qMakeError(
453 QCoreApplication::translate("QMimerSQLResult", "Could not close statement"),
454 err, QSqlError::StatementError, d->drv_d_func()));
455 d->openStatement = false;
456 }
457 d->currentSize = -1;
458}
459
460qint64 QMimerSQLResult::currentRow()
461{
462 Q_D(const QMimerSQLResult);
463 return d->currentRow;
464}
465
466bool QMimerSQLResult::fetch(int i)
467{
468 Q_D(const QMimerSQLResult);
469 int32_t err = 0;
470 if (!isActive() || !isSelect())
471 return false;
472 if (i == at())
473 return true;
474 if (i < 0)
475 return false;
476
477 if (isForwardOnly() && i < at())
478 return false;
479
480 if (isForwardOnly()) {
481 bool rc;
482 do {
483 rc = fetchNext();
484 } while (rc && currentRow() < i);
485 return rc;
486 } else {
487 err = MimerFetchScroll(d->statementhandle, MIMER_ABSOLUTE, i + 1);
488 if (err == MIMER_NO_DATA)
489 return false;
490 }
491 if (!MIMER_SUCCEEDED(err)) {
492 setLastError(
493 qMakeError(QCoreApplication::translate("QMimerSQLResult", "Fetch did not succeed"),
494 err, QSqlError::StatementError, d->drv_d_func()));
495 return false;
496 }
497 setAt(MimerCurrentRow(d->statementhandle) - 1);
498 return true;
499}
500
501bool QMimerSQLResult::fetchFirst()
502{
503 Q_D(const QMimerSQLResult);
504 int32_t err = 0;
505 if (!isActive() || !isSelect())
506 return false;
507 if (isForwardOnly()) {
508 if (currentRow() < 0)
509 return fetchNext();
510 else if (currentRow() == 0)
511 setAt(0);
512 else
513 return false;
514 } else {
515 err = MimerFetchScroll(d->statementhandle, MIMER_FIRST, 0);
516 if (MIMER_SUCCEEDED(err) && err != MIMER_NO_DATA)
517 setAt(0);
518 }
519 if (!MIMER_SUCCEEDED(err)) {
520 setLastError(qMakeError(
521 QCoreApplication::translate("QMimerSQLResult", "Fetch first did not succeed"), err,
522 QSqlError::StatementError, d->drv_d_func()));
523 return false;
524 }
525 if (err == MIMER_NO_DATA)
526 return false;
527 return true;
528}
529
530bool QMimerSQLResult::fetchLast()
531{
532 Q_D(const QMimerSQLResult);
533 int32_t err = 0;
534 int row = 0;
535 if (!isActive() || !isSelect())
536 return false;
537 if (isForwardOnly()) {
538 bool rc;
539 do {
540 rc = fetchNext();
541 } while (rc);
542
543 return currentRow() >= 0;
544 } else {
545 err = MimerFetchScroll(d->statementhandle, static_cast<std::int32_t>(MIMER_LAST), 0);
546 if (err == MIMER_NO_DATA)
547 return false;
548 if (MIMER_SUCCEEDED(err)) {
549 row = MimerCurrentRow(d->statementhandle) - 1;
550 } else {
551 setLastError(qMakeError(
552 QCoreApplication::translate("QMimerSQLResult:", "Fetch last did not succeed"),
553 err, QSqlError::StatementError, d->drv_d_func()));
554 return false;
555 }
556 }
557
558 if (row < 0) {
559 setAt(QSql::BeforeFirstRow);
560 return false;
561 } else {
562 setAt(row);
563 return true;
564 }
565}
566
567bool QMimerSQLResult::fetchNext()
568{
569 Q_D(QMimerSQLResult);
570 int32_t err = 0;
571 if (!isActive() || !isSelect())
572 return false;
573 if (isForwardOnly())
574 err = MimerFetch(d->statementhandle);
575 else
576 err = MimerFetchScroll(d->statementhandle, MIMER_NEXT, 0);
577 if (!MIMER_SUCCEEDED(err)) {
578 setLastError(qMakeError(
579 QCoreApplication::translate("QMimerSQLResult", "Could not fetch next row"), err,
580 QSqlError::StatementError, d->drv_d_func()));
581 if (isForwardOnly())
582 d->currentRow = QSql::BeforeFirstRow;
583 return false;
584 }
585 if (err == MIMER_NO_DATA)
586 return false;
587 if (isForwardOnly())
588 setAt(++d->currentRow);
589 else
590 setAt(MimerCurrentRow(d->statementhandle) - 1);
591 return true;
592}
593
594QVariant QMimerSQLResult::data(int i)
595{
596 Q_D(QMimerSQLResult);
597 int32_t err;
598 int32_t mType;
599 if (d->callWithOut) {
600 if (i >= MimerParameterCount(d->statementhandle)) {
601 setLastError(qMakeError(
602 QCoreApplication::translate("QMimerSQLResult:", "Column %1 out of range")
603 .arg(i),
604 genericError, QSqlError::StatementError, nullptr));
605 return QVariant();
606 }
607 mType = MimerParameterType(d->statementhandle, static_cast<std::int16_t>(i) + 1);
608 } else {
609 if (i >= MimerColumnCount(d->statementhandle)) {
610 setLastError(qMakeError(
611 QCoreApplication::translate("QMimerSQLResult:", "Column %1 out of range")
612 .arg(i),
613 genericError, QSqlError::StatementError, nullptr));
614 return QVariant();
615 }
616 mType = MimerColumnType(d->statementhandle, static_cast<std::int16_t>(i) + 1);
617 }
618 const QMetaType::Type type = qDecodeMSQLType(mType);
619 const MimerColumnTypes mimDataType = mimerMapColumnTypes(mType);
620 err = MimerIsNull(d->statementhandle, static_cast<std::int16_t>(i) + 1);
621 if (err > 0) {
622 return QVariant(QMetaType(type), nullptr);
623 } else {
624 switch (mimDataType) {
625 case MimerColumnTypes::Date: {
626 wchar_t dateString_w[maxDateStringSize + 1];
627 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1, dateString_w,
628 sizeof(dateString_w) / sizeof(dateString_w[0]));
629 if (!MIMER_SUCCEEDED(err)) {
630 setLastError(qMakeError(msgCouldNotGet("date", i),
631 err, QSqlError::StatementError, d->drv_d_func()));
632 return QVariant(QMetaType(type), nullptr);
633 }
634 return QDate::fromString(QString::fromWCharArray(dateString_w), "yyyy-MM-dd"_L1);
635 }
636 case MimerColumnTypes::Time: {
637 wchar_t timeString_w[maxTimeStringSize + 1];
638 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1, timeString_w,
639 sizeof(timeString_w) / sizeof(timeString_w[0]));
640 if (!MIMER_SUCCEEDED(err)) {
641 setLastError(qMakeError(msgCouldNotGet("time", i),
642 err, QSqlError::StatementError, d->drv_d_func()));
643 return QVariant(QMetaType(type), nullptr);
644 }
645 QString timeString = QString::fromWCharArray(timeString_w);
646 QString timeFormatString = "HH:mm:ss"_L1;
647 if (timeString.size() > 8) {
648 timeFormatString.append(".zzz"_L1);
649 timeString = timeString.left(12);
650 }
651 return QTime::fromString(timeString, timeFormatString);
652 }
653 case MimerColumnTypes::Timestamp: {
654 wchar_t dateTimeString_w[maxTimestampStringSize + 1];
655 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1,
656 dateTimeString_w,
657 sizeof(dateTimeString_w) / sizeof(dateTimeString_w[0]));
658 if (!MIMER_SUCCEEDED(err)) {
659 setLastError(
660 qMakeError(msgCouldNotGet("date time", i),
661 err, QSqlError::StatementError, d->drv_d_func()));
662 return QVariant(QMetaType(type), nullptr);
663 }
664 QString dateTimeString = QString::fromWCharArray(dateTimeString_w);
665 QString dateTimeFormatString = "yyyy-MM-dd HH:mm:ss"_L1;
666 if (dateTimeString.size() > 19) {
667 dateTimeFormatString.append(".zzz"_L1);
668 dateTimeString = dateTimeString.left(23);
669 }
670 return QDateTime::fromString(dateTimeString, dateTimeFormatString);
671 }
672 case MimerColumnTypes::Int: {
673 int resInt;
674 err = MimerGetInt32(d->statementhandle, static_cast<std::int16_t>(i) + 1, &resInt);
675 if (!MIMER_SUCCEEDED(err)) {
676 setLastError(qMakeError(msgCouldNotGet("int32", i),
677 err, QSqlError::StatementError, d->drv_d_func()));
678 return QVariant(QMetaType(type), nullptr);
679 }
680 return resInt;
681 }
682 case MimerColumnTypes::Long: {
683 int64_t resLongLong;
684 err = MimerGetInt64(d->statementhandle, static_cast<std::int16_t>(i) + 1, &resLongLong);
685 if (!MIMER_SUCCEEDED(err)) {
686 setLastError(qMakeError(msgCouldNotGet("int64", i),
687 err, QSqlError::StatementError, d->drv_d_func()));
688 return QVariant(QMetaType(type), nullptr);
689 }
690 return QString::number(resLongLong).toLongLong();
691 }
692 case MimerColumnTypes::Boolean: {
693 err = MimerGetBoolean(d->statementhandle, static_cast<std::int16_t>(i) + 1);
694 if (!MIMER_SUCCEEDED(err)) {
695 setLastError(
696 qMakeError(msgCouldNotGet("boolean", i),
697 err, QSqlError::StatementError, d->drv_d_func()));
698 return QVariant(QMetaType(type), nullptr);
699 }
700 return err == 1;
701 }
702 case MimerColumnTypes::Float: {
703 float resFloat;
704 err = MimerGetFloat(d->statementhandle, static_cast<std::int16_t>(i) + 1, &resFloat);
705 if (!MIMER_SUCCEEDED(err)) {
706 setLastError(qMakeError(msgCouldNotGet("float", i),
707 err, QSqlError::StatementError, d->drv_d_func()));
708 return QVariant(QMetaType(type), nullptr);
709 }
710 return resFloat;
711 }
712 case MimerColumnTypes::Double: {
713 double resDouble;
714 err = MimerGetDouble(d->statementhandle, static_cast<std::int16_t>(i) + 1, &resDouble);
715 if (!MIMER_SUCCEEDED(err)) {
716 setLastError(
717 qMakeError(msgCouldNotGet("double", i),
718 err, QSqlError::StatementError, d->drv_d_func()));
719 return QVariant(QMetaType(type), nullptr);
720 }
721 switch (numericalPrecisionPolicy()) {
722 case QSql::LowPrecisionInt32:
723 return static_cast<std::int32_t>(resDouble);
724 case QSql::LowPrecisionInt64:
725 return static_cast<qint64>(resDouble);
726 case QSql::LowPrecisionDouble:
727 return resDouble;
728 case QSql::HighPrecision:
729 return QString::number(resDouble, 'g', 17);
730 }
731 return QVariant(QMetaType(type), nullptr);
732 }
733 case MimerColumnTypes::Binary: {
734 QByteArray byteArray;
735 // Get size
736 err = MimerGetBinary(d->statementhandle, static_cast<std::int16_t>(i) + 1, NULL, 0);
737 if (MIMER_SUCCEEDED(err)) {
738 byteArray.resize(err);
739 err = MimerGetBinary(d->statementhandle, static_cast<std::int16_t>(i) + 1,
740 byteArray.data(), err);
741 }
742 if (!MIMER_SUCCEEDED(err)) {
743 setLastError(
744 qMakeError(msgCouldNotGet("binary", i),
745 err, QSqlError::StatementError, d->drv_d_func()));
746 return QVariant(QMetaType(type), nullptr);
747 }
748 return byteArray;
749 }
750 case MimerColumnTypes::Blob: {
751 QByteArray byteArray;
752 size_t size;
753 err = MimerGetLob(d->statementhandle, static_cast<std::int16_t>(i) + 1, &size,
754 &d->lobhandle);
755 if (MIMER_SUCCEEDED(err)) {
756 constexpr size_t maxSize = lobChunkMaxSizeFetch;
757 QVarLengthArray<char> blobchar(lobChunkMaxSizeFetch);
758 byteArray.reserve(size);
759 size_t left_to_return = size;
760 while (left_to_return > 0) {
761 const size_t bytesToReceive =
762 left_to_return <= maxSize ? left_to_return : maxSize;
763 err = MimerGetBlobData(&d->lobhandle, blobchar.data(), bytesToReceive);
764 byteArray.append(QByteArray::fromRawData(blobchar.data(), bytesToReceive));
765 left_to_return -= bytesToReceive;
766 if (!MIMER_SUCCEEDED(err)) {
767 setLastError(qMakeError(msgCouldNotGet("BLOB", i),
768 err, QSqlError::StatementError, d->drv_d_func()));
769 return QVariant(QMetaType(type), nullptr);
770 }
771 }
772 } else {
773 setLastError(qMakeError(msgCouldNotGet("BLOB", i),
774 err, QSqlError::StatementError, d->drv_d_func()));
775 return QVariant(QMetaType(type), nullptr);
776 }
777 return byteArray;
778 }
779 case MimerColumnTypes::String: {
780 wchar_t resString_w[maxStackStringSize + 1];
781 // Get size
782 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1, resString_w,
783 0);
784 if (MIMER_SUCCEEDED(err)) {
785 int size = err;
786 if (err <= maxStackStringSize) { // For smaller strings, use a small buffer for
787 // efficiency
788 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1,
789 resString_w, maxStackStringSize + 1);
790 if (MIMER_SUCCEEDED(err))
791 return QString::fromWCharArray(resString_w);
792 } else { // For larger strings, dynamically allocate memory
793 QVarLengthArray<wchar_t> largeResString_w(size + 1);
794 err = MimerGetString(d->statementhandle, static_cast<std::int16_t>(i) + 1,
795 largeResString_w.data(), size + 1);
796 if (MIMER_SUCCEEDED(err))
797 return QString::fromWCharArray(largeResString_w.data());
798 }
799 }
800 setLastError(qMakeError(msgCouldNotGet("string", i),
801 err, QSqlError::StatementError, d->drv_d_func()));
802 return QVariant(QMetaType(type), nullptr);
803 }
804 case MimerColumnTypes::Clob: {
805 size_t size;
806 err = MimerGetLob(d->statementhandle, static_cast<std::int16_t>(i) + 1, &size,
807 &d->lobhandle);
808 if (MIMER_SUCCEEDED(err)) {
809 constexpr size_t maxSize = lobChunkMaxSizeFetch;
810 QVarLengthArray<wchar_t> clobstring_w(lobChunkMaxSizeFetch + 1);
811
812 size_t left_to_return = size;
813 QString returnString;
814 while (left_to_return > 0) {
815 const size_t bytesToReceive =
816 left_to_return <= maxSize ? left_to_return : maxSize;
817 err = MimerGetNclobData(&d->lobhandle, clobstring_w.data(), bytesToReceive + 1);
818 returnString.append(QString::fromWCharArray(clobstring_w.data()));
819 left_to_return -= bytesToReceive;
820 if (!MIMER_SUCCEEDED(err)) {
821 setLastError(qMakeError(msgCouldNotGet("CLOB", i),
822 err, QSqlError::StatementError, d->drv_d_func()));
823 return QVariant(QMetaType(type), nullptr);
824 }
825 }
826 return returnString;
827 }
828 setLastError(qMakeError(msgCouldNotGet("CLOB", i),
829 err, QSqlError::StatementError, d->drv_d_func()));
830 return QVariant(QMetaType(type), nullptr);
831 }
832 case MimerColumnTypes::Uuid: {
833 unsigned char uuidChar[16];
834 err = MimerGetUUID(d->statementhandle, static_cast<std::int16_t>(i) + 1, uuidChar);
835 if (!MIMER_SUCCEEDED(err)) {
836 setLastError(qMakeError(msgCouldNotGet("UUID", i),
837 err, QSqlError::StatementError, d->drv_d_func()));
838 return QVariant(QMetaType(type), nullptr);
839 }
840 const QByteArray uuidByteArray = QByteArray(reinterpret_cast<char *>(uuidChar), 16);
841 return QUuid::fromRfc4122(uuidByteArray);
842 }
843 case MimerColumnTypes::Unknown:
844 default:
845 setLastError(qMakeError(
846 QCoreApplication::translate("QMimerSQLResult", "Unknown data type %1").arg(i),
847 genericError, QSqlError::StatementError, nullptr));
848 }
849 return QVariant(QMetaType(type), nullptr);
850 }
851}
852
853bool QMimerSQLResult::isNull(int index)
854{
855 Q_D(const QMimerSQLResult);
856 const int32_t rc = MimerIsNull(d->statementhandle, static_cast<std::int16_t>(index) + 1);
857 if (!MIMER_SUCCEEDED(rc)) {
858 setLastError(qMakeError(
859 QCoreApplication::translate("QMimerSQLResult", "Could not check null, column %1")
860 .arg(index),
861 rc, QSqlError::StatementError, d->drv_d_func()));
862 return false;
863 }
864 return rc != 0;
865}
866
867bool QMimerSQLResult::reset(const QString &query)
868{
869 if (!prepare(query))
870 return false;
871 return exec();
872}
873
874int QMimerSQLResult::size()
875{
876 Q_D(QMimerSQLResult);
877 if (!isActive() || !isSelect() || isForwardOnly())
878 return -1;
879
880 if (d->currentSize != -1)
881 return d->currentSize;
882
883 const int currentRow = MimerCurrentRow(d->statementhandle);
884 MimerFetchScroll(d->statementhandle, static_cast<std::int32_t>(MIMER_LAST), 0);
885 int size = MimerCurrentRow(d->statementhandle);
886 if (!MIMER_SUCCEEDED(size))
887 size = -1;
888 MimerFetchScroll(d->statementhandle, MIMER_ABSOLUTE, currentRow);
889 d->currentSize = size;
890 return size;
891}
892
893int QMimerSQLResult::numRowsAffected()
894{
895 Q_D(const QMimerSQLResult);
896 return d->rowsAffected;
897}
898
899QSqlRecord QMimerSQLResult::record() const
900{
901 Q_D(const QMimerSQLResult);
902 QSqlRecord rec;
903 if (!isActive() || !isSelect() || !driver())
904 return rec;
905 QSqlField field;
906 const int colSize = MimerColumnCount(d->statementhandle);
907 for (int i = 0; i < colSize; i++) {
908 wchar_t colName_w[100];
909 MimerColumnName(d->statementhandle, static_cast<std::int16_t>(i) + 1, colName_w,
910 sizeof(colName_w) / sizeof(colName_w[0]));
911 field.setName(QString::fromWCharArray(colName_w));
912 const int32_t mType = MimerColumnType(d->statementhandle, static_cast<std::int16_t>(i) + 1);
913 const QMetaType::Type type = qDecodeMSQLType(mType);
914 field.setSqlType(mType);
915 field.setMetaType(QMetaType(type));
916 field.setValue(QVariant(field.metaType()));
917 // field.setPrecision(); Should be implemented once the Mimer API can give this
918 // information.
919 // field.setLength(); Should be implemented once the Mimer API can give
920 // this information.
921 rec.insert(i, field);
922 }
923 return rec;
924}
925
926bool QMimerSQLResult::prepare(const QString &query)
927{
928 Q_D(QMimerSQLResult);
929 int32_t err;
930 if (!driver())
931 return false;
932 if (!d->preparedQuery)
933 return QSqlResult::prepare(query);
934 if (query.isEmpty())
935 return false;
936 cleanup();
937 const int option = isForwardOnly() ? MIMER_FORWARD_ONLY : MIMER_SCROLLABLE;
938 err = MimerBeginStatement8(d->drv_d_func()->sessionhandle, query.toUtf8().constData(), option,
939 &d->statementhandle);
940 if (err == MIMER_STATEMENT_CANNOT_BE_PREPARED) {
941 err = MimerExecuteStatement8(d->drv_d_func()->sessionhandle, query.toUtf8().constData());
942 if (MIMER_SUCCEEDED(err)) {
943 d->executedStatement = true;
944 d->openCursor = false;
945 d->openStatement = false;
946 return true;
947 }
948 }
949 if (!MIMER_SUCCEEDED(err)) {
950 setLastError(qMakeError(QCoreApplication::translate("QMimerSQLResult",
951 "Could not prepare/execute statement"),
952 err, QSqlError::StatementError, d->drv_d_func()));
953 return false;
954 }
955 d->openStatement = true;
956 return true;
957}
958
959bool QMimerSQLResult::exec()
960{
961 Q_D(QMimerSQLResult);
962 int32_t err;
963 if (!driver())
964 return false;
965 if (!d->preparedQuery)
966 return QSqlResult::exec();
967 if (d->executedStatement) {
968 d->executedStatement = false;
969 return true;
970 }
971 if (d->openCursor) {
972 setAt(QSql::BeforeFirstRow);
973 err = MimerCloseCursor(d->statementhandle);
974 d->openCursor = false;
975 d->currentSize = -1;
976 }
977 QVector<QVariant> &values = boundValues();
978 if (d->execBatch)
979 values = d->batch_vector;
980 int mimParamCount = MimerParameterCount(d->statementhandle);
981 if (!MIMER_SUCCEEDED(mimParamCount))
982 mimParamCount = 0;
983 if (mimParamCount != values.size()) {
984 setLastError(qMakeError(
985 QCoreApplication::translate("QMimerSQLResult", "Wrong number of parameters"),
986 genericError, QSqlError::StatementError, nullptr));
987 return false;
988 }
989 for (int i = 0; i < mimParamCount; i++) {
990 if (bindValueType(i) == QSql::Out) {
991 d->callWithOut = true;
992 continue;
993 }
994 const QVariant &val = values.at(i);
995 if (QSqlResultPrivate::isVariantNull(val) || val.isNull() || val.toString().isNull()) {
996 err = MimerSetNull(d->statementhandle, i + 1);
997 if (!MIMER_SUCCEEDED(err)) {
998 setLastError(
999 qMakeError(msgCouldNotSet("null", i),
1000 err, QSqlError::StatementError, d->drv_d_func()));
1001 return false;
1002 }
1003 continue;
1004 }
1005
1006 const int mimParamType = MimerParameterType(d->statementhandle, i + 1);
1007 const MimerColumnTypes mimDataType = mimerMapColumnTypes(mimParamType);
1008 switch (mimDataType) {
1009 case MimerColumnTypes::Int: {
1010 bool convertOk;
1011 err = MimerSetInt32(d->statementhandle, i + 1, val.toInt(&convertOk));
1012 if (!convertOk || !MIMER_SUCCEEDED(err)) {
1013 setLastError(
1014 qMakeError(msgCouldNotSet("int32", i),
1015 convertOk ? err : genericError, QSqlError::StatementError,
1016 convertOk ? d->drv_d_func() : nullptr));
1017 return false;
1018 }
1019 break;
1020 }
1021 case MimerColumnTypes::Long: {
1022 bool convertOk;
1023 err = MimerSetInt64(d->statementhandle, i + 1, val.toLongLong(&convertOk));
1024 if (!convertOk || !MIMER_SUCCEEDED(err)) {
1025 setLastError(
1026 qMakeError(msgCouldNotSet("int64", i),
1027 convertOk ? err : genericError, QSqlError::StatementError,
1028 convertOk ? d->drv_d_func() : nullptr));
1029 return false;
1030 }
1031 break;
1032 }
1033 case MimerColumnTypes::Float: {
1034 bool convertOk;
1035 err = MimerSetFloat(d->statementhandle, i + 1, val.toFloat(&convertOk));
1036 if (!convertOk || !MIMER_SUCCEEDED(err)) {
1037 setLastError(
1038 qMakeError(msgCouldNotSet("float", i),
1039 convertOk ? err : genericError, QSqlError::StatementError,
1040 convertOk ? d->drv_d_func() : nullptr));
1041 return false;
1042 }
1043 break;
1044 }
1045 case MimerColumnTypes::Double: {
1046 bool convertOk;
1047 err = MimerSetDouble(d->statementhandle, i + 1, val.toDouble(&convertOk));
1048 if (!convertOk || !MIMER_SUCCEEDED(err)) {
1049 setLastError(
1050 qMakeError(msgCouldNotSet("double", i),
1051 convertOk ? err : genericError, QSqlError::StatementError,
1052 convertOk ? d->drv_d_func() : nullptr));
1053 return false;
1054 }
1055 break;
1056 }
1057 case MimerColumnTypes::Binary: {
1058 const QByteArray binArr = val.toByteArray();
1059 size_t size = static_cast<std::size_t>(binArr.size());
1060 err = MimerSetBinary(d->statementhandle, i + 1, binArr.data(), size);
1061 if (!MIMER_SUCCEEDED(err)) {
1062 setLastError(
1063 qMakeError(msgCouldNotSet("binary", i),
1064 err, QSqlError::StatementError, d->drv_d_func()));
1065 return false;
1066 }
1067 break;
1068 }
1069 case MimerColumnTypes::Boolean: {
1070 err = MimerSetBoolean(d->statementhandle, i + 1, val.toBool() == true ? 1 : 0);
1071 if (!MIMER_SUCCEEDED(err)) {
1072 setLastError(
1073 qMakeError(msgCouldNotSet("boolean", i),
1074 err, QSqlError::StatementError, d->drv_d_func()));
1075 return false;
1076 }
1077 break;
1078 }
1079 case MimerColumnTypes::Uuid: {
1080 const QByteArray uuidArray =
1081 QByteArray::fromHex(val.toUuid().toString(QUuid::WithoutBraces).toLatin1());
1082 const unsigned char *uuid =
1083 reinterpret_cast<const unsigned char *>(uuidArray.constData());
1084 err = MimerSetUUID(d->statementhandle, i + 1, uuid);
1085 if (!MIMER_SUCCEEDED(err)) {
1086 setLastError(
1087 qMakeError(msgCouldNotSet("UUID", i),
1088 err, QSqlError::StatementError, d->drv_d_func()));
1089 return false;
1090 }
1091 break;
1092 }
1093 case MimerColumnTypes::String: {
1094 QByteArray string_b = val.toString().trimmed().toUtf8();
1095 const char *string_u = string_b.constData();
1096 err = MimerSetString8(d->statementhandle, i + 1, string_u);
1097 if (!MIMER_SUCCEEDED(err)) {
1098 setLastError(
1099 qMakeError(msgCouldNotSet("string", i),
1100 err, QSqlError::StatementError, d->drv_d_func()));
1101 return false;
1102 }
1103 break;
1104 }
1105 case MimerColumnTypes::Date: {
1106 err = MimerSetString8(d->statementhandle, i + 1, val.toString().toUtf8().constData());
1107 if (!MIMER_SUCCEEDED(err)) {
1108 setLastError(
1109 qMakeError(msgCouldNotSet("date", i),
1110 err, QSqlError::StatementError, d->drv_d_func()));
1111 return false;
1112 }
1113 break;
1114 }
1115 case MimerColumnTypes::Time: {
1116 QString timeFormatString = "hh:mm:ss"_L1;
1117 const QTime timeVal = val.toTime();
1118 if (timeVal.msec() > 0)
1119 timeFormatString.append(".zzz"_L1);
1120 err = MimerSetString8(d->statementhandle, i + 1,
1121 timeVal.toString(timeFormatString).toUtf8().constData());
1122 if (!MIMER_SUCCEEDED(err)) {
1123 setLastError(
1124 qMakeError(msgCouldNotSet("time", i),
1125 err, QSqlError::StatementError, d->drv_d_func()));
1126 return false;
1127 }
1128 break;
1129 }
1130 case MimerColumnTypes::Timestamp: {
1131 QString dateTimeFormatString = "yyyy-MM-dd hh:mm:ss"_L1;
1132 const QDateTime dateTimeVal = val.toDateTime();
1133 if (dateTimeVal.time().msec() > 0)
1134 dateTimeFormatString.append(".zzz"_L1);
1135 err = MimerSetString8(
1136 d->statementhandle, i + 1,
1137 val.toDateTime().toString(dateTimeFormatString).toUtf8().constData());
1138 if (!MIMER_SUCCEEDED(err)) {
1139 setLastError(qMakeError(msgCouldNotSet("datetime", i),
1140 err, QSqlError::StatementError, d->drv_d_func()));
1141 return false;
1142 }
1143 break;
1144 }
1145 case MimerColumnTypes::Blob: {
1146 QByteArray blobArr = val.toByteArray();
1147 const char *blobData = blobArr.constData();
1148 qsizetype size = blobArr.size();
1149 err = MimerSetLob(d->statementhandle, i + 1, size, &d->lobhandle);
1150 if (MIMER_SUCCEEDED(err)) {
1151 qsizetype maxSize = lobChunkMaxSizeSet;
1152 if (size > maxSize) {
1153 qsizetype left_to_send = size;
1154 for (qsizetype k = 0; left_to_send > 0; k++) {
1155 if (left_to_send <= maxSize) {
1156 err = MimerSetBlobData(&d->lobhandle, &blobData[k * maxSize],
1157 left_to_send);
1158 left_to_send = 0;
1159 } else {
1160 err = MimerSetBlobData(&d->lobhandle, &blobData[k * maxSize], maxSize);
1161 left_to_send = left_to_send - maxSize;
1162 }
1163 }
1164 if (!MIMER_SUCCEEDED(err)) {
1165 setLastError(
1166 qMakeError(msgCouldNotSet("BLOB byte array", i),
1167 err, QSqlError::StatementError, d->drv_d_func()));
1168 return false;
1169 }
1170 } else {
1171 err = MimerSetBlobData(&d->lobhandle, blobArr, size);
1172 }
1173 }
1174 if (!MIMER_SUCCEEDED(err)) {
1175 setLastError(qMakeError(msgCouldNotSet("BLOB byte array", i),
1176 err, QSqlError::StatementError, d->drv_d_func()));
1177 return false;
1178 }
1179 break;
1180 }
1181 case MimerColumnTypes::Clob: {
1182 QByteArray string_b = val.toString().trimmed().toUtf8();
1183 const char *string_u = string_b.constData();
1184 size_t size_c = 1;
1185 size_t size = 0;
1186 while (string_u[size++])
1187 if ((string_u[size] & 0xc0) != 0x80)
1188 size_c++;
1189 err = MimerSetLob(d->statementhandle, i + 1, size_c, &d->lobhandle);
1190 if (MIMER_SUCCEEDED(err)) {
1191 constexpr size_t maxSize = lobChunkMaxSizeSet;
1192 if (size > maxSize) {
1193 size_t left_to_send = size;
1194 size_t pos = 0;
1195 uint step_back = 0;
1196 while (left_to_send > 0 && step_back < maxSize) {
1197 step_back = 0;
1198 if (left_to_send <= maxSize) {
1199 err = MimerSetNclobData8(&d->lobhandle, &string_u[pos], left_to_send);
1200 left_to_send = 0;
1201 } else {
1202 // Check that we don't split a multi-byte utf-8 characters
1203 while (pos + maxSize - step_back > 0
1204 && (string_u[pos + maxSize - step_back] & 0xc0) == 0x80)
1205 step_back++;
1206 err = MimerSetNclobData8(&d->lobhandle, &string_u[pos],
1207 maxSize - step_back);
1208 left_to_send = left_to_send - maxSize + step_back;
1209 pos += maxSize - step_back;
1210 }
1211 if (!MIMER_SUCCEEDED(err)) {
1212 setLastError(qMakeError(msgCouldNotSet("CLOB", i),
1213 err, QSqlError::StatementError, d->drv_d_func()));
1214 return false;
1215 }
1216 }
1217 } else {
1218 err = MimerSetNclobData8(&d->lobhandle, string_u, size);
1219 }
1220 }
1221 if (!MIMER_SUCCEEDED(err)) {
1222 setLastError(
1223 qMakeError(msgCouldNotSet("CLOB", i),
1224 err, QSqlError::StatementError, d->drv_d_func()));
1225 return false;
1226 }
1227 break;
1228 }
1229 case MimerColumnTypes::Unknown:
1230 default:
1231 setLastError(qMakeError(
1232 QCoreApplication::translate("QMimerSQLResult", "Unknown datatype, parameter %1")
1233 .arg(i),
1234 genericError, QSqlError::StatementError, nullptr));
1235 return false;
1236 }
1237 }
1238 if (d->execBatch)
1239 return true;
1240 err = MimerExecute(d->statementhandle);
1241 if (MIMER_SUCCEEDED(err)) {
1242 d->rowsAffected = err;
1243 int k = 0;
1244 for (qsizetype i = 0; i < values.size(); i++) {
1245 if (bindValueType(i) == QSql::Out || bindValueType(i) == QSql::InOut) {
1246 bindValue(i, data(k), QSql::In);
1247 k++;
1248 }
1249 }
1250 d->callWithOut = false;
1251 }
1252 setSelect(false);
1253 if (MIMER_SEQUENCE_ERROR == err) {
1254 err = MimerOpenCursor(d->statementhandle);
1255 d->rowsAffected = err;
1256 d->openCursor = true;
1257 d->currentRow = QSql::BeforeFirstRow;
1258 setSelect(true);
1259 }
1260 if (!MIMER_SUCCEEDED(err)) {
1261 setLastError(
1262 qMakeError(QCoreApplication::translate("QMimerSQLResult",
1263 "Could not execute statement/open cursor"),
1264 err, QSqlError::StatementError, d->drv_d_func()));
1265 return false;
1266 }
1267 setActive(true);
1268 return true;
1269}
1270
1271bool QMimerSQLResult::execBatch(bool arrayBind)
1272{
1273 Q_D(QMimerSQLResult);
1274 Q_UNUSED(arrayBind);
1275 int32_t err;
1276 const QVector<QVariant> values = boundValues();
1277
1278 // Check that we only have input parameters. Currently
1279 // we can only handle batch operations without output parameters.
1280 for (qsizetype i = 0; i < values.first().toList().size(); i++)
1281 if (bindValueType(i) == QSql::Out || bindValueType(i) == QSql::InOut) {
1282 setLastError(qMakeError(QCoreApplication::translate(
1283 "QMimerSQLResult",
1284 "Only input parameter can be used in batch operations"),
1285 genericError, QSqlError::StatementError, nullptr));
1286 d->execBatch = false;
1287 return false;
1288 }
1289 d->execBatch = true;
1290 for (qsizetype i = 0; i < values.first().toList().size(); i++) {
1291 for (qsizetype j = 0; j < values.size(); j++)
1292 d->batch_vector.append(values.at(j).toList().at(i));
1293 exec();
1294 if (i != (values.at(0).toList().size() - 1)) {
1295 err = MimerAddBatch(d->statementhandle);
1296 if (!MIMER_SUCCEEDED(err)) {
1297 setLastError(qMakeError(
1298 QCoreApplication::translate("QMimerSQLResult", "Could not add batch %1")
1299 .arg(i),
1300 err, QSqlError::StatementError, d->drv_d_func()));
1301 d->execBatch = false;
1302 return false;
1303 }
1304 }
1305 d->batch_vector.clear();
1306 }
1307 d->execBatch = false;
1308 err = MimerExecute(d->statementhandle);
1309 if (!MIMER_SUCCEEDED(err)) {
1310 setLastError(qMakeError(
1311 QCoreApplication::translate("QMimerSQLResult", "Could not execute batch"), err,
1312 QSqlError::StatementError, d->drv_d_func()));
1313 return false;
1314 }
1315 return true;
1316}
1317
1318QVariant QMimerSQLResult::lastInsertId() const
1319{
1320 Q_D(const QMimerSQLResult);
1321 int64_t lastSequence;
1322 const int32_t err = MimerGetSequenceInt64(d->statementhandle, &lastSequence);
1323 if (!MIMER_SUCCEEDED(err))
1324 return QVariant(QMetaType(QMetaType::LongLong), nullptr);
1325 return QVariant(qint64(lastSequence));
1326}
1327
1328bool QMimerSQLDriver::hasFeature(DriverFeature f) const
1329{
1330 switch (f) {
1331 case NamedPlaceholders: // Is true in reality but Qt parses Sql statement...
1332 case EventNotifications:
1333 case LowPrecisionNumbers:
1334 case MultipleResultSets:
1335 case SimpleLocking:
1336 case CancelQuery:
1337 return false;
1338 case FinishQuery:
1339 case LastInsertId:
1340 case Transactions:
1341 case QuerySize:
1342 case BLOB:
1343 case Unicode:
1344 case PreparedQueries:
1345 case PositionalPlaceholders:
1346 case BatchOperations:
1347 return true;
1348 }
1349 return true;
1350}
1351
1352bool QMimerSQLDriver::open(const QString &db, const QString &user, const QString &password,
1353 const QString &host, int port, const QString &connOpts)
1354{
1355 Q_D(QMimerSQLDriver);
1356 Q_UNUSED(host);
1357 Q_UNUSED(port);
1358 Q_UNUSED(connOpts);
1359 if (isOpen())
1360 close();
1361 const int32_t err = MimerBeginSession8(db.toUtf8().constData(), user.toUtf8().constData(),
1362 password.toUtf8().constData(), &d->sessionhandle);
1363 if (!MIMER_SUCCEEDED(err)) {
1364 setLastError(qMakeError(
1365 QCoreApplication::translate("QMimerSQLDriver", "Could not connect to database")
1366 + " "_L1 + db,
1367 err, QSqlError::ConnectionError, nullptr));
1368 setOpenError(true);
1369 return false;
1370 }
1371 d->dbUser = user;
1372 d->dbName = db;
1373 setOpen(true);
1374 setOpenError(false);
1375 return true;
1376}
1377
1378void QMimerSQLDriver::close()
1379{
1380 Q_D(QMimerSQLDriver);
1381 if (isOpen()) {
1382 const int end_err = MimerEndSession(&d->sessionhandle);
1383 if (MIMER_SUCCEEDED(end_err)) {
1384 setOpen(false);
1385 setOpenError(false);
1386 }
1387 }
1388}
1389
1390QSqlResult *QMimerSQLDriver::createResult() const
1391{
1392 return new QMimerSQLResult(this);
1393}
1394
1395QStringList QMimerSQLDriver::tables(QSql::TableType type) const
1396{
1397 QStringList tl;
1398 if (!isOpen())
1399 return tl;
1400 QSqlQuery t(createResult());
1401 QString sql;
1402 switch (type) {
1403 case QSql::Tables: {
1404 sql = "select table_name from information_schema.tables where "
1405 "table_type=\'BASE TABLE\' AND table_schema = CURRENT_USER"_L1;
1406 break;
1407 }
1408 case QSql::SystemTables: {
1409 sql = "select table_name from information_schema.tables where "
1410 "table_type=\'BASE TABLE\' AND table_schema = \'SYSTEM\'"_L1;
1411 break;
1412 }
1413 case QSql::Views: {
1414 sql = "select table_name from information_schema.tables where "
1415 "table_type=\'VIEW\' AND table_schema = CURRENT_USER"_L1;
1416 break;
1417 }
1418 case QSql::AllTables: {
1419 sql = "select table_name from information_schema.tables where "
1420 "(table_type=\'VIEW\' or table_type=\'BASE TABLE\')"
1421 " AND (table_schema = CURRENT_USER OR table_schema =\'SYSTEM\')"_L1;
1422 break;
1423 }
1424 default:
1425 break;
1426 }
1427 if (sql.length() > 0) {
1428 t.exec(sql);
1429 while (t.next())
1430 tl.append(t.value(0).toString());
1431 }
1432 return tl;
1433}
1434
1435QSqlIndex QMimerSQLDriver::primaryIndex(const QString &tablename) const
1436{
1437 Q_D(const QMimerSQLDriver);
1438 if (!isOpen())
1439 return QSqlIndex();
1440 QString table = tablename;
1441 if (isIdentifierEscaped(table, QSqlDriver::TableName))
1442 table = stripDelimiters(table, QSqlDriver::TableName);
1443 QSqlIndex index(tablename);
1444 QSqlQuery t(createResult());
1445 QString schema;
1446 QString qualifiedName = table;
1447 d->splitTableQualifier(qualifiedName, &schema, &table);
1448 QString sql =
1449 "select information_schema.ext_access_paths.column_name,"
1450 "case when data_type = 'INTERVAL' then 'INTERVAL '|| interval_type "
1451 "when data_type = 'INTEGER' and numeric_precision > 10 then 'BIGINT' "
1452 "when data_type = 'INTEGER' and numeric_precision <= 10 AND NUMERIC_PRECISION > 5 "
1453 "then 'INTEGER' when data_type = 'INTEGER' and numeric_precision <= 5 then 'SMALLINT' "
1454 "else upper(data_type) end as data_type "
1455 "from information_schema.ext_access_paths full outer join "
1456 "information_schema.columns on information_schema.ext_access_paths.column_name = "
1457 "information_schema.columns.column_name and "
1458 "information_schema.ext_access_paths.table_name = "
1459 "information_schema.columns.table_name where "
1460 "information_schema.ext_access_paths.table_name = \'"_L1;
1461 sql.append(table)
1462 .append("\' and index_type = \'PRIMARY KEY\'"_L1);
1463 if (schema.length() == 0)
1464 sql.append(" and table_schema = CURRENT_USER"_L1);
1465 else
1466 sql.append(" and table_schema = \'"_L1).append(schema).append("\'"_L1);
1467
1468 if (!t.exec(sql))
1469 return QSqlIndex();
1470 int i = 0;
1471 while (t.next()) {
1472 QSqlField field(t.value(0).toString(),
1473 QMetaType(qDecodeMSQLType(qLookupMimDataType(t.value(1).toString()))),
1474 tablename);
1475 index.insert(i, field);
1476 index.setName(t.value(0).toString());
1477 i++;
1478 }
1479 return index;
1480}
1481
1482QSqlRecord QMimerSQLDriver::record(const QString &tablename) const
1483{
1484 Q_D(const QMimerSQLDriver);
1485 if (!isOpen())
1486 return QSqlRecord();
1487 QSqlRecord rec;
1488 QSqlQuery t(createResult());
1489 QString qualifiedName = tablename;
1490 if (isIdentifierEscaped(qualifiedName, QSqlDriver::TableName))
1491 qualifiedName = stripDelimiters(qualifiedName, QSqlDriver::TableName);
1492 QString schema, table;
1493 d->splitTableQualifier(qualifiedName, &schema, &table);
1494
1495 QString sql =
1496 "select column_name, case when data_type = 'INTERVAL' then 'INTERVAL '|| interval_type "
1497 "when data_type = 'INTEGER' and numeric_precision > 10 then 'BIGINT' "
1498 "when data_type = 'INTEGER' and numeric_precision <= 10 AND numeric_precision > 5 "
1499 "then 'INTEGER' when data_type = 'INTEGER' and numeric_precision <= 5 then 'SMALLINT' "
1500 "else UPPER(data_type) end as data_type, case when is_nullable = 'YES' then false else "
1501 "true end as required, "
1502 "coalesce(numeric_precision, coalesce(datetime_precision,coalesce(interval_precision, "
1503 "-1))) as prec from information_schema.columns where table_name = \'"_L1;
1504 if (schema.length() == 0)
1505 sql.append(table).append("\' and table_schema = CURRENT_USER"_L1);
1506 else
1507 sql.append(table).append("\' and table_schema = \'"_L1).append(schema).append("\'"_L1);
1508 sql.append(" order by ordinal_position"_L1);
1509 if (!t.exec(sql))
1510 return QSqlRecord();
1511
1512 while (t.next()) {
1513 QSqlField field(t.value(0).toString(),
1514 QMetaType(qDecodeMSQLType(qLookupMimDataType(t.value(1).toString()))),
1515 tablename);
1516 field.setRequired(t.value(3).toBool());
1517 if (t.value(3).toInt() != -1)
1518 field.setPrecision(t.value(3).toInt());
1519 rec.append(field);
1520 }
1521
1522 return rec;
1523}
1524
1525QVariant QMimerSQLDriver::handle() const
1526{
1527 Q_D(const QMimerSQLDriver);
1528 return QVariant::fromValue(d->sessionhandle);
1529}
1530
1531QString QMimerSQLDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const
1532{
1533 Q_UNUSED(type);
1534 QString res = identifier;
1535 if (!identifier.isEmpty() && !identifier.startsWith(u'"') && !identifier.endsWith(u'"')) {
1536 res.replace(u'"', "\"\""_L1);
1537 res = u'"' + res + u'"';
1538 res.replace(u'.', "\".\""_L1);
1539 }
1540 return res;
1541}
1542
1543bool QMimerSQLDriver::beginTransaction()
1544{
1545 Q_D(const QMimerSQLDriver);
1546 const int32_t err = MimerBeginTransaction(d->sessionhandle, MIMER_TRANS_READWRITE);
1547 if (!MIMER_SUCCEEDED(err)) {
1548 setLastError(qMakeError(
1549 QCoreApplication::translate("QMimerSQLDriver", "Could not start transaction"), err,
1550 QSqlError::TransactionError, d));
1551 return false;
1552 }
1553 return true;
1554}
1555
1556bool QMimerSQLDriver::commitTransaction()
1557{
1558 Q_D(const QMimerSQLDriver);
1559 const int32_t err = MimerEndTransaction(d->sessionhandle, MIMER_COMMIT);
1560 if (!MIMER_SUCCEEDED(err)) {
1561 setLastError(qMakeError(
1562 QCoreApplication::translate("QMimerSQLDriver", "Could not commit transaction"), err,
1563 QSqlError::TransactionError, d));
1564 return false;
1565 }
1566 return true;
1567}
1568
1569bool QMimerSQLDriver::rollbackTransaction()
1570{
1571 Q_D(const QMimerSQLDriver);
1572 const int32_t err = MimerEndTransaction(d->sessionhandle, MIMER_ROLLBACK);
1573 if (!MIMER_SUCCEEDED(err)) {
1574 setLastError(qMakeError(
1575 QCoreApplication::translate("QMimerSQLDriver", "Could not roll back transaction"),
1576 err, QSqlError::TransactionError, d));
1577 return false;
1578 }
1579 return true;
1580}
1581
1582void QMimerSQLDriverPrivate::splitTableQualifier(const QString &qualifiedName, QString *schema,
1583 QString *table) const
1584{
1585 const QList<QStringView> l = QStringView(qualifiedName).split(u'.');
1586 int n = l.count();
1587 if (n > 2) {
1588 return; // can't possibly be a valid table qualifier
1589 } else if (n == 1) {
1590 *schema = QString();
1591 *table = l.at(0).toString();
1592 } else {
1593 *schema = l.at(0).toString();
1594 *table = l.at(1).toString();
1595 }
1596}
1597
1598QT_END_NAMESPACE
QByteArray
\inmodule QtCore
Definition qbytearray.h:57
QByteArray::trimmed
QByteArray trimmed() const &
Definition qbytearray.h:198
QByteArray::data
char * data()
\macro QT_NO_CAST_FROM_BYTEARRAY
Definition qbytearray.h:534
QByteArray::size
qsizetype size() const noexcept
Returns the number of bytes in this byte array.
Definition qbytearray.h:474
QByteArray::fromHex
static QByteArray fromHex(const QByteArray &hexEncoded)
Returns a decoded copy of the hex encoded array hexEncoded.
Definition qbytearray.cpp:4664
QByteArray::reserve
void reserve(qsizetype size)
Attempts to allocate memory for at least size bytes.
Definition qbytearray.h:557
QByteArray::constData
const char * constData() const noexcept
Returns a pointer to the const data stored in the byte array.
Definition qbytearray.h:122
QByteArray::resize
void resize(qsizetype size)
Sets the size of the byte array to size bytes.
Definition qbytearray.cpp:1859
QByteArray::append
QByteArray & append(char c)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qbytearray.cpp:2099
QByteArray::fromRawData
static QByteArray fromRawData(const char *data, qsizetype size)
Constructs a QByteArray that uses the first size bytes of the data array.
Definition qbytearray.h:394
QCoreApplication::translate
static QString translate(const char *context, const char *key, const char *disambiguation=nullptr, int n=-1)
\threadsafe
Definition qcoreapplication.cpp:2314
QDateTime
\inmodule QtCore\reentrant
Definition qdatetime.h:257
QDateTime::time
QTime time() const
Returns the time part of the datetime.
Definition qdatetime.cpp:3628
QList
Definition qlist.h:74
QList::at
const_reference at(qsizetype i) const noexcept
Definition qlist.h:429
QList::count
qsizetype count() const noexcept
Definition qlist.h:387
QMetaType
\inmodule QtCore
Definition qmetatype.h:320
QMetaType::Type
Type
\macro Q_DECLARE_OPAQUE_POINTER(PointerType)
Definition qmetatype.h:324
QMimerSQLDriverPrivate::sessionhandle
MimerSession sessionhandle
Definition qsql_mimer.cpp:93
QMimerSQLDriverPrivate::splitTableQualifier
void splitTableQualifier(const QString &qualifier, QString *schema, QString *table) const
Definition qsql_mimer.cpp:1582
QMimerSQLDriver::~QMimerSQLDriver
~QMimerSQLDriver() override
Definition qsql_mimer.cpp:186
QMimerSQLDriver::primaryIndex
QSqlIndex primaryIndex(const QString &tablename) const override
Returns the primary index for table tableName.
Definition qsql_mimer.cpp:1435
QMimerSQLDriver::rollbackTransaction
bool rollbackTransaction() override
This function is called to rollback a transaction.
Definition qsql_mimer.cpp:1569
QMimerSQLDriver::commitTransaction
bool commitTransaction() override
This function is called to commit a transaction.
Definition qsql_mimer.cpp:1556
QMimerSQLDriver::beginTransaction
bool beginTransaction() override
This function is called to begin a transaction.
Definition qsql_mimer.cpp:1543
QMimerSQLDriver::tables
QStringList tables(QSql::TableType type) const override
Returns a list of the names of the tables in the database.
Definition qsql_mimer.cpp:1395
QMimerSQLDriver::close
void close() override
Derived classes must reimplement this pure virtual function in order to close the database connection...
Definition qsql_mimer.cpp:1378
QMimerSQLDriver::escapeIdentifier
QString escapeIdentifier(const QString &identifier, IdentifierType type) const override
Returns the identifier escaped according to the database rules.
Definition qsql_mimer.cpp:1531
QMimerSQLDriver::QMimerSQLDriver
QMimerSQLDriver(QObject *parent=nullptr)
Definition qsql_mimer.cpp:174
QMimerSQLDriver::open
bool open(const QString &db, const QString &user, const QString &password, const QString &host, int port, const QString &connOpts) override
Derived classes must reimplement this pure virtual function to open a database connection on database...
Definition qsql_mimer.cpp:1352
QMimerSQLDriver::hasFeature
bool hasFeature(DriverFeature f) const override
Returns true if the driver supports feature feature; otherwise returns false.
Definition qsql_mimer.cpp:1328
QMimerSQLDriver::createResult
QSqlResult * createResult() const override
Creates an empty SQL result on the database.
Definition qsql_mimer.cpp:1390
QMimerSQLDriver::record
QSqlRecord record(const QString &tablename) const override
Returns a QSqlRecord populated with the names of the fields in table tableName.
Definition qsql_mimer.cpp:1482
QMimerSQLDriver::handle
QVariant handle() const override
Returns the low-level database handle wrapped in a QVariant or an invalid variant if there is no hand...
Definition qsql_mimer.cpp:1525
QMimerSQLResultPrivate::statementhandle
MimerStatement statementhandle
Definition qsql_mimer.cpp:118
QMimerSQLResultPrivate::batch_vector
QVector< QVariant > batch_vector
Definition qsql_mimer.cpp:129
QMimerSQLResult::maxTimestampStringSize
static constexpr int maxTimestampStringSize
Definition qsql_mimer.cpp:67
QMimerSQLResult::lobChunkMaxSizeSet
static constexpr int lobChunkMaxSizeSet
Definition qsql_mimer.cpp:62
QMimerSQLResult::fetchNext
bool fetchNext() override
Positions the result to the next available record (row) in the result.
Definition qsql_mimer.cpp:567
QMimerSQLResult::reset
bool reset(const QString &query) override
Sets the result to use the SQL statement query for subsequent data retrieval.
Definition qsql_mimer.cpp:867
QMimerSQLResult::maxDateStringSize
static constexpr int maxDateStringSize
Definition qsql_mimer.cpp:66
QMimerSQLResult::prepare
bool prepare(const QString &query) override
Prepares the given query for execution; the query will normally use placeholders so that it can be ex...
Definition qsql_mimer.cpp:926
QMimerSQLResult::data
QVariant data(int i) override
Returns the data for field index in the current row as a QVariant.
Definition qsql_mimer.cpp:594
QMimerSQLResult::record
QSqlRecord record() const override
Returns the current record if the query is active; otherwise returns an empty QSqlRecord.
Definition qsql_mimer.cpp:899
QMimerSQLResult::size
int size() override
Returns the size of the SELECT result, or -1 if it cannot be determined or if the query is not a SELE...
Definition qsql_mimer.cpp:874
QMimerSQLResult::handle
QVariant handle() const override
Returns the low-level database handle for this result set wrapped in a QVariant or an invalid QVarian...
Definition qsql_mimer.cpp:427
QMimerSQLResult::fetchLast
bool fetchLast() override
Positions the result to the last record (last row) in the result.
Definition qsql_mimer.cpp:530
QMimerSQLResult::fetch
bool fetch(int i) override
Positions the result to an arbitrary (zero-based) row index.
Definition qsql_mimer.cpp:466
QMimerSQLResult::execBatch
bool execBatch(bool arrayBind=false) override
Definition qsql_mimer.cpp:1271
QMimerSQLResult::isNull
bool isNull(int index) override
Returns true if the field at position index in the current row is null; otherwise returns false.
Definition qsql_mimer.cpp:853
QMimerSQLResult::fetchFirst
bool fetchFirst() override
Positions the result to the first record (row 0) in the result.
Definition qsql_mimer.cpp:501
QMimerSQLResult::numRowsAffected
int numRowsAffected() override
Returns the number of rows affected by the last query executed, or -1 if it cannot be determined or i...
Definition qsql_mimer.cpp:893
QMimerSQLResult::maxTimeStringSize
static constexpr int maxTimeStringSize
Definition qsql_mimer.cpp:65
QMimerSQLResult::genericError
static constexpr int genericError
Definition qsql_mimer.cpp:61
QMimerSQLResult::lobChunkMaxSizeFetch
static constexpr int lobChunkMaxSizeFetch
Definition qsql_mimer.cpp:63
QMimerSQLResult::QMimerSQLResult
QMimerSQLResult(const QMimerSQLDriver *db)
Definition qsql_mimer.cpp:191
QMimerSQLResult::~QMimerSQLResult
virtual ~QMimerSQLResult() override
Definition qsql_mimer.cpp:198
QMimerSQLResult::exec
bool exec() override
Executes the query, returning true if successful; otherwise returns false.
Definition qsql_mimer.cpp:959
QMimerSQLResult::maxStackStringSize
static constexpr int maxStackStringSize
Definition qsql_mimer.cpp:64
QMimerSQLResult::lastInsertId
QVariant lastInsertId() const override
Returns the object ID of the most recent inserted row if the database supports it.
Definition qsql_mimer.cpp:1318
QObject
\inmodule QtCore
Definition qobject.h:90
QSqlDriver
The QSqlDriver class is an abstract base class for accessing specific SQL databases.
Definition qsqldriver.h:25
QSqlDriver::IdentifierType
IdentifierType
This enum contains a list of SQL identifier types.
Definition qsqldriver.h:40
QSqlDriver::stripDelimiters
virtual QString stripDelimiters(const QString &identifier, IdentifierType type) const
Returns the identifier with the leading and trailing delimiters removed, identifier can either be a t...
Definition qsqldriver.cpp:410
QSqlDriver::DriverFeature
DriverFeature
This enum contains a list of features a driver might support.
Definition qsqldriver.h:32
QSqlDriver::PositionalPlaceholders
@ PositionalPlaceholders
Definition qsqldriver.h:33
QSqlDriver::LowPrecisionNumbers
@ LowPrecisionNumbers
Definition qsqldriver.h:34
QSqlDriver::EventNotifications
@ EventNotifications
Definition qsqldriver.h:35
QSqlDriver::PreparedQueries
@ PreparedQueries
Definition qsqldriver.h:32
QSqlDriver::NamedPlaceholders
@ NamedPlaceholders
Definition qsqldriver.h:33
QSqlDriver::BatchOperations
@ BatchOperations
Definition qsqldriver.h:34
QSqlDriver::MultipleResultSets
@ MultipleResultSets
Definition qsqldriver.h:35
QSqlDriver::setLastError
virtual void setLastError(const QSqlError &e)
This function is used to set the value of the last error, error, that occurred on the database.
Definition qsqldriver.cpp:310
QSqlDriver::isOpen
virtual bool isOpen() const
Returns true if the database connection is open; otherwise returns false.
Definition qsqldriver.cpp:120
QSqlDriver::setOpenError
virtual void setOpenError(bool e)
This function sets the open error state of the database to error.
Definition qsqldriver.cpp:256
QSqlDriver::isIdentifierEscaped
virtual bool isIdentifierEscaped(const QString &identifier, IdentifierType type) const
Returns whether identifier is escaped according to the database rules.
Definition qsqldriver.cpp:389
QSqlDriver::setOpen
virtual void setOpen(bool o)
This function sets the open state of the database to open.
Definition qsqldriver.cpp:241
QSqlError
The QSqlError class provides SQL database error information.
Definition qsqlerror.h:17
QSqlError::ErrorType
ErrorType
This enum type describes the context in which the error occurred, e.g., a connection error,...
Definition qsqlerror.h:19
QSqlError::StatementError
@ StatementError
Definition qsqlerror.h:22
QSqlError::TransactionError
@ TransactionError
Definition qsqlerror.h:23
QSqlError::ConnectionError
@ ConnectionError
Definition qsqlerror.h:21
QSqlField
The QSqlField class manipulates the fields in SQL database tables and views.
Definition qsqlfield.h:19
QSqlField::metaType
QMetaType metaType() const
Returns the field's type as stored in the database.
Definition qsqlfield.cpp:337
QSqlField::setValue
void setValue(const QVariant &value)
Sets the value of the field to value.
Definition qsqlfield.cpp:266
QSqlField::setName
void setName(const QString &name)
Sets the name of the field to name.
Definition qsqlfield.cpp:293
QSqlField::setMetaType
void setMetaType(QMetaType type)
Set's the field's variant type to type.
Definition qsqlfield.cpp:348
QSqlField::setRequired
void setRequired(bool required)
Sets the required status of this field to \l Required if required is true; otherwise sets it to \l Op...
Definition qsqlfield.h:67
QSqlField::setPrecision
void setPrecision(int precision)
Sets the field's precision.
Definition qsqlfield.cpp:209
QSqlField::setSqlType
void setSqlType(int type)
Definition qsqlfield.cpp:230
QSqlIndex
The QSqlIndex class provides functions to manipulate and describe database indexes.
Definition qsqlindex.h:16
QSqlQuery
The QSqlQuery class provides a means of executing and manipulating SQL statements.
Definition qsqlquery.h:23
QSqlRecord
The QSqlRecord class encapsulates a database record.
Definition qsqlrecord.h:20
QSqlRecord::append
void append(const QSqlField &field)
Append a copy of field field to the end of the record.
Definition qsqlrecord.cpp:247
QSqlRecord::insert
void insert(int pos, const QSqlField &field)
Inserts the field field at position pos in the record.
Definition qsqlrecord.cpp:258
QSqlResultPrivate::isVariantNull
static bool isVariantNull(const QVariant &variant)
Definition qsqlresult.cpp:587
QSqlResult
The QSqlResult class provides an abstract interface for accessing data from specific SQL databases.
Definition qsqlresult.h:25
QSqlResult::isForwardOnly
bool isForwardOnly() const
Returns true if you can only scroll forward through the result set; otherwise returns false.
Definition qsqlresult.cpp:505
QSqlResult::bindValueType
QSql::ParamType bindValueType(const QString &placeholder) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qsqlresult.cpp:769
QSqlResult::at
int at() const
Returns the current (zero-based) row position of the result.
Definition qsqlresult.cpp:243
QSqlResult::prepare
virtual bool prepare(const QString &query)
Prepares the given query for execution; the query will normally use placeholders so that it can be ex...
Definition qsqlresult.cpp:576
QSqlResult::exec
virtual bool exec()
Executes the query, returning true if successful; otherwise returns false.
Definition qsqlresult.cpp:620
QSqlResult::isSelect
bool isSelect() const
Returns true if the current result is from a SELECT statement; otherwise returns false.
Definition qsqlresult.cpp:318
QSqlResult::setAt
virtual void setAt(int at)
This function is provided for derived classes to set the internal (zero-based) row position to index.
Definition qsqlresult.cpp:289
QSqlResult::setSelect
virtual void setSelect(bool s)
This function is provided for derived classes to indicate whether or not the current statement is a S...
Definition qsqlresult.cpp:305
QSqlResult::setActive
virtual void setActive(bool a)
This function is provided for derived classes to set the internal active state to active.
Definition qsqlresult.cpp:343
QSqlResult::boundValues
QVariantList & boundValues(QT6_DECL_NEW_OVERLOAD)
QSqlResult::numericalPrecisionPolicy
QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const
Definition qsqlresult.cpp:1001
QSqlResult::setLastError
virtual void setLastError(const QSqlError &e)
This function is provided for derived classes to set the last error to error.
Definition qsqlresult.cpp:359
QSqlResult::driver
const QSqlDriver * driver() const
Returns the driver associated with the result.
Definition qsqlresult.cpp:329
QSqlResult::bindValue
virtual void bindValue(int pos, const QVariant &val, QSql::ParamType type)
Binds the value val of parameter type paramType to position index in the current record (row).
Definition qsqlresult.cpp:670
QSqlResult::isActive
bool isActive() const
Returns true if the result has records to be retrieved; otherwise returns false.
Definition qsqlresult.cpp:276
QStringList
\inmodule QtCore
QStringView
\inmodule QtCore
Definition qstringview.h:76
QStringView::split
Q_CORE_EXPORT QList< QStringView > split(QStringView sep, Qt::SplitBehavior behavior=Qt::KeepEmptyParts, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Splits the view into substring views wherever sep occurs, and returns the list of those string views.
Definition qstring.cpp:7987
QString
\macro QT_RESTRICTED_CAST_FROM_ASCII
Definition qstring.h:127
QString::startsWith
bool startsWith(const QString &s, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Returns true if the string starts with s; otherwise returns false.
Definition qstring.cpp:5299
QString::replace
QString & replace(qsizetype i, qsizetype len, QChar after)
Definition qstring.cpp:3794
QString::size
qsizetype size() const
Returns the number of characters in this string.
Definition qstring.h:182
QString::arg
QString arg(qlonglong a, int fieldwidth=0, int base=10, QChar fillChar=u' ') const
Definition qstring.cpp:8606
QString::toLongLong
qlonglong toLongLong(bool *ok=nullptr, int base=10) const
Returns the string converted to a {long long} using base base, which is 10 by default and must be bet...
QString::endsWith
bool endsWith(const QString &s, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Returns true if the string ends with s; otherwise returns false.
Definition qstring.cpp:5350
QString::isEmpty
bool isEmpty() const
Returns true if the string has no characters; otherwise returns false.
Definition qstring.h:1083
QString::fromWCharArray
static QString fromWCharArray(const wchar_t *string, qsizetype size=-1)
Definition qstring.h:1164
QString::number
static QString number(int, int base=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qstring.cpp:7822
QString::append
QString & append(QChar c)
Definition qstring.cpp:3227
QString::left
QString left(qsizetype n) const
Returns a substring that contains the n leftmost characters of the string.
Definition qstring.cpp:5161
QString::toUtf8
QByteArray toUtf8() const &
Definition qstring.h:563
QString::length
qsizetype length() const
Returns the number of characters in this string.
Definition qstring.h:187
QTime
\inmodule QtCore \reentrant
Definition qdatetime.h:189
QTime::msec
int msec() const
Returns the millisecond part (0 to 999) of the time.
Definition qdatetime.cpp:1958
QUuid::WithoutBraces
@ WithoutBraces
Definition quuid.h:54
QUuid::fromRfc4122
static QUuid fromRfc4122(QByteArrayView) noexcept
Creates a QUuid object from the binary representation of the UUID, as specified by RFC 4122 section 4...
Definition quuid.cpp:547
QVarLengthArray::data
T * data() noexcept
Definition qvarlengtharray.h:84
QVariant
\inmodule QtCore
Definition qvariant.h:64
QVariant::fromValue
static auto fromValue(T &&value) noexcept(std::is_nothrow_copy_constructible_v< T > &&Private::CanUseInternalSpace< T >) -> std::enable_if_t< std::conjunction_v< std::is_copy_constructible< T >, std::is_destructible< T > >, QVariant >
Definition qvariant.h:531
this
#define this
Definition dialogs.cpp:9
j
int j
Definition doc_src_containers.cpp:273
i
i
[1]
Definition doc_src_containers.cpp:167
QSql::BeforeFirstRow
@ BeforeFirstRow
Definition qtsqlglobal.h:22
QSql::SystemTables
@ SystemTables
Definition qtsqlglobal.h:38
QSql::Views
@ Views
Definition qtsqlglobal.h:39
QSql::Tables
@ Tables
Definition qtsqlglobal.h:37
QSql::AllTables
@ AllTables
Definition qtsqlglobal.h:40
QSql::InOut
@ InOut
Definition qtsqlglobal.h:30
QSql::LowPrecisionInt32
@ LowPrecisionInt32
Definition qtsqlglobal.h:45
QSql::LowPrecisionDouble
@ LowPrecisionDouble
Definition qtsqlglobal.h:47
QSql::LowPrecisionInt64
@ LowPrecisionInt64
Definition qtsqlglobal.h:46
QSql::HighPrecision
@ HighPrecision
Definition qtsqlglobal.h:49
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21
QT_END_NAMESPACE
Definition qsharedpointer.cpp:1545
port
EGLOutputPortEXT port
Definition qeglstreamconvenience_p.h:49
qWarning
#define qWarning
Definition qlogging.h:162
Q_DECLARE_OPAQUE_POINTER
#define Q_DECLARE_OPAQUE_POINTER(POINTER)
Definition qmetatype.h:1496
Q_DECLARE_METATYPE
#define Q_DECLARE_METATYPE(TYPE)
Definition qmetatype.h:1504
values
GLenum GLsizei GLsizei GLint * values
[15]
Definition qopengles2ext.h:1032
size
GLenum GLuint GLintptr GLsizeiptr size
[1]
Definition qopengles2ext.h:660
index
GLuint index
[2]
Definition qopengles2ext.h:331
f
GLfloat GLfloat f
Definition qopengles2ext.h:795
type
GLenum type
Definition qopengles2ext.h:150
data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition qopengles2ext.h:206
n
GLfloat n
Definition qopengles2ext.h:795
column
GLenum GLenum GLsizei void GLsizei void * column
Definition qopenglext.h:2747
reset
GLboolean reset
Definition qopenglext.h:2748
query
GLenum query
Definition qopenglext.h:2738
res
GLuint res
Definition qopenglext.h:8867
val
GLuint GLfloat * val
Definition qopenglext.h:1513
t
GLdouble GLdouble t
Definition qopenglext.h:243
q
GLdouble GLdouble GLdouble GLdouble q
Definition qopenglext.h:259
row
GLenum GLenum GLsizei void * row
Definition qopenglext.h:2747
s
GLdouble s
[6]
Definition qopenglext.h:235
p
GLfloat GLfloat p
[1]
Definition qopenglext.h:12698
option
GLuint GLenum option
Definition qopenglext.h:5929
table
GLenum GLenum GLsizei void * table
Definition qopenglext.h:2745
qMakeError
static QSqlError qMakeError(const QString &err, QSqlError::ErrorType type, const QDB2DriverPrivate *p)
Definition qsql_db2.cpp:203
toList
static QList< QVariant > toList(char **buf, int count)
Definition qsql_ibase.cpp:537
qMakeError
static QSqlError qMakeError(const QString &err, const int errCode, QSqlError::ErrorType type, const QMimerSQLDriverPrivate *p)
Definition qsql_mimer.cpp:132
mimerMapColumnTypes
static MimerColumnTypes mimerMapColumnTypes(int32_t t)
Definition qsql_mimer.cpp:203
msgCouldNotGet
static QString msgCouldNotGet(const char *type, int column)
Definition qsql_mimer.cpp:160
qDecodeMSQLType
static QMetaType::Type qDecodeMSQLType(int32_t t)
Definition qsql_mimer.cpp:277
msgCouldNotSet
static QString msgCouldNotSet(const char *type, int column)
Definition qsql_mimer.cpp:167
qLookupMimDataType
static int32_t qLookupMimDataType(QStringView s)
Definition qsql_mimer.cpp:349
MimerColumnTypes
MimerColumnTypes
Definition qsql_mimer.cpp:33
MimerColumnTypes::Int
@ Int
MimerColumnTypes::Float
@ Float
MimerColumnTypes::String
@ String
MimerColumnTypes::Boolean
@ Boolean
MimerColumnTypes::Date
@ Date
MimerColumnTypes::Binary
@ Binary
MimerColumnTypes::Uuid
@ Uuid
MimerColumnTypes::Long
@ Long
MimerColumnTypes::Unknown
@ Unknown
MimerColumnTypes::Clob
@ Clob
MimerColumnTypes::Timestamp
@ Timestamp
MimerColumnTypes::Time
@ Time
MimerColumnTypes::Double
@ Double
MimerColumnTypes::Blob
@ Blob
MIMER_DEFAULT_DATATYPE
#define MIMER_DEFAULT_DATATYPE
Definition qsql_mimer.cpp:23
qsql_mimer.h
Q_DECLARE_SQLDRIVER_PRIVATE
#define Q_DECLARE_SQLDRIVER_PRIVATE(Class)
Definition qsqlresult_p.h:28
arg
SSL_CTX int(*) void arg)
Definition qsslsocket_openssl_symbols.cpp:404
Q_UNUSED
#define Q_UNUSED(x)
Definition qtpreprocessorsupport.h:20
qsizetype
ptrdiff_t qsizetype
Definition qtypes.h:70
uint
unsigned int uint
Definition qtypes.h:29
qint64
long long qint64
Definition qtypes.h:55
pos
pos
[7]
Definition src_corelib_io_qsettings.cpp:57
nullptr
QObject::connect nullptr
Definition src_corelib_kernel_qobject.cpp:255
db
QMimeDatabase db
[0]
Definition src_corelib_mimetype_qmimedatabase.cpp:7
d
double d
Definition src_corelib_text_qlocale.cpp:9
false
return false
Definition src_corelib_thread_qatomic.cpp:23
drv
QPSQLDriver * drv
Definition src_sql_kernel_qsqldatabase_snippet.cpp:12
parent
IUIAutomationTreeWalker __RPC__deref_out_opt IUIAutomationElement ** parent
Definition uiaclientinterfaces_p.h:209