QSQLITE support only one statement at a time
[qt:qt.git] / src / sql / drivers / sqlite / qsql_sqlite.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the QtSql module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 **
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 **
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
29 **
30 ** Other Usage
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "qsql_sqlite.h"
43
44 #include <qcoreapplication.h>
45 #include <qvariant.h>
46 #include <qsqlerror.h>
47 #include <qsqlfield.h>
48 #include <qsqlindex.h>
49 #include <qsqlquery.h>
50 #include <qstringlist.h>
51 #include <qvector.h>
52 #include <qdebug.h>
53
54 #if defined Q_OS_WIN
55 # include <qt_windows.h>
56 #else
57 # include <unistd.h>
58 #endif
59
60 #include <sqlite3.h>
61
62 Q_DECLARE_METATYPE(sqlite3*)
63 Q_DECLARE_METATYPE(sqlite3_stmt*)
64
65 QT_BEGIN_NAMESPACE
66
67 static QString _q_escapeIdentifier(const QString &identifier) 
68 {
69     QString res = identifier;
70     if(!identifier.isEmpty() && identifier.left(1) != QString(QLatin1Char('"')) && identifier.right(1) != QString(QLatin1Char('"')) ) {
71         res.replace(QLatin1Char('"'), QLatin1String("\"\""));
72         res.prepend(QLatin1Char('"')).append(QLatin1Char('"'));
73         res.replace(QLatin1Char('.'), QLatin1String("\".\""));
74     }
75     return res;
76 }
77
78 static QVariant::Type qGetColumnType(const QString &tpName)
79 {
80     const QString typeName = tpName.toLower();
81
82     if (typeName == QLatin1String("integer")
83         || typeName == QLatin1String("int"))
84         return QVariant::Int;
85     if (typeName == QLatin1String("double")
86         || typeName == QLatin1String("float")
87         || typeName.startsWith(QLatin1String("numeric")))
88         return QVariant::Double;
89     if (typeName == QLatin1String("blob"))
90         return QVariant::ByteArray;
91     return QVariant::String;
92 }
93
94 static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::ErrorType type,
95                             int errorCode = -1)
96 {
97     return QSqlError(descr,
98                      QString(reinterpret_cast<const QChar *>(sqlite3_errmsg16(access))),
99                      type, errorCode);
100 }
101
102 class QSQLiteDriverPrivate
103 {
104 public:
105     inline QSQLiteDriverPrivate() : access(0) {}
106     sqlite3 *access;
107 };
108
109
110 class QSQLiteResultPrivate
111 {
112 public:
113     QSQLiteResultPrivate(QSQLiteResult *res);
114     void cleanup();
115     bool fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch);
116     // initializes the recordInfo and the cache
117     void initColumns(bool emptyResultset);
118     void finalize();
119
120     QSQLiteResult* q;
121     sqlite3 *access;
122
123     sqlite3_stmt *stmt;
124
125     bool skippedStatus; // the status of the fetchNext() that's skipped
126     bool skipRow; // skip the next fetchNext()?
127     QSqlRecord rInf;
128     QVector<QVariant> firstRow;
129 };
130
131 QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult* res) : q(res), access(0),
132     stmt(0), skippedStatus(false), skipRow(false)
133 {
134 }
135
136 void QSQLiteResultPrivate::cleanup()
137 {
138     finalize();
139     rInf.clear();
140     skippedStatus = false;
141     skipRow = false;
142     q->setAt(QSql::BeforeFirstRow);
143     q->setActive(false);
144     q->cleanup();
145 }
146
147 void QSQLiteResultPrivate::finalize()
148 {
149     if (!stmt)
150         return;
151
152     sqlite3_finalize(stmt);
153     stmt = 0;
154 }
155
156 void QSQLiteResultPrivate::initColumns(bool emptyResultset)
157 {
158     int nCols = sqlite3_column_count(stmt);
159     if (nCols <= 0)
160         return;
161
162     q->init(nCols);
163
164     for (int i = 0; i < nCols; ++i) {
165         QString colName = QString(reinterpret_cast<const QChar *>(
166                     sqlite3_column_name16(stmt, i))
167                     ).remove(QLatin1Char('"'));
168
169         // must use typeName for resolving the type to match QSqliteDriver::record
170         QString typeName = QString(reinterpret_cast<const QChar *>(
171                     sqlite3_column_decltype16(stmt, i)));
172
173         int dotIdx = colName.lastIndexOf(QLatin1Char('.'));
174         QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), qGetColumnType(typeName));
175
176         // sqlite3_column_type is documented to have undefined behavior if the result set is empty
177         int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
178         fld.setSqlType(stp);
179         rInf.append(fld);
180     }
181 }
182
183 bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch)
184 {
185     int res;
186     int i;
187
188     if (skipRow) {
189         // already fetched
190         Q_ASSERT(!initialFetch);
191         skipRow = false;
192         for(int i=0;i<firstRow.count();i++)
193             values[i]=firstRow[i];
194         return skippedStatus;
195     }
196     skipRow = initialFetch;
197
198     if(initialFetch) {
199         firstRow.clear();
200         firstRow.resize(sqlite3_column_count(stmt));
201     }
202
203     if (!stmt) {
204         q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"),
205                                   QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));
206         q->setAt(QSql::AfterLastRow);
207         return false;
208     }
209     res = sqlite3_step(stmt);
210
211     switch(res) {
212     case SQLITE_ROW:
213         // check to see if should fill out columns
214         if (rInf.isEmpty())
215             // must be first call.
216             initColumns(false);
217         if (idx < 0 && !initialFetch)
218             return true;
219         for (i = 0; i < rInf.count(); ++i) {
220             switch (sqlite3_column_type(stmt, i)) {
221             case SQLITE_BLOB:
222                 values[i + idx] = QByteArray(static_cast<const char *>(
223                             sqlite3_column_blob(stmt, i)),
224                             sqlite3_column_bytes(stmt, i));
225                 break;
226             case SQLITE_INTEGER:
227                 values[i + idx] = sqlite3_column_int64(stmt, i);
228                 break;
229             case SQLITE_FLOAT:
230                 switch(q->numericalPrecisionPolicy()) {
231                     case QSql::LowPrecisionInt32:
232                         values[i + idx] = sqlite3_column_int(stmt, i);
233                         break;
234                     case QSql::LowPrecisionInt64:
235                         values[i + idx] = sqlite3_column_int64(stmt, i);
236                         break;
237                     case QSql::LowPrecisionDouble:
238                     case QSql::HighPrecision:
239                     default:
240                         values[i + idx] = sqlite3_column_double(stmt, i);
241                         break;
242                 };
243                 break;
244             case SQLITE_NULL:
245                 values[i + idx] = QVariant(QVariant::String);
246                 break;
247             default:
248                 values[i + idx] = QString(reinterpret_cast<const QChar *>(
249                             sqlite3_column_text16(stmt, i)),
250                             sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
251                 break;
252             }
253         }
254         return true;
255     case SQLITE_DONE:
256         if (rInf.isEmpty())
257             // must be first call.
258             initColumns(true);
259         q->setAt(QSql::AfterLastRow);
260         sqlite3_reset(stmt);
261         return false;
262     case SQLITE_CONSTRAINT:
263     case SQLITE_ERROR:
264         // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()
265         // to get the specific error message.
266         res = sqlite3_reset(stmt);
267         q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
268                         "Unable to fetch row"), QSqlError::ConnectionError, res));
269         q->setAt(QSql::AfterLastRow);
270         return false;
271     case SQLITE_MISUSE:
272     case SQLITE_BUSY:
273     default:
274         // something wrong, don't get col info, but still return false
275         q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
276                         "Unable to fetch row"), QSqlError::ConnectionError, res));
277         sqlite3_reset(stmt);
278         q->setAt(QSql::AfterLastRow);
279         return false;
280     }
281     return false;
282 }
283
284 QSQLiteResult::QSQLiteResult(const QSQLiteDriver* db)
285     : QSqlCachedResult(db)
286 {
287     d = new QSQLiteResultPrivate(this);
288     d->access = db->d->access;
289 }
290
291 QSQLiteResult::~QSQLiteResult()
292 {
293     d->cleanup();
294     delete d;
295 }
296
297 void QSQLiteResult::virtual_hook(int id, void *data)
298 {
299     switch (id) {
300     case QSqlResult::DetachFromResultSet:
301         if (d->stmt)
302             sqlite3_reset(d->stmt);
303         break;
304     default:
305         QSqlCachedResult::virtual_hook(id, data);
306     }
307 }
308
309 bool QSQLiteResult::reset(const QString &query)
310 {
311     if (!prepare(query))
312         return false;
313     return exec();
314 }
315
316 bool QSQLiteResult::prepare(const QString &query)
317 {
318     if (!driver() || !driver()->isOpen() || driver()->isOpenError())
319         return false;
320
321     d->cleanup();
322
323     setSelect(false);
324
325     const void *pzTail = NULL;
326
327 #if (SQLITE_VERSION_NUMBER >= 3003011)
328     int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
329                                    &d->stmt, &pzTail);
330 #else
331     int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
332                                 &d->stmt, &pzTail);
333 #endif
334
335     if (res != SQLITE_OK) {
336         setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
337                      "Unable to execute statement"), QSqlError::StatementError, res));
338         d->finalize();
339         return false;
340     } else if (pzTail && !QString(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
341         setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
342             "Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
343         d->finalize();
344         return false;
345     }
346     return true;
347 }
348
349 bool QSQLiteResult::exec()
350 {
351     const QVector<QVariant> values = boundValues();
352
353     d->skippedStatus = false;
354     d->skipRow = false;
355     d->rInf.clear();
356     clearValues();
357     setLastError(QSqlError());
358
359     int res = sqlite3_reset(d->stmt);
360     if (res != SQLITE_OK) {
361         setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
362                      "Unable to reset statement"), QSqlError::StatementError, res));
363         d->finalize();
364         return false;
365     }
366     int paramCount = sqlite3_bind_parameter_count(d->stmt);
367     if (paramCount == values.count()) {
368         for (int i = 0; i < paramCount; ++i) {
369             res = SQLITE_OK;
370             const QVariant value = values.at(i);
371
372             if (value.isNull()) {
373                 res = sqlite3_bind_null(d->stmt, i + 1);
374             } else {
375                 switch (value.type()) {
376                 case QVariant::ByteArray: {
377                     const QByteArray *ba = static_cast<const QByteArray*>(value.constData());
378                     res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(),
379                                             ba->size(), SQLITE_STATIC);
380                     break; }
381                 case QVariant::Int:
382                     res = sqlite3_bind_int(d->stmt, i + 1, value.toInt());
383                     break;
384                 case QVariant::Double:
385                     res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble());
386                     break;
387                 case QVariant::UInt:
388                 case QVariant::LongLong:
389                     res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong());
390                     break;
391                 case QVariant::String: {
392                     // lifetime of string == lifetime of its qvariant
393                     const QString *str = static_cast<const QString*>(value.constData());
394                     res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(),
395                                               (str->size()) * sizeof(QChar), SQLITE_STATIC);
396                     break; }
397                 default: {
398                     QString str = value.toString();
399                     // SQLITE_TRANSIENT makes sure that sqlite buffers the data
400                     res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(),
401                                               (str.size()) * sizeof(QChar), SQLITE_TRANSIENT);
402                     break; }
403                 }
404             }
405             if (res != SQLITE_OK) {
406                 setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
407                              "Unable to bind parameters"), QSqlError::StatementError, res));
408                 d->finalize();
409                 return false;
410             }
411         }
412     } else {
413         setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult",
414                         "Parameter count mismatch"), QString(), QSqlError::StatementError));
415         return false;
416     }
417     d->skippedStatus = d->fetchNext(d->firstRow, 0, true);
418     if (lastError().isValid()) {
419         setSelect(false);
420         setActive(false);
421         return false;
422     }
423     setSelect(!d->rInf.isEmpty());
424     setActive(true);
425     return true;
426 }
427
428 bool QSQLiteResult::gotoNext(QSqlCachedResult::ValueCache& row, int idx)
429 {
430     return d->fetchNext(row, idx, false);
431 }
432
433 int QSQLiteResult::size()
434 {
435     return -1;
436 }
437
438 int QSQLiteResult::numRowsAffected()
439 {
440     return sqlite3_changes(d->access);
441 }
442
443 QVariant QSQLiteResult::lastInsertId() const
444 {
445     if (isActive()) {
446         qint64 id = sqlite3_last_insert_rowid(d->access);
447         if (id)
448             return id;
449     }
450     return QVariant();
451 }
452
453 QSqlRecord QSQLiteResult::record() const
454 {
455     if (!isActive() || !isSelect())
456         return QSqlRecord();
457     return d->rInf;
458 }
459
460 QVariant QSQLiteResult::handle() const
461 {
462     return QVariant::fromValue(d->stmt);
463 }
464
465 /////////////////////////////////////////////////////////
466
467 QSQLiteDriver::QSQLiteDriver(QObject * parent)
468     : QSqlDriver(parent)
469 {
470     d = new QSQLiteDriverPrivate();
471 }
472
473 QSQLiteDriver::QSQLiteDriver(sqlite3 *connection, QObject *parent)
474     : QSqlDriver(parent)
475 {
476     d = new QSQLiteDriverPrivate();
477     d->access = connection;
478     setOpen(true);
479     setOpenError(false);
480 }
481
482
483 QSQLiteDriver::~QSQLiteDriver()
484 {
485     delete d;
486 }
487
488 bool QSQLiteDriver::hasFeature(DriverFeature f) const
489 {
490     switch (f) {
491     case BLOB:
492     case Transactions:
493     case Unicode:
494     case LastInsertId:
495     case PreparedQueries:
496     case PositionalPlaceholders:
497     case SimpleLocking:
498     case FinishQuery:
499     case LowPrecisionNumbers:
500         return true;
501     case QuerySize:
502     case NamedPlaceholders:
503     case BatchOperations:
504     case EventNotifications:
505     case MultipleResultSets:
506         return false;
507     }
508     return false;
509 }
510
511 /*
512    SQLite dbs have no user name, passwords, hosts or ports.
513    just file names.
514 */
515 bool QSQLiteDriver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &conOpts)
516 {
517     if (isOpen())
518         close();
519
520     if (db.isEmpty())
521         return false;
522     bool sharedCache = false;
523     int openMode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, timeOut=5000;
524     QStringList opts=QString(conOpts).remove(QLatin1Char(' ')).split(QLatin1Char(';'));
525     foreach(const QString &option, opts) {
526         if (option.startsWith(QLatin1String("QSQLITE_BUSY_TIMEOUT="))) {
527             bool ok;
528             int nt = option.mid(21).toInt(&ok);
529             if (ok)
530                 timeOut = nt;
531         }
532         if (option == QLatin1String("QSQLITE_OPEN_READONLY"))
533             openMode = SQLITE_OPEN_READONLY;
534         if (option == QLatin1String("QSQLITE_ENABLE_SHARED_CACHE"))
535             sharedCache = true;
536     }
537
538     sqlite3_enable_shared_cache(sharedCache);
539
540     if (sqlite3_open_v2(db.toUtf8().constData(), &d->access, openMode, NULL) == SQLITE_OK) {
541         sqlite3_busy_timeout(d->access, timeOut);
542         setOpen(true);
543         setOpenError(false);
544         return true;
545     } else {
546         setLastError(qMakeError(d->access, tr("Error opening database"),
547                      QSqlError::ConnectionError));
548         setOpenError(true);
549         return false;
550     }
551 }
552
553 void QSQLiteDriver::close()
554 {
555     if (isOpen()) {
556         if (sqlite3_close(d->access) != SQLITE_OK)
557             setLastError(qMakeError(d->access, tr("Error closing database"),
558                                     QSqlError::ConnectionError));
559         d->access = 0;
560         setOpen(false);
561         setOpenError(false);
562     }
563 }
564
565 QSqlResult *QSQLiteDriver::createResult() const
566 {
567     return new QSQLiteResult(this);
568 }
569
570 bool QSQLiteDriver::beginTransaction()
571 {
572     if (!isOpen() || isOpenError())
573         return false;
574
575     QSqlQuery q(createResult());
576     if (!q.exec(QLatin1String("BEGIN"))) {
577         setLastError(QSqlError(tr("Unable to begin transaction"),
578                                q.lastError().databaseText(), QSqlError::TransactionError));
579         return false;
580     }
581
582     return true;
583 }
584
585 bool QSQLiteDriver::commitTransaction()
586 {
587     if (!isOpen() || isOpenError())
588         return false;
589
590     QSqlQuery q(createResult());
591     if (!q.exec(QLatin1String("COMMIT"))) {
592         setLastError(QSqlError(tr("Unable to commit transaction"),
593                                q.lastError().databaseText(), QSqlError::TransactionError));
594         return false;
595     }
596
597     return true;
598 }
599
600 bool QSQLiteDriver::rollbackTransaction()
601 {
602     if (!isOpen() || isOpenError())
603         return false;
604
605     QSqlQuery q(createResult());
606     if (!q.exec(QLatin1String("ROLLBACK"))) {
607         setLastError(QSqlError(tr("Unable to rollback transaction"),
608                                q.lastError().databaseText(), QSqlError::TransactionError));
609         return false;
610     }
611
612     return true;
613 }
614
615 QStringList QSQLiteDriver::tables(QSql::TableType type) const
616 {
617     QStringList res;
618     if (!isOpen())
619         return res;
620
621     QSqlQuery q(createResult());
622     q.setForwardOnly(true);
623
624     QString sql = QLatin1String("SELECT name FROM sqlite_master WHERE %1 "
625                                 "UNION ALL SELECT name FROM sqlite_temp_master WHERE %1");
626     if ((type & QSql::Tables) && (type & QSql::Views))
627         sql = sql.arg(QLatin1String("type='table' OR type='view'"));
628     else if (type & QSql::Tables)
629         sql = sql.arg(QLatin1String("type='table'"));
630     else if (type & QSql::Views)
631         sql = sql.arg(QLatin1String("type='view'"));
632     else
633         sql.clear();
634
635     if (!sql.isEmpty() && q.exec(sql)) {
636         while(q.next())
637             res.append(q.value(0).toString());
638     }
639
640     if (type & QSql::SystemTables) {
641         // there are no internal tables beside this one:
642         res.append(QLatin1String("sqlite_master"));
643     }
644
645     return res;
646 }
647
648 static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool onlyPIndex = false)
649 {
650     QString schema;
651     QString table(tableName);
652     int indexOfSeparator = tableName.indexOf(QLatin1Char('.'));
653     if (indexOfSeparator > -1) {
654         schema = tableName.left(indexOfSeparator).append(QLatin1Char('.'));
655         table = tableName.mid(indexOfSeparator + 1);
656     }
657     q.exec(QLatin1String("PRAGMA ") + schema + QLatin1String("table_info (") + _q_escapeIdentifier(table) + QLatin1String(")"));
658
659     QSqlIndex ind;
660     while (q.next()) {
661         bool isPk = q.value(5).toInt();
662         if (onlyPIndex && !isPk)
663             continue;
664         QString typeName = q.value(2).toString().toLower();
665         QSqlField fld(q.value(1).toString(), qGetColumnType(typeName));
666         if (isPk && (typeName == QLatin1String("integer")))
667             // INTEGER PRIMARY KEY fields are auto-generated in sqlite
668             // INT PRIMARY KEY is not the same as INTEGER PRIMARY KEY!
669             fld.setAutoValue(true);
670         fld.setRequired(q.value(3).toInt() != 0);
671         fld.setDefaultValue(q.value(4));
672         ind.append(fld);
673     }
674     return ind;
675 }
676
677 QSqlIndex QSQLiteDriver::primaryIndex(const QString &tblname) const
678 {
679     if (!isOpen())
680         return QSqlIndex();
681
682     QString table = tblname;
683     if (isIdentifierEscaped(table, QSqlDriver::TableName))
684         table = stripDelimiters(table, QSqlDriver::TableName);
685
686     QSqlQuery q(createResult());
687     q.setForwardOnly(true);
688     return qGetTableInfo(q, table, true);
689 }
690
691 QSqlRecord QSQLiteDriver::record(const QString &tbl) const
692 {
693     if (!isOpen())
694         return QSqlRecord();
695
696     QString table = tbl;
697     if (isIdentifierEscaped(table, QSqlDriver::TableName))
698         table = stripDelimiters(table, QSqlDriver::TableName);
699
700     QSqlQuery q(createResult());
701     q.setForwardOnly(true);
702     return qGetTableInfo(q, table);
703 }
704
705 QVariant QSQLiteDriver::handle() const
706 {
707     return QVariant::fromValue(d->access);
708 }
709
710 QString QSQLiteDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const
711 {
712     Q_UNUSED(type);
713     return _q_escapeIdentifier(identifier);
714 }
715
716 QT_END_NAMESPACE