diff --git a/0032-QSqlite3-fix-build-with-Qt-5.7.patch b/0032-QSqlite3-fix-build-with-Qt-5.7.patch new file mode 100644 index 0000000..637ebb2 --- /dev/null +++ b/0032-QSqlite3-fix-build-with-Qt-5.7.patch @@ -0,0 +1,911 @@ +From 068c0bd5f93232eea97e492354eff2b9b62c6643 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Daniel=20Vr=C3=A1til?= +Date: Sun, 5 Jun 2016 15:49:29 +0200 +Subject: [PATCH 32/58] QSqlite3: fix build with Qt 5.7 + +Use ${QtSql_PRIVATE_INCLUDE_DIRS} to include the private headers +directly from current Qt install instead of carrying a local copy. +--- + CMakeLists.txt | 10 +- + src/qsqlite/CMakeLists.txt | 2 + + src/qsqlite/src/QtSql/private/qobject_p.h | 434 --------------------- + src/qsqlite/src/QtSql/private/qsqlcachedresult_p.h | 100 ----- + src/qsqlite/src/QtSql/private/qsqldriver_p.h | 86 ---- + src/qsqlite/src/qsql_sqlite.cpp | 70 +++- + 6 files changed, 64 insertions(+), 638 deletions(-) + delete mode 100644 src/qsqlite/src/QtSql/private/qobject_p.h + delete mode 100644 src/qsqlite/src/QtSql/private/qsqlcachedresult_p.h + delete mode 100644 src/qsqlite/src/QtSql/private/qsqldriver_p.h + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 4df23e0..f6647fb 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -31,7 +31,8 @@ ecm_setup_version(${AKONADI_VERSION} + SOVERSION 5) + + # Find packages +-find_package(Qt5Core ${QT_REQUIRED_VERSION} CONFIG REQUIRED) ++find_package(Qt5Core ${QT_REQUIRED_VERSION} REQUIRED COMPONENTS Private) ++find_package(Qt5Sql ${QT_REQUIRED_VERSION} REQUIRED COMPONENTS Private) + find_package(Qt5Gui ${QT_REQUIRED_VERSION} CONFIG REQUIRED) + find_package(Qt5Widgets ${QT_REQUIRED_VERSION} CONFIG REQUIRED) + find_package(Qt5Sql ${QT_REQUIRED_VERSION} CONFIG REQUIRED) +@@ -129,7 +130,7 @@ else() + set(SQLITE_TYPE "OPTIONAL") + endif() + +-if(AKONADI_BUILD_QSQLITE AND Qt5Core_VERSION VERSION_LESS 5.7.0) # API change in 5.7 breaks our sqlite driver ++if(AKONADI_BUILD_QSQLITE) + set(SQLITE_MIN_VERSION 3.6.23) + find_package(Sqlite ${SQLITE_MIN_VERSION}) + set_package_properties(Sqlite PROPERTIES + +diff --git a/src/qsqlite/CMakeLists.txt b/src/qsqlite/CMakeLists.txt +index 228cd10..b2f7f0c 100644 +--- a/src/qsqlite/CMakeLists.txt ++++ b/src/qsqlite/CMakeLists.txt +@@ -9,6 +9,8 @@ message(STATUS "Building QSQLITE3 driver") + set(QSQLITE_INSTALL_PREFIX "${PLUGIN_INSTALL_DIR}/sqldrivers") + + include_directories( ++ ${Qt5Core_PRIVATE_INCLUDE_DIRS} ++ ${Qt5Sql_PRIVATE_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR}/src + ${SQLITE_INCLUDE_DIR} + ) +diff --git a/src/qsqlite/src/QtSql/private/qobject_p.h b/src/qsqlite/src/QtSql/private/qobject_p.h +deleted file mode 100644 +index 180887b..0000000 +--- a/src/qsqlite/src/QtSql/private/qobject_p.h ++++ /dev/null +@@ -1,434 +0,0 @@ +-/**************************************************************************** +-** +-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +-** Copyright (C) 2013 Olivier Goffart +-** Contact: http://www.qt-project.org/legal +-** +-** This file is part of the QtCore module of the Qt Toolkit. +-** +-** $QT_BEGIN_LICENSE:LGPL$ +-** Commercial License Usage +-** Licensees holding valid commercial Qt licenses may use this file in +-** accordance with the commercial license agreement provided with the +-** Software or, alternatively, in accordance with the terms contained in +-** a written agreement between you and Digia. For licensing terms and +-** conditions see http://qt.digia.com/licensing. For further information +-** use the contact form at http://qt.digia.com/contact-us. +-** +-** GNU Lesser General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU Lesser +-** General Public License version 2.1 as published by the Free Software +-** Foundation and appearing in the file LICENSE.LGPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU Lesser General Public License version 2.1 requirements +-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +-** +-** In addition, as a special exception, Digia gives you certain additional +-** rights. These rights are described in the Digia Qt LGPL Exception +-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +-** +-** GNU General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU +-** General Public License version 3.0 as published by the Free Software +-** Foundation and appearing in the file LICENSE.GPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU General Public License version 3.0 requirements will be +-** met: http://www.gnu.org/copyleft/gpl.html. +-** +-** +-** $QT_END_LICENSE$ +-** +-****************************************************************************/ +- +-#ifndef QOBJECT_P_H +-#define QOBJECT_P_H +- +-// +-// W A R N I N G +-// ------------- +-// +-// This file is not part of the Qt API. It exists for the convenience +-// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp. This header +-// file may change from version to version without notice, or even be removed. +-// +-// We mean it. +-// +- +-#include "QtCore/qobject.h" +-#include "QtCore/qpointer.h" +-#include "QtCore/qsharedpointer.h" +-#include "QtCore/qcoreevent.h" +-#include "QtCore/qlist.h" +-#include "QtCore/qvector.h" +-#include "QtCore/qvariant.h" +-#include "QtCore/qreadwritelock.h" +- +-QT_BEGIN_NAMESPACE +- +-class QVariant; +-class QThreadData; +-class QObjectConnectionListVector; +-namespace QtSharedPointer { struct ExternalRefCountData; } +- +-/* for Qt Test */ +-struct QSignalSpyCallbackSet +-{ +- typedef void (*BeginCallback)(QObject *caller, int signal_or_method_index, void **argv); +- typedef void (*EndCallback)(QObject *caller, int signal_or_method_index); +- BeginCallback signal_begin_callback, +- slot_begin_callback; +- EndCallback signal_end_callback, +- slot_end_callback; +-}; +-void Q_CORE_EXPORT qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set); +- +-extern QSignalSpyCallbackSet Q_CORE_EXPORT qt_signal_spy_callback_set; +- +-enum { QObjectPrivateVersion = QT_VERSION }; +- +-class Q_CORE_EXPORT QAbstractDeclarativeData +-{ +-public: +- static void (*destroyed)(QAbstractDeclarativeData *, QObject *); +- static void (*destroyed_qml1)(QAbstractDeclarativeData *, QObject *); +- static void (*parentChanged)(QAbstractDeclarativeData *, QObject *, QObject *); +- static void (*signalEmitted)(QAbstractDeclarativeData *, QObject *, int, void **); +- static int (*receivers)(QAbstractDeclarativeData *, const QObject *, int); +- static bool (*isSignalConnected)(QAbstractDeclarativeData *, const QObject *, int); +-}; +- +-// This is an implementation of QAbstractDeclarativeData that is identical with +-// the implementation in QtDeclarative and QtQml for the first bit +-struct QAbstractDeclarativeDataImpl : public QAbstractDeclarativeData +-{ +- quint32 ownedByQml1:1; +- quint32 unused: 31; +-}; +- +-class Q_CORE_EXPORT QObjectPrivate : public QObjectData +-{ +- Q_DECLARE_PUBLIC(QObject) +- +-public: +- struct ExtraData +- { +- ExtraData() {} +- #ifndef QT_NO_USERDATA +- QVector userData; +- #endif +- QList propertyNames; +- QList propertyValues; +- QVector runningTimers; +- QList > eventFilters; +- QString objectName; +- }; +- +- typedef void (*StaticMetaCallFunction)(QObject *, QMetaObject::Call, int, void **); +- struct Connection +- { +- QObject *sender; +- QObject *receiver; +- union { +- StaticMetaCallFunction callFunction; +- QtPrivate::QSlotObjectBase *slotObj; +- }; +- // The next pointer for the singly-linked ConnectionList +- Connection *nextConnectionList; +- //senders linked list +- Connection *next; +- Connection **prev; +- QAtomicPointer argumentTypes; +- QAtomicInt ref_; +- ushort method_offset; +- ushort method_relative; +- uint signal_index : 27; // In signal range (see QObjectPrivate::signalIndex()) +- ushort connectionType : 3; // 0 == auto, 1 == direct, 2 == queued, 4 == blocking +- ushort isSlotObject : 1; +- ushort ownArgumentTypes : 1; +- Connection() : nextConnectionList(0), ref_(2), ownArgumentTypes(true) { +- //ref_ is 2 for the use in the internal lists, and for the use in QMetaObject::Connection +- } +- ~Connection(); +- int method() const { return method_offset + method_relative; } +- void ref() { ref_.ref(); } +- void deref() { +- if (!ref_.deref()) { +- Q_ASSERT(!receiver); +- delete this; +- } +- } +- }; +- // ConnectionList is a singly-linked list +- struct ConnectionList { +- ConnectionList() : first(0), last(0) {} +- Connection *first; +- Connection *last; +- }; +- +- struct Sender +- { +- QObject *sender; +- int signal; +- int ref; +- }; +- +- +- QObjectPrivate(int version = QObjectPrivateVersion); +- virtual ~QObjectPrivate(); +- void deleteChildren(); +- +- void setParent_helper(QObject *); +- void moveToThread_helper(); +- void setThreadData_helper(QThreadData *currentData, QThreadData *targetData); +- void _q_reregisterTimers(void *pointer); +- +- bool isSender(const QObject *receiver, const char *signal) const; +- QObjectList receiverList(const char *signal) const; +- QObjectList senderList() const; +- +- void addConnection(int signal, Connection *c); +- void cleanConnectionLists(); +- +- static inline Sender *setCurrentSender(QObject *receiver, +- Sender *sender); +- static inline void resetCurrentSender(QObject *receiver, +- Sender *currentSender, +- Sender *previousSender); +- +- static QObjectPrivate *get(QObject *o) { +- return o->d_func(); +- } +- +- int signalIndex(const char *signalName, const QMetaObject **meta = 0) const; +- inline bool isSignalConnected(uint signalIdx) const; +- +- // To allow abitrary objects to call connectNotify()/disconnectNotify() without making +- // the API public in QObject. This is used by QQmlNotifierEndpoint. +- inline void connectNotify(const QMetaMethod &signal); +- inline void disconnectNotify(const QMetaMethod &signal); +- +- template +- static inline QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer::Object *sender, Func1 signal, +- const typename QtPrivate::FunctionPointer::Object *receiverPrivate, Func2 slot, +- Qt::ConnectionType type = Qt::AutoConnection); +- +- template +- static inline bool disconnect(const typename QtPrivate::FunctionPointer::Object *sender, Func1 signal, +- const typename QtPrivate::FunctionPointer::Object *receiverPrivate, Func2 slot); +- +- static QMetaObject::Connection connectImpl(const QObject *sender, int signal_index, +- const QObject *receiver, void **slot, +- QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type, +- const int *types, const QMetaObject *senderMetaObject); +- static QMetaObject::Connection connect(const QObject *sender, int signal_index, QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type); +- static bool disconnect(const QObject *sender, int signal_index, void **slot); +-public: +- ExtraData *extraData; // extra data set by the user +- QThreadData *threadData; // id of the thread that owns the object +- +- QObjectConnectionListVector *connectionLists; +- +- Connection *senders; // linked list of connections connected to this object +- Sender *currentSender; // object currently activating the object +- mutable quint32 connectedSignals[2]; +- +- union { +- QObject *currentChildBeingDeleted; +- QAbstractDeclarativeData *declarativeData; //extra data used by the declarative module +- }; +- +- // these objects are all used to indicate that a QObject was deleted +- // plus QPointer, which keeps a separate list +- QAtomicPointer sharedRefcount; +-}; +- +- +-/*! \internal +- +- Returns \c true if the signal with index \a signal_index from object \a sender is connected. +- Signals with indices above a certain range are always considered connected (see connectedSignals +- in QObjectPrivate). +- +- \a signal_index must be the index returned by QObjectPrivate::signalIndex; +-*/ +-inline bool QObjectPrivate::isSignalConnected(uint signal_index) const +-{ +- return signal_index >= sizeof(connectedSignals) * 8 +- || (connectedSignals[signal_index >> 5] & (1 << (signal_index & 0x1f)) +- || (declarativeData && QAbstractDeclarativeData::isSignalConnected +- && QAbstractDeclarativeData::isSignalConnected(declarativeData, q_func(), signal_index))); +-} +- +-inline QObjectPrivate::Sender *QObjectPrivate::setCurrentSender(QObject *receiver, +- Sender *sender) +-{ +- Sender *previousSender = receiver->d_func()->currentSender; +- receiver->d_func()->currentSender = sender; +- return previousSender; +-} +- +-inline void QObjectPrivate::resetCurrentSender(QObject *receiver, +- Sender *currentSender, +- Sender *previousSender) +-{ +- // ref is set to zero when this object is deleted during the metacall +- if (currentSender->ref == 1) +- receiver->d_func()->currentSender = previousSender; +- // if we've recursed, we need to tell the caller about the objects deletion +- if (previousSender) +- previousSender->ref = currentSender->ref; +-} +- +-inline void QObjectPrivate::connectNotify(const QMetaMethod &signal) +-{ +- q_ptr->connectNotify(signal); +-} +- +-inline void QObjectPrivate::disconnectNotify(const QMetaMethod &signal) +-{ +- q_ptr->disconnectNotify(signal); +-} +- +-namespace QtPrivate { +-template class QPrivateSlotObject : public QSlotObjectBase +-{ +- typedef QtPrivate::FunctionPointer FuncType; +- Func function; +- static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret) +- { +- switch (which) { +- case Destroy: +- delete static_cast(this_); +- break; +- case Call: +- FuncType::template call(static_cast(this_)->function, +- static_cast(QObjectPrivate::get(r)), a); +- break; +- case Compare: +- *ret = *reinterpret_cast(a) == static_cast(this_)->function; +- break; +- case NumOperations: ; +- } +- } +-public: +- explicit QPrivateSlotObject(Func f) : QSlotObjectBase(&impl), function(f) {} +-}; +-} //namespace QtPrivate +- +-template +-inline QMetaObject::Connection QObjectPrivate::connect(const typename QtPrivate::FunctionPointer::Object *sender, Func1 signal, +- const typename QtPrivate::FunctionPointer::Object *receiverPrivate, Func2 slot, +- Qt::ConnectionType type) +-{ +- typedef QtPrivate::FunctionPointer SignalType; +- typedef QtPrivate::FunctionPointer SlotType; +- Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro::Value, +- "No Q_OBJECT in the class with the signal"); +- +- //compilation error if the arguments does not match. +- Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount), +- "The slot requires more arguments than the signal provides."); +- Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments::value), +- "Signal and slot arguments are not compatible."); +- Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible::value), +- "Return type of the slot is not compatible with the return type of the signal."); +- +- const int *types = 0; +- if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection) +- types = QtPrivate::ConnectionTypes::types(); +- +- return QObject::connectImpl(sender, reinterpret_cast(&signal), +- receiverPrivate->q_ptr, reinterpret_cast(&slot), +- new QtPrivate::QPrivateSlotObject::Value, +- typename SignalType::ReturnType>(slot), +- type, types, &SignalType::Object::staticMetaObject); +-} +- +-template +-bool QObjectPrivate::disconnect(const typename QtPrivate::FunctionPointer< Func1 >::Object* sender, Func1 signal, +- const typename QtPrivate::FunctionPointer< Func2 >::Object* receiverPrivate, Func2 slot) +-{ +- typedef QtPrivate::FunctionPointer SignalType; +- typedef QtPrivate::FunctionPointer SlotType; +- Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro::Value, +- "No Q_OBJECT in the class with the signal"); +- //compilation error if the arguments does not match. +- Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments::value), +- "Signal and slot arguments are not compatible."); +- return QObject::disconnectImpl(sender, reinterpret_cast(&signal), +- receiverPrivate->q_ptr, reinterpret_cast(&slot), +- &SignalType::Object::staticMetaObject); +-} +- +-Q_DECLARE_TYPEINFO(QObjectPrivate::Connection, Q_MOVABLE_TYPE); +-Q_DECLARE_TYPEINFO(QObjectPrivate::Sender, Q_MOVABLE_TYPE); +- +-class QSemaphore; +-class Q_CORE_EXPORT QMetaCallEvent : public QEvent +-{ +-public: +- QMetaCallEvent(ushort method_offset, ushort method_relative, QObjectPrivate::StaticMetaCallFunction callFunction , const QObject *sender, int signalId, +- int nargs = 0, int *types = 0, void **args = 0, QSemaphore *semaphore = 0); +- /*! \internal +- \a signalId is in the signal index range (see QObjectPrivate::signalIndex()). +- */ +- QMetaCallEvent(QtPrivate::QSlotObjectBase *slotObj, const QObject *sender, int signalId, +- int nargs = 0, int *types = 0, void **args = 0, QSemaphore *semaphore = 0); +- +- ~QMetaCallEvent(); +- +- inline int id() const { return method_offset_ + method_relative_; } +- inline const QObject *sender() const { return sender_; } +- inline int signalId() const { return signalId_; } +- inline void **args() const { return args_; } +- +- virtual void placeMetaCall(QObject *object); +- +-private: +- QtPrivate::QSlotObjectBase *slotObj_; +- const QObject *sender_; +- int signalId_; +- int nargs_; +- int *types_; +- void **args_; +- QSemaphore *semaphore_; +- QObjectPrivate::StaticMetaCallFunction callFunction_; +- ushort method_offset_; +- ushort method_relative_; +-}; +- +-class QBoolBlocker +-{ +- Q_DISABLE_COPY(QBoolBlocker) +-public: +- explicit inline QBoolBlocker(bool &b, bool value=true):block(b), reset(b){block = value;} +- inline ~QBoolBlocker(){block = reset; } +-private: +- bool █ +- bool reset; +-}; +- +-void Q_CORE_EXPORT qDeleteInEventHandler(QObject *o); +- +-struct QAbstractDynamicMetaObject; +-struct Q_CORE_EXPORT QDynamicMetaObjectData +-{ +- virtual ~QDynamicMetaObjectData() {} +- virtual void objectDestroyed(QObject *) { delete this; } +- +- virtual QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) = 0; +- virtual int metaCall(QObject *, QMetaObject::Call, int _id, void **) = 0; +-}; +- +-struct Q_CORE_EXPORT QAbstractDynamicMetaObject : public QDynamicMetaObjectData, public QMetaObject +-{ +- virtual QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) { return this; } +- virtual int createProperty(const char *, const char *) { return -1; } +- virtual int metaCall(QObject *, QMetaObject::Call c, int _id, void **a) +- { return metaCall(c, _id, a); } +- virtual int metaCall(QMetaObject::Call, int _id, void **) { return _id; } // Compat overload +-}; +- +-QT_END_NAMESPACE +- +-#endif // QOBJECT_P_H +diff --git a/src/qsqlite/src/QtSql/private/qsqlcachedresult_p.h b/src/qsqlite/src/QtSql/private/qsqlcachedresult_p.h +deleted file mode 100644 +index ce15cfe..0000000 +--- a/src/qsqlite/src/QtSql/private/qsqlcachedresult_p.h ++++ /dev/null +@@ -1,100 +0,0 @@ +-/**************************************************************************** +-** +-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +-** All rights reserved. +-** Contact: Nokia Corporation (qt-info@nokia.com) +-** +-** This file is part of the QtSql module of the Qt Toolkit. +-** +-** $QT_BEGIN_LICENSE:LGPL$ +-** Commercial Usage +-** Licensees holding valid Qt Commercial licenses may use this file in +-** accordance with the Qt Commercial License Agreement provided with the +-** Software or, alternatively, in accordance with the terms contained in +-** a written agreement between you and Nokia. +-** +-** GNU Lesser General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU Lesser +-** General Public License version 2.1 as published by the Free Software +-** Foundation and appearing in the file LICENSE.LGPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU Lesser General Public License version 2.1 requirements +-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +-** +-** In addition, as a special exception, Nokia gives you certain additional +-** rights. These rights are described in the Nokia Qt LGPL Exception +-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +-** +-** GNU General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU +-** General Public License version 3.0 as published by the Free Software +-** Foundation and appearing in the file LICENSE.GPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU General Public License version 3.0 requirements will be +-** met: http://www.gnu.org/copyleft/gpl.html. +-** +-** If you have questions regarding the use of this file, please contact +-** Nokia at qt-info@nokia.com. +-** $QT_END_LICENSE$ +-** +-****************************************************************************/ +- +-#ifndef QSQLCACHEDRESULT_P_H +-#define QSQLCACHEDRESULT_P_H +- +-// +-// W A R N I N G +-// ------------- +-// +-// This file is not part of the Qt API. It exists for the convenience +-// of other Qt classes. This header file may change from version to +-// version without notice, or even be removed. +-// +-// We mean it. +-// +- +-#include "QtSql/qsqlresult.h" +- +-QT_BEGIN_NAMESPACE +- +-class QVariant; +-template class QVector; +- +-class QSqlCachedResultPrivate; +- +-class Q_SQL_EXPORT QSqlCachedResult: public QSqlResult +-{ +-public: +- virtual ~QSqlCachedResult(); +- +- typedef QVector ValueCache; +- +-protected: +- QSqlCachedResult(const QSqlDriver * db); +- +- void init(int colCount); +- void cleanup(); +- void clearValues(); +- +- virtual bool gotoNext(ValueCache &values, int index) = 0; +- +- QVariant data(int i); +- bool isNull(int i); +- bool fetch(int i); +- bool fetchNext(); +- bool fetchPrevious(); +- bool fetchFirst(); +- bool fetchLast(); +- +- int colCount() const; +- ValueCache &cache(); +- +- void virtual_hook(int id, void *data); +-private: +- bool cacheNext(); +- QSqlCachedResultPrivate *d; +-}; +- +-QT_END_NAMESPACE +- +-#endif // QSQLCACHEDRESULT_P_H +diff --git a/src/qsqlite/src/QtSql/private/qsqldriver_p.h b/src/qsqlite/src/QtSql/private/qsqldriver_p.h +deleted file mode 100644 +index 15b51f8..0000000 +--- a/src/qsqlite/src/QtSql/private/qsqldriver_p.h ++++ /dev/null +@@ -1,86 +0,0 @@ +-/**************************************************************************** +-** +-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +-** Contact: http://www.qt-project.org/legal +-** +-** This file is part of the QtSql module of the Qt Toolkit. +-** +-** $QT_BEGIN_LICENSE:LGPL$ +-** Commercial License Usage +-** Licensees holding valid commercial Qt licenses may use this file in +-** accordance with the commercial license agreement provided with the +-** Software or, alternatively, in accordance with the terms contained in +-** a written agreement between you and Digia. For licensing terms and +-** conditions see http://qt.digia.com/licensing. For further information +-** use the contact form at http://qt.digia.com/contact-us. +-** +-** GNU Lesser General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU Lesser +-** General Public License version 2.1 as published by the Free Software +-** Foundation and appearing in the file LICENSE.LGPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU Lesser General Public License version 2.1 requirements +-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +-** +-** In addition, as a special exception, Digia gives you certain additional +-** rights. These rights are described in the Digia Qt LGPL Exception +-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +-** +-** GNU General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU +-** General Public License version 3.0 as published by the Free Software +-** Foundation and appearing in the file LICENSE.GPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU General Public License version 3.0 requirements will be +-** met: http://www.gnu.org/copyleft/gpl.html. +-** +-** +-** $QT_END_LICENSE$ +-** +-****************************************************************************/ +- +-#ifndef QSQLDRIVER_P_H +-#define QSQLDRIVER_P_H +- +-// +-// W A R N I N G +-// ------------- +-// +-// This file is not part of the Qt API. It exists for the convenience +-// of the QtSQL module. This header file may change from version to version +-// without notice, or even be removed. +-// +-// We mean it. +-// +- +-#include "qobject_p.h" +-#include "qsqldriver.h" +-#include "qsqlerror.h" +- +-QT_BEGIN_NAMESPACE +- +-class QSqlDriverPrivate : public QObjectPrivate +-{ +- Q_DECLARE_PUBLIC(QSqlDriver) +- +-public: +- enum DBMSType {UnknownDB, MSSqlServer, MySqlServer, PostgreSQL, Oracle, Sybase, SQLite, Interbase, DB2}; +- +- QSqlDriverPrivate() +- : QObjectPrivate(), +- isOpen(false), +- isOpenError(false), +- precisionPolicy(QSql::LowPrecisionDouble), +- dbmsType(UnknownDB) +- { } +- +- uint isOpen; +- uint isOpenError; +- QSqlError error; +- QSql::NumericalPrecisionPolicy precisionPolicy; +- DBMSType dbmsType; +-}; +- +-QT_END_NAMESPACE +- +-#endif // QSQLDRIVER_P_H +diff --git a/src/qsqlite/src/qsql_sqlite.cpp b/src/qsqlite/src/qsql_sqlite.cpp +index 06301cf..e4971a3 100644 +--- a/src/qsqlite/src/qsql_sqlite.cpp ++++ b/src/qsqlite/src/qsql_sqlite.cpp +@@ -51,8 +51,8 @@ + #include + #include + +-#include "QtSql/private/qsqldriver_p.h" +-#include "QtSql/private/qsqlcachedresult_p.h" ++#include ++#include + + #if defined Q_OS_WIN + # include +@@ -136,7 +136,10 @@ protected: + void virtual_hook(int id, void *data); + + private: +- QSQLiteResultPrivate* d; ++#if QT_VERSION < QT_VERSION_CHECK(5, 7, 0) ++ QSQLiteResultPrivate* d_ptr; ++#endif ++ Q_DECLARE_PRIVATE(QSQLiteResult) + }; + + +@@ -144,24 +147,33 @@ class QSQLiteDriverPrivate : public QSqlDriverPrivate + { + public: + inline QSQLiteDriverPrivate() : access(0) { +- dbmsType = SQLite; ++ dbmsType = QSqlDriver::SQLite; + } + sqlite3 *access; + QList results; + }; + + ++#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) ++class QSQLiteResultPrivate : public QSqlCachedResultPrivate ++#else + class QSQLiteResultPrivate ++#endif + { + public: ++#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) ++ QSQLiteResultPrivate(QSQLiteResult *res, const QSQLiteDriver *drv); ++#else + QSQLiteResultPrivate(QSQLiteResult *res); ++ QSQLiteResult* q_ptr; ++#endif ++ + void cleanup(); + bool fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch); + // initializes the recordInfo and the cache + void initColumns(bool emptyResultset); + void finalize(); + +- QSQLiteResult* q; + sqlite3 *access; + + sqlite3_stmt *stmt; +@@ -170,15 +182,27 @@ public: + bool skipRow; // skip the next fetchNext()? + QSqlRecord rInf; + QVector firstRow; ++ ++ Q_DECLARE_PUBLIC(QSQLiteResult) + }; + +-QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult* res) : q(res), access(0), +- stmt(0), skippedStatus(false), skipRow(false) ++#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) ++QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult *res, const QSQLiteDriver *drv) ++ : QSqlCachedResultPrivate(res, drv) ++#else ++QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult* res) ++ : q_ptr(res) ++#endif ++ , access(0) ++ , stmt(0) ++ , skippedStatus(false) ++ , skipRow(false) + { + } + + void QSQLiteResultPrivate::cleanup() + { ++ Q_Q(QSQLiteResult); + finalize(); + rInf.clear(); + skippedStatus = false; +@@ -199,6 +223,7 @@ void QSQLiteResultPrivate::finalize() + + void QSQLiteResultPrivate::initColumns(bool emptyResultset) + { ++ Q_Q(QSQLiteResult); + int nCols = sqlite3_column_count(stmt); + if (nCols <= 0) + return; +@@ -251,6 +276,8 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset) + + bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch) + { ++ Q_Q(QSQLiteResult); ++ + int res; + int i; + +@@ -351,20 +378,28 @@ bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int i + } + + QSQLiteResult::QSQLiteResult(const QSQLiteDriver* db) ++#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) ++ : QSqlCachedResult(*new QSQLiteResultPrivate(this, db)) ++#else + : QSqlCachedResult(db) ++ , d_ptr(new QSQLiteResultPrivate(this)) ++#endif + { +- d = new QSQLiteResultPrivate(this); ++ Q_D(QSQLiteResult); + d->access = db->d_func()->access; + const_cast(db->d_func())->results.append(this); + } + + QSQLiteResult::~QSQLiteResult() + { ++ Q_D(QSQLiteResult); + const QSqlDriver *sqlDriver = driver(); + if (sqlDriver) + const_cast(qobject_cast(sqlDriver)->d_func())->results.removeOne(this); + d->cleanup(); ++#if QT_VERSION < QT_VERSION_CHECK(5, 7, 0) + delete d; ++#endif + } + + void QSQLiteResult::virtual_hook(int id, void *data) +@@ -381,6 +416,8 @@ bool QSQLiteResult::reset(const QString &query) + + bool QSQLiteResult::prepare(const QString &query) + { ++ Q_D(QSQLiteResult); ++ + if (!driver() || !driver()->isOpen() || driver()->isOpenError()) + return false; + +@@ -416,6 +453,7 @@ bool QSQLiteResult::prepare(const QString &query) + + bool QSQLiteResult::exec() + { ++ Q_D(QSQLiteResult); + const QVector values = boundValues(); + + d->skippedStatus = false; +@@ -510,7 +548,7 @@ bool QSQLiteResult::exec() + + bool QSQLiteResult::gotoNext(QSqlCachedResult::ValueCache& row, int idx) + { +- return d->fetchNext(row, idx, false); ++ return d_func()->fetchNext(row, idx, false); + } + + int QSQLiteResult::size() +@@ -520,13 +558,13 @@ int QSQLiteResult::size() + + int QSQLiteResult::numRowsAffected() + { +- return sqlite3_changes(d->access); ++ return sqlite3_changes(d_func()->access); + } + + QVariant QSQLiteResult::lastInsertId() const + { + if (isActive()) { +- qint64 id = sqlite3_last_insert_rowid(d->access); ++ qint64 id = sqlite3_last_insert_rowid(d_func()->access); + if (id) + return id; + } +@@ -537,18 +575,18 @@ QSqlRecord QSQLiteResult::record() const + { + if (!isActive() || !isSelect()) + return QSqlRecord(); +- return d->rInf; ++ return d_func()->rInf; + } + + void QSQLiteResult::detachFromResultSet() + { +- if (d->stmt) +- sqlite3_reset(d->stmt); ++ if (d_func()->stmt) ++ sqlite3_reset(d_func()->stmt); + } + + QVariant QSQLiteResult::handle() const + { +- return qVariantFromValue(d->stmt); ++ return qVariantFromValue(d_func()->stmt); + } + + ///////////////////////////////////////////////////////// +@@ -660,7 +698,7 @@ void QSQLiteDriver::close() + + if (isOpen()) { + Q_FOREACH (QSQLiteResult *result, d->results) { +- result->d->finalize(); ++ result->d_func()->finalize(); + } + + if (sqlite3_close(d->access) != SQLITE_OK) +-- +2.7.4 + diff --git a/akonadiserverrc.sqlite b/akonadiserverrc.sqlite new file mode 100644 index 0000000..cd29ea5 --- /dev/null +++ b/akonadiserverrc.sqlite @@ -0,0 +1,2 @@ +[%General] +Driver=QSQLITE3 diff --git a/kf5-akonadi-server.spec b/kf5-akonadi-server.spec index e8182bf..3211e34 100644 --- a/kf5-akonadi-server.spec +++ b/kf5-akonadi-server.spec @@ -1,8 +1,5 @@ %global framework akonadi-server -# base pkg default to SQLITE now, install -mysql if you want that instead -%global database_backend SQLITE - # trim changelog included in binary rpms %global _changelog_trimtime %(date +%s -d "1 year ago") @@ -37,10 +34,14 @@ Source0: http://download.kde.org/%{stable}/applications/%{version}/src/akonadi-% ## mysql config Source10: akonadiserverrc.mysql +Source11: akonadiserverrc.sqlite ## upstreamable patches ## upstream patches +## 16.08 branch +# fix sqlite backend FTBFS +Patch32: 0032-QSqlite3-fix-build-with-Qt-5.7.patch %define mysql_conf_timestamp 20140709 @@ -82,6 +83,8 @@ BuildRequires: xorg-x11-server-Xvfb %endif Requires: kf5-filesystem +Requires(post): %{_sbindir}/update-alternatives +Requires(postun): %{_sbindir}/update-alternatives Recommends: %{name}-mysql = %{version}-%{release} @@ -141,7 +144,6 @@ mkdir %{_target_platform} pushd %{_target_platform} %{cmake_kf5} .. \ %{?database_backend:-DDATABASE_BACKEND=%{database_backend}} \ - -DINSTALL_QSQLITE_IN_QT_PREFIX:BOOL=ON \ -DBUILD_TESTING:BOOL=%{?tests:ON}%{!?tests:OFF} popd @@ -152,6 +154,7 @@ make %{?_smp_mflags} -C %{_target_platform} make install/fast DESTDIR=$RPM_BUILD_ROOT -C %{_target_platform} install -p -m644 -D %{SOURCE10} %{buildroot}%{_sysconfdir}/xdg/akonadi/akonadiserverrc.mysql +install -p -m644 -D %{SOURCE11} %{buildroot}%{_sysconfdir}/xdg/akonadi/akonadiserverrc.sqlite mkdir -p %{buildroot}%{_datadir}/akonadi/agents @@ -184,6 +187,11 @@ make test ARGS="--output-on-failure --timeout 300" -C %{_target_platform} ||: %post /sbin/ldconfig touch --no-create %{_datadir}/mime/packages &> /dev/null || : +%{_sbindir}/update-alternatives \ + --install %{_sysconfdir}/xdg/akonadi/akonadiserverrc \ + akonadiserverrc \ + %{_sysconfdir}/xdg/akonadi/akonadiserverrc.sqlite \ + 8 %posttrans update-mime-database %{?fedora:-n} %{_datadir}/mime &> /dev/null || : @@ -191,15 +199,20 @@ update-mime-database %{?fedora:-n} %{_datadir}/mime &> /dev/null || : %postun /sbin/ldconfig ||: if [ $1 -eq 0 ] ; then - touch --no-create %{_datadir}/mime/packages &> /dev/null || : - update-mime-database %{?fedora:-n} %{_datadir}/mime &> /dev/null ||: +touch --no-create %{_datadir}/mime/packages &> /dev/null || : +update-mime-database %{?fedora:-n} %{_datadir}/mime &> /dev/null ||: +%{_sbindir}/update-alternatives \ + --remove akonadiserverrc \ + %{_sysconfdir}/xdg/akonadi/akonadiserverrc.sqlite fi + %files %doc AUTHORS README %license COPYING* %dir %{_sysconfdir}/xdg/akonadi/ %ghost %config(missingok,noreplace) %{_sysconfdir}/xdg/akonadi/akonadiserverrc +%config(noreplace) %{_sysconfdir}/xdg/akonadi/akonadiserverrc.sqlite %{_sysconfdir}/xdg/akonadi.categories %{_kf5_bindir}/akonadi_agent_launcher %{_kf5_bindir}/akonadi_agent_server @@ -268,7 +281,9 @@ fi %changelog * Sun Jul 17 2016 Rex Dieter - 16.04.3-3 -- rebuild (qt5-qtbase) +- backport FTBFS fix +- make build use mysql backend as default (so tests use that) +- add alternatives support for sqlite backend to main pkg * Wed Jul 13 2016 Rex Dieter - 16.04.3-2 - BR: qt5-qtbase-private-devel (sqlite3 driver plugin)