Add sqlite3 plugin

7 files changed, 706 insertions, 0 deletions

diff --git a/plugins/src/sqldrivers/sqldrivers.pro b/plugins/src/sqldrivers/sqldrivers.pro
index 616b23f..0f2e322 100644
--- a/plugins/src/sqldrivers/sqldrivers.pro
+++ b/plugins/src/sqldrivers/sqldrivers.pro
@@ -7,4 +7,5 @@ contains(sql-plugins, tds)	: SUBDIRS += tds
 contains(sql-plugins, oci)	: SUBDIRS += oci
 contains(sql-plugins, db2)	: SUBDIRS += db2
 contains(sql-plugins, sqlite)	: SUBDIRS += sqlite
+contains(sql-plugins, sqlite)	: SUBDIRS += sqlite3
 contains(sql-plugins, ibase)	: SUBDIRS += ibase
diff --git a/plugins/src/sqldrivers/sqlite3/smain.cpp b/plugins/src/sqldrivers/sqlite3/smain.cpp
new file mode 100644
index 0000000..1124bb3
--- /dev/null
+++ b/plugins/src/sqldrivers/sqlite3/smain.cpp
@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** Implementation of SQLite driver plugin
+**
+** Created : 031106
+**
+** Copyright (C) 1992-2003 Trolltech AS.  All rights reserved.
+**
+** This file is part of the sql module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition licenses may use this
+** file in accordance with the Qt Commercial License Agreement provided
+** with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include <qsqldriverplugin.h>
+#include "../../../../src/sql/drivers/sqlite3/qsql_sqlite3.h"
+
+class QSQLite3DriverPlugin : public QSqlDriverPlugin
+{
+public:
+    QSQLite3DriverPlugin();
+
+    QSqlDriver* create( const QString & );
+    QStringList keys() const;
+};
+
+QSQLite3DriverPlugin::QSQLite3DriverPlugin()
+    : QSqlDriverPlugin()
+{
+}
+
+QSqlDriver* QSQLite3DriverPlugin::create( const QString &name )
+{
+    if ( name == "QSQLITE3" ) {
+	QSQLite3Driver* driver = new QSQLite3Driver();
+	return driver;
+    }
+    return 0;
+}
+
+QStringList QSQLite3DriverPlugin::keys() const
+{
+    QStringList l;
+    l  << "QSQLITE3";
+    return l;
+}
+
+Q_EXPORT_PLUGIN( QSQLite3DriverPlugin )
diff --git a/plugins/src/sqldrivers/sqlite3/sqlite3.pro b/plugins/src/sqldrivers/sqlite3/sqlite3.pro
new file mode 100644
index 0000000..c3184f9
--- /dev/null
+++ b/plugins/src/sqldrivers/sqlite3/sqlite3.pro
@@ -0,0 +1,33 @@
+TEMPLATE = lib
+TARGET	 = qsqlite3
+
+CONFIG	+= qt plugin
+DESTDIR	 = ../../../sqldrivers
+
+HEADERS		= ../../../../src/sql/drivers/sqlite3/qsql_sqlite3.h
+SOURCES		= smain.cpp \
+		  ../../../../src/sql/drivers/sqlite3/qsql_sqlite3.cpp
+
+unix {
+	OBJECTS_DIR = .obj
+	!contains( LIBS, .*sqlite3.* ) {
+	    LIBS	*= -lsqlite3
+	}
+}
+
+win32 {
+	OBJECTS_DIR = obj
+	LIBS	*= sqlite3.lib
+#	win32-msvc: {
+#		LIBS *= delayimp.lib
+#		QMAKE_LFLAGS += /DELAYLOAD:sqlite3.dll
+#	}
+#	win32-borland: {
+#		QMAKE_LFLAGS += /dsqlite3.dll
+#	}
+}
+
+REQUIRES	= sql
+
+target.path += $$plugins.path/sqldrivers
+INSTALLS += target
diff --git a/src/sql/drivers/sqlite3/qsql_sqlite3.cpp b/src/sql/drivers/sqlite3/qsql_sqlite3.cpp
new file mode 100644
index 0000000..0bd20d9
--- /dev/null
+++ b/src/sql/drivers/sqlite3/qsql_sqlite3.cpp
@@ -0,0 +1,494 @@
+/****************************************************************************
+**
+** Implementation of SQLite driver classes.
+**
+** Copyright (C) 1992-2003 Trolltech AS. All rights reserved.
+**
+** This file is part of the sql module of the Qt GUI Toolkit.
+** EDITIONS: FREE, ENTERPRISE
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#include "qsql_sqlite3.h"
+
+#include <qdatetime.h>
+#include <qvaluevector.h>
+#include <qregexp.h>
+#include <qfile.h>
+#include <sqlite3.h>
+
+#if (QT_VERSION-0 < 0x030200)
+#  include <qvector.h>
+#  if !defined Q_WS_WIN32
+#    include <unistd.h>
+#  endif
+#else
+#  include <qptrvector.h>
+#  if !defined Q_WS_WIN32
+#    include <unistd.h>
+#  endif
+#endif
+
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+#define QSQLITE3_DRIVER_NAME "QSQLITE3"
+
+static QVariant::Type qSqliteType(int tp)
+{
+    switch (tp) {
+    case SQLITE_INTEGER:
+        return QVariant::Int;
+    case SQLITE_FLOAT:
+        return QVariant::Double;
+    case SQLITE_BLOB:
+        return QVariant::ByteArray;
+    case SQLITE_TEXT:
+    default:
+        return QVariant::String;
+    }
+}
+
+static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::Type type,
+                            int errorCode = -1)
+{
+    return QSqlError(descr,
+                     QString::fromUtf8(sqlite3_errmsg(access)),
+                     type, errorCode);
+}
+
+class QSQLite3DriverPrivate
+{
+public:
+    QSQLite3DriverPrivate();
+    sqlite3 *access;
+    bool utf8;
+};
+
+QSQLite3DriverPrivate::QSQLite3DriverPrivate() : access(0)
+{
+    utf8 = true;
+}
+
+class QSQLite3ResultPrivate
+{
+public:
+    QSQLite3ResultPrivate(QSQLite3Result *res);
+    void cleanup();
+    bool fetchNext(QtSqlCachedResult::RowCache *row);
+    bool isSelect();
+    // initializes the recordInfo and the cache
+    void initColumns(QtSqlCachedResult::RowCache **row = 0);
+    void finalize();
+
+    QSQLite3Result* q;
+    sqlite3 *access;
+
+    sqlite3_stmt *stmt;
+
+    uint skippedStatus: 1; // the status of the fetchNext() that's skipped
+    QtSqlCachedResult::RowCache *skipRow;
+
+    uint utf8: 1;
+    QSqlRecord rInf;
+};
+
+static const uint initial_cache_size = 128;
+
+QSQLite3ResultPrivate::QSQLite3ResultPrivate(QSQLite3Result* res) : q(res), access(0),
+    stmt(0), skippedStatus(false), skipRow(0), utf8(false)
+{
+}
+
+void QSQLite3ResultPrivate::cleanup()
+{
+    finalize();
+    rInf.clear();
+    skippedStatus = false;
+    delete skipRow;
+    skipRow = 0;
+    q->setAt(QSql::BeforeFirst);
+    q->setActive(false);
+    q->cleanup();
+}
+
+void QSQLite3ResultPrivate::finalize()
+{
+    if (!stmt)
+        return;
+
+    sqlite3_finalize(stmt);
+    stmt = 0;
+}
+
+// called on first fetch
+void QSQLite3ResultPrivate::initColumns(QtSqlCachedResult::RowCache** row)
+{
+    rInf.clear();
+
+    int nCols = sqlite3_column_count(stmt);
+    if (nCols <= 0)
+        return;
+
+    q->init(nCols);
+
+    for (int i = 0; i < nCols; ++i) {
+        QString colName = QString::fromUtf8(sqlite3_column_name(stmt, i));
+
+        int dotIdx = colName.findRev('.');
+        rInf.append(QSqlField(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1),
+                qSqliteType(sqlite3_column_type(stmt, i))));
+    }
+
+    // skip the first fetch
+    if (row && !*row) {
+        *row = new QtSqlCachedResult::RowCache(nCols);
+        skipRow = *row;
+    }
+}
+
+bool QSQLite3ResultPrivate::fetchNext(QtSqlCachedResult::RowCache* row)
+{
+    int res;
+    unsigned int i;
+
+    if (skipRow) {
+	// already fetched
+	if (row)
+	    *row = *skipRow;
+	delete skipRow;
+	skipRow = 0;
+	return skippedStatus;
+    }
+
+    if (!stmt)
+        return false;
+
+    // keep trying while busy, wish I could implement this better.
+    while ((res = sqlite3_step(stmt)) == SQLITE_BUSY) {
+        // sleep instead requesting result again immidiately.
+#if defined Q_OS_WIN
+        Sleep(1000);
+#else
+        sleep(1);
+#endif
+    }
+
+    switch(res) {
+    case SQLITE_ROW:
+        // check to see if should fill out columns
+        if (rInf.isEmpty())
+            // must be first call.
+            initColumns(&row);
+        if (!row)
+            return true;
+        for (i = 0; i < rInf.count(); ++i)
+            // todo - handle other types
+            (*row)[i] = QString::fromUtf8((char *)(sqlite3_column_text(stmt, i)));
+ //           values[i + idx] = utf8 ? QString::fromUtf8(fvals[i]) : QString::fromAscii(fvals[i]);
+        return true;
+    case SQLITE_DONE:
+        if (rInf.isEmpty())
+            // must be first call.
+            initColumns(&row);
+        q->setAt(QSql::AfterLast);
+        return false;
+    case SQLITE_ERROR:
+    case SQLITE_MISUSE:
+    default:
+        // something wrong, don't get col info, but still return false
+        q->setLastError(qMakeError(access, "Unable to fetch row", QSqlError::Connection, res));
+        finalize();
+        q->setAt(QSql::AfterLast);
+        return false;
+    }
+    return false;
+}
+
+QSQLite3Result::QSQLite3Result(const QSQLite3Driver* db)
+    : QtSqlCachedResult(db)
+{
+    d = new QSQLite3ResultPrivate(this);
+    d->access = db->d->access;
+}
+
+QSQLite3Result::~QSQLite3Result()
+{
+    d->cleanup();
+    delete d;
+}
+
+/*
+   Execute \a query.
+*/
+bool QSQLite3Result::reset (const QString &query)
+{
+    // this is where we build a query.
+    if (!driver() || !driver()->isOpen() || driver()->isOpenError())
+        return false;
+
+    d->cleanup();
+
+    setSelect(false);
+
+    int res = sqlite3_prepare(d->access, query.utf8().data(), (query.length() + 1) * sizeof(QChar),
+                                &d->stmt, 0);
+
+    if (res != SQLITE_OK) {
+        setLastError(qMakeError(d->access, "Unable to execute statement", QSqlError::Statement, res));
+        d->finalize();
+        return false;
+    }
+
+    d->skippedStatus = d->fetchNext(0);
+
+    setSelect(!d->rInf.isEmpty());
+    setActive(true);
+    return true;
+}
+
+bool QSQLite3Result::gotoNext(QtSqlCachedResult::RowCache* row)
+{
+    return d->fetchNext(row);
+}
+
+int QSQLite3Result::size()
+{
+    return -1;
+}
+
+int QSQLite3Result::numRowsAffected()
+{
+    return sqlite3_changes(d->access);
+}
+
+/////////////////////////////////////////////////////////
+
+QSQLite3Driver::QSQLite3Driver(QObject * parent, const char *name)
+    : QSqlDriver(parent, name)
+{
+    d = new QSQLite3DriverPrivate();
+}
+
+QSQLite3Driver::QSQLite3Driver(sqlite3 *connection, QObject *parent, const char *name)
+    : QSqlDriver(parent, name)
+{
+    d = new QSQLite3DriverPrivate();
+    d->access = connection;
+    setOpen(true);
+    setOpenError(false);
+}
+
+
+QSQLite3Driver::~QSQLite3Driver()
+{
+    delete d;
+}
+
+bool QSQLite3Driver::hasFeature(DriverFeature f) const
+{
+    switch (f) {
+    case Transactions:
+    case Unicode:
+    case BLOB:
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+/*
+   SQLite dbs have no user name, passwords, hosts or ports.
+   just file names.
+*/
+bool QSQLite3Driver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &)
+{
+    if (isOpen())
+        close();
+
+    if (db.isEmpty())
+        return false;
+
+    if (sqlite3_open(QFile::encodeName(db), &d->access) == SQLITE_OK) {
+        setOpen(true);
+        setOpenError(false);
+        return true;
+    } else {
+        setLastError(qMakeError(d->access, "Error opening database",
+                     QSqlError::Connection));
+        setOpenError(true);
+        return false;
+    }
+}
+
+void QSQLite3Driver::close()
+{
+    if (isOpen()) {
+        if (sqlite3_close(d->access) != SQLITE_OK)
+            setLastError(qMakeError(d->access, "Error closing database",
+                                    QSqlError::Connection));
+        d->access = 0;
+        setOpen(false);
+        setOpenError(false);
+    }
+}
+
+QSqlQuery QSQLite3Driver::createQuery() const
+{
+    return QSqlQuery(new QSQLite3Result(this));
+}
+
+bool QSQLite3Driver::beginTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createQuery());
+    if (!q.exec("BEGIN")) {
+        setLastError(QSqlError("Unable to begin transaction",
+                               q.lastError().databaseText(), QSqlError::Transaction));
+        return false;
+    }
+
+    return true;
+}
+
+bool QSQLite3Driver::commitTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createQuery());
+    if (!q.exec("COMMIT")) {
+        setLastError(QSqlError("Unable to begin transaction",
+                               q.lastError().databaseText(), QSqlError::Transaction));
+        return false;
+    }
+
+    return true;
+}
+
+bool QSQLite3Driver::rollbackTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createQuery());
+    if (!q.exec("ROLLBACK")) {
+        setLastError(QSqlError("Unable to begin transaction",
+                               q.lastError().databaseText(), QSqlError::Transaction));
+        return false;
+    }
+
+    return true;
+}
+
+QStringList QSQLite3Driver::tables(const QString &typeName) const
+{
+    QStringList res;
+    if (!isOpen())
+        return res;
+    int type = typeName.toInt();
+
+    QSqlQuery q = createQuery();
+    q.setForwardOnly(TRUE);
+#if (QT_VERSION-0 >= 0x030200)
+    if ((type & (int)QSql::Tables) && (type & (int)QSql::Views))
+        q.exec("SELECT name FROM sqlite_master WHERE type='table' OR type='view'");
+    else if (typeName.isEmpty() || (type & (int)QSql::Tables))
+        q.exec("SELECT name FROM sqlite_master WHERE type='table'");
+    else if (type & (int)QSql::Views)
+        q.exec("SELECT name FROM sqlite_master WHERE type='view'");
+#else
+        q.exec("SELECT name FROM sqlite_master WHERE type='table' OR type='view'");
+#endif
+
+
+    if (q.isActive()) {
+        while(q.next())
+            res.append(q.value(0).toString());
+    }
+
+#if (QT_VERSION-0 >= 0x030200)
+    if (type & (int)QSql::SystemTables) {
+        // there are no internal tables beside this one:
+        res.append("sqlite_master");
+    }
+#endif
+
+    return res;
+}
+
+QSqlIndex QSQLite3Driver::primaryIndex(const QString &tblname) const
+{
+    QSqlRecordInfo rec(recordInfo(tblname)); // expensive :(
+
+    if (!isOpen())
+        return QSqlIndex();
+
+    QSqlQuery q = createQuery();
+    q.setForwardOnly(TRUE);
+    // finrst find a UNIQUE INDEX
+    q.exec("PRAGMA index_list('" + tblname + "');");
+    QString indexname;
+    while(q.next()) {
+	if (q.value(2).toInt()==1) {
+	    indexname = q.value(1).toString();
+	    break;
+	}
+    }
+    if (indexname.isEmpty())
+	return QSqlIndex();
+
+    q.exec("PRAGMA index_info('" + indexname + "');");
+
+    QSqlIndex index(indexname);
+    while(q.next()) {
+	QString name = q.value(2).toString();
+	QSqlVariant::Type type = QSqlVariant::Invalid;
+	if (rec.contains(name))
+	    type = rec.find(name).type();
+	index.append(QSqlField(name, type));
+    }
+    return index;
+}
+
+QSqlRecordInfo QSQLite3Driver::recordInfo(const QString &tbl) const
+{
+    if (!isOpen())
+        return QSqlRecordInfo();
+
+    QSqlQuery q = createQuery();
+    q.setForwardOnly(TRUE);
+    q.exec("SELECT * FROM " + tbl + " LIMIT 1");
+    return recordInfo(q);
+}
+
+QSqlRecord QSQLite3Driver::record(const QString &tblname) const
+{
+    if (!isOpen())
+        return QSqlRecord();
+
+    return recordInfo(tblname).toRecord();
+}
+
+QSqlRecord QSQLite3Driver::record(const QSqlQuery& query) const
+{
+    if (query.isActive() && query.driver() == this) {
+        QSQLite3Result* result = (QSQLite3Result*)query.result();
+        return result->d->rInf;
+    }
+    return QSqlRecord();
+}
+
+QSqlRecordInfo QSQLite3Driver::recordInfo(const QSqlQuery& query) const
+{
+    if (query.isActive() && query.driver() == this) {
+        QSQLite3Result* result = (QSQLite3Result*)query.result();
+        return QSqlRecordInfo(result->d->rInf);
+    }
+    return QSqlRecordInfo();
+}
diff --git a/src/sql/drivers/sqlite3/qsql_sqlite3.h b/src/sql/drivers/sqlite3/qsql_sqlite3.h
new file mode 100644
index 0000000..e92022f
--- /dev/null
+++ b/src/sql/drivers/sqlite3/qsql_sqlite3.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Definition of SQLite driver classes.
+**
+** Copyright (C) 1992-2003 Trolltech AS. All rights reserved.
+**
+** This file is part of the sql module of the Qt GUI Toolkit.
+** EDITIONS: FREE, ENTERPRISE
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#ifndef QSQL_SQLITE3_H
+#define QSQL_SQLITE3_H
+
+#include <qsqldriver.h>
+#include <qsqlresult.h>
+#include <qsqlrecord.h>
+#include <qsqlindex.h>
+#include "qsqlcachedresult.h"
+
+#if (QT_VERSION-0 >= 0x030200)
+typedef QVariant QSqlVariant;
+#endif
+
+#if defined (Q_OS_WIN32)
+# include <qt_windows.h>
+#endif
+
+class QSQLite3DriverPrivate;
+class QSQLite3ResultPrivate;
+class QSQLite3Driver;
+struct sqlite3;
+
+class QSQLite3Result : public QtSqlCachedResult
+{
+    friend class QSQLite3Driver;
+    friend class QSQLite3ResultPrivate;
+public:
+    QSQLite3Result(const QSQLite3Driver* db);
+    ~QSQLite3Result();
+
+protected:
+    bool gotoNext(QtSqlCachedResult::RowCache* row);
+    bool reset (const QString& query);
+    int size();
+    int numRowsAffected();
+
+private:
+    QSQLite3ResultPrivate* d;
+};
+
+class QSQLite3Driver : public QSqlDriver
+{
+    friend class QSQLite3Result;
+public:
+    QSQLite3Driver(QObject *parent = 0, const char *name = 0);
+    QSQLite3Driver(sqlite3 *connection, QObject *parent = 0, const char *name = 0);
+    ~QSQLite3Driver();
+    bool hasFeature(DriverFeature f) const;
+    bool open(const QString & db,
+                   const QString & user,
+                   const QString & password,
+                   const QString & host,
+                   int port,
+                   const QString & connOpts);
+    bool open( const QString & db,
+               const QString & user,
+               const QString & password,
+               const QString & host,
+               int port ) { return open (db, user, password, host, port, QString()); }
+    void close();
+    QSqlQuery createQuery() const;
+    bool beginTransaction();
+    bool commitTransaction();
+    bool rollbackTransaction();
+    QStringList tables(const QString &user) const;
+
+    QSqlRecord record(const QString& tablename) const;
+    QSqlRecordInfo recordInfo(const QString& tablename) const;
+    QSqlIndex primaryIndex(const QString &table) const;
+    QSqlRecord record(const QSqlQuery& query) const;
+    QSqlRecordInfo recordInfo(const QSqlQuery& query) const;
+
+private:
+    QSQLite3DriverPrivate* d;
+};
+#endif
diff --git a/src/sql/qsqldatabase.cpp b/src/sql/qsqldatabase.cpp
index af069a4..8a4f885 100644
--- a/src/sql/qsqldatabase.cpp
+++ b/src/sql/qsqldatabase.cpp
@@ -68,6 +68,9 @@
 #ifdef QT_SQL_SQLITE
 #include "drivers/sqlite/qsql_sqlite.h"
 #endif
+#ifdef QT_SQL_SQLITE3
+#include "drivers/sqlite3/qsql_sqlite3.h"
+#endif
 #ifdef QT_SQL_IBASE
 #include "drivers/ibase/qsql_ibase.h"
 #endif
@@ -525,6 +528,10 @@ QStringList QSqlDatabase::drivers()
     if ( !l.contains( "QSQLITE" ) )
 	l << "QSQLITE";
 #endif
+#ifdef QT_SQL_SQLITE3
+    if ( !l.contains( "QSQLITE3" ) )
+	l << "QSQLITE3";
+#endif
 #ifdef QT_SQL_IBASE
     if ( !l.contains( "QIBASE" ) )
 	l << "QIBASE";
@@ -665,6 +672,11 @@ void QSqlDatabase::init( const QString& type, const QString& )
 	    d->driver = new QSQLiteDriver();
 #endif
 
+#ifdef QT_SQL_SQLITE3
+	if ( type == "QSQLITE3" )
+	    d->driver = new QSQLite3Driver();
+#endif
+
 #ifdef QT_SQL_IBASE
 	if ( type == "QIBASE" )
 	    d->driver = new QIBaseDriver();
diff --git a/src/sql/qt_sql.pri b/src/sql/qt_sql.pri
index 17a6d40..5ccbf3f 100644
--- a/src/sql/qt_sql.pri
+++ b/src/sql/qt_sql.pri
@@ -250,5 +250,11 @@ sql {
             SOURCES += $$SQL_CPP/drivers/sqlite/qsql_sqlite.cpp
             DEFINES += QT_SQL_SQLITE
         }
+
+        contains(sql-drivers, sqlite3) {
+            HEADERS += $$SQL_CPP/drivers/sqlite3/qsql_sqlite3.h
+            SOURCES += $$SQL_CPP/drivers/sqlite3/qsql_sqlite3.cpp
+            DEFINES += QT_SQL_SQLITE3
+        }
 }