CL-Softwares
/
Nut
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: build errors

This commit is contained in:
Hamed Masafi 2020-07-29 18:41:19 +04:30
parent 076a15e127
commit ac77f8aa4f
33 changed files with 249 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.github/workflows/qt.yml vendored
View File

@ -20,8 +20,7 @@ jobs:
- mingw81_64 - mingw81_64
- mingw81_32 - mingw81_32
- clang_64 - clang_64
- ios
include: include:
- platform: gcc_64 - platform: gcc_64
os: ubuntu-latest os: ubuntu-latest
@ -43,8 +42,6 @@ jobs:
os: windows-latest os: windows-latest
- platform: clang_64 - platform: clang_64
os: macos-latest os: macos-latest
- platform: ios
os: macos-latest
runs-on: ${{matrix.os}} runs-on: ${{matrix.os}}
steps: steps:

2
.qmake.conf
View File

@ -1,7 +1,7 @@
load(qt_build_config) load(qt_build_config)
CONFIG += warning_clean exceptions qt_module_build c++17 CONFIG += warning_clean exceptions qt_module_build c++17
DEFINES += QT_DEPRECATED_WARNINGS QT_ASCII_CAST_WARNINGS # DEFINES += QT_DEPRECATED_WARNINGS QT_ASCII_CAST_WARNINGS
MODULE_VERSION = 0.6.0 MODULE_VERSION = 0.6.0

1
nut.pro
View File

@ -1,5 +1,4 @@
load(qt_parts) load(qt_parts)
#system($$[QT_INSTALL_BINS]/syncqt.pl -version 0.6.0 -outdir $$OUT_PWD)
runtests.target = run-tests runtests.target = run-tests
runtests.CONFIG = recursive runtests.CONFIG = recursive

2
src/nut/bulkinserter.cpp
View File

@ -4,7 +4,7 @@
#include "generators/sqlgeneratorbase_p.h" #include "generators/sqlgeneratorbase_p.h"
#include "databasemodel.h" #include "databasemodel.h"
#include <QDebug> #include <QtCore/QDebug>
Nut::BulkInserter::BulkInserter(Nut::Database *db, QString &className) Nut::BulkInserter::BulkInserter(Nut::Database *db, QString &className)
: _database(db), _fieldCount(0) : _database(db), _fieldCount(0)

2
src/nut/bulkinserter.h
View File

@ -2,7 +2,7 @@
#define BULKINSERTER_H #define BULKINSERTER_H
#include <initializer_list> #include <initializer_list>
#include <QDebug> #include <QtCore/QDebug>
#include "defines.h" #include "defines.h"
#include "phrases/phraselist.h" #include "phrases/phraselist.h"
#include "phrases/fieldphrase.h" #include "phrases/fieldphrase.h"

44
src/nut/database.cpp
View File

@ -193,8 +193,8 @@ bool DatabasePrivate::getCurrectSchema()
Q_Q(Database); Q_Q(Database);
//is not first instanicate of this class //is not first instanicate of this class
if (allTableMaps.contains(q->metaObject()->className())) { if (allTableMaps.contains(QString::fromUtf8(q->metaObject()->className()))) {
currentModel = allTableMaps[q->metaObject()->className()]; currentModel = allTableMaps[QString::fromUtf8(q->metaObject()->className())];
return false; return false;
} }
@ -205,9 +205,9 @@ bool DatabasePrivate::getCurrectSchema()
int changeLogTypeId = qRegisterMetaType<ChangeLogTable*>(); int changeLogTypeId = qRegisterMetaType<ChangeLogTable*>();
currentModel.append( currentModel.append(
new TableModel(changeLogTypeId, __CHANGE_LOG_TABLE_NAME)); new TableModel(changeLogTypeId, QStringLiteral(__CHANGE_LOG_TABLE_NAME)));
tables.insert(ChangeLogTable::staticMetaObject.className(), tables.insert(QStringLiteral(ChangeLogTable::staticMetaObject.className()),
__CHANGE_LOG_TABLE_NAME); QStringLiteral(__CHANGE_LOG_TABLE_NAME));
changeLogs = new TableSet<ChangeLogTable>(q); changeLogs = new TableSet<ChangeLogTable>(q);
@ -219,11 +219,11 @@ bool DatabasePrivate::getCurrectSchema()
if (!nutClassInfoString(q->metaObject()->classInfo(i), if (!nutClassInfoString(q->metaObject()->classInfo(i),
type, name, value)) { type, name, value)) {
errorMessage = QString("No valid table in %1") errorMessage = QString::fromUtf8("No valid table in %1")
.arg(q->metaObject()->classInfo(i).value()); .arg(q->metaObject()->classInfo(i).value());
continue; continue;
} }
if (type == __nut_TABLE) { if (type == QStringLiteral(__nut_TABLE)) {
//name: table class name //name: table class name
//value: table variable name (table name in db) //value: table variable name (table name in db)
tables.insert(name, value); tables.insert(name, value);
@ -237,7 +237,7 @@ bool DatabasePrivate::getCurrectSchema()
currentModel.append(sch); currentModel.append(sch);
} }
if (type == __nut_DB_VERSION) { if (type == QStringLiteral(__nut_DB_VERSION)) {
bool ok; bool ok;
int version = value.toInt(&ok); int version = value.toInt(&ok);
if (!ok) if (!ok)
@ -250,9 +250,9 @@ bool DatabasePrivate::getCurrectSchema()
QMetaProperty tableProperty = q->metaObject()->property(i); QMetaProperty tableProperty = q->metaObject()->property(i);
int typeId = QMetaType::type(tableProperty.typeName()); int typeId = QMetaType::type(tableProperty.typeName());
if (tables.values().contains(tableProperty.name()) if (tables.values().contains(QString::fromUtf8(tableProperty.name()))
&& (unsigned)typeId >= QVariant::UserType) { && (unsigned)typeId >= QVariant::UserType) {
TableModel *sch = new TableModel(typeId, tableProperty.name()); TableModel *sch = new TableModel(typeId, QString::fromUtf8(tableProperty.name()));
currentModel.append(sch); currentModel.append(sch);
} }
} }
@ -272,7 +272,7 @@ bool DatabasePrivate::getCurrectSchema()
fk->masterTable = currentModel.tableByClassName(fk->masterClassName); fk->masterTable = currentModel.tableByClassName(fk->masterClassName);
} }
allTableMaps.insert(q->metaObject()->className(), currentModel); allTableMaps.insert(QString::fromUtf8(q->metaObject()->className()), currentModel);
return true; return true;
} }
@ -286,8 +286,12 @@ DatabaseModel DatabasePrivate::getLastSchema()
if (u) { if (u) {
QJsonParseError e; QJsonParseError e;
QJsonObject json QJsonObject json = QJsonDocument::fromJson(u->data()
= QJsonDocument::fromJson(u->data().replace("\\\"", "\"").toUtf8(), &e).object(); .replace(QStringLiteral("\\\""),
QStringLiteral("\""))
.toUtf8(),
&e)
.object();
DatabaseModel ret = json; DatabaseModel ret = json;
return ret; return ret;
@ -322,7 +326,7 @@ bool DatabasePrivate::putModelToDatabase()
/*current.remove(__CHANGE_LOG_TABLE_NAME)*/; /*current.remove(__CHANGE_LOG_TABLE_NAME)*/;
auto changeLog = create<ChangeLogTable>(); auto changeLog = create<ChangeLogTable>();
changeLog->setData(QJsonDocument(current.toJson()).toJson(QJsonDocument::Compact)); changeLog->setData(QString(QJsonDocument(current.toJson()).toJson(QJsonDocument::Compact)));
changeLog->setVersion(current.version()); changeLog->setVersion(current.version());
changeLogs->append(changeLog); changeLogs->append(changeLog);
q->saveChanges(true); q->saveChanges(true);
@ -344,7 +348,7 @@ bool DatabasePrivate::putModelToDatabase()
void DatabasePrivate::createChangeLogs() void DatabasePrivate::createChangeLogs()
{ {
// currentModel.model("change_log") // currentModel.model("change_log")
QStringList diff = sqlGenerator->diff(nullptr, currentModel.tableByName("__change_log")); QStringList diff = sqlGenerator->diff(nullptr, currentModel.tableByName(QStringLiteral("__change_log")));
foreach (QString s, diff) foreach (QString s, diff)
db.exec(s); db.exec(s);
@ -545,17 +549,17 @@ bool Database::open(bool updateDatabase)
{ {
Q_D(Database); Q_D(Database);
if (d->driver == "QPSQL" || d->driver == "QPSQL7") if (d->driver == QStringLiteral("QPSQL") || d->driver == QStringLiteral("QPSQL7"))
d->sqlGenerator = new PostgreSqlGenerator(this); d->sqlGenerator = new PostgreSqlGenerator(this);
else if (d->driver == "QMYSQL" || d->driver == "QMYSQL3") else if (d->driver == QStringLiteral("QMYSQL") || d->driver == QStringLiteral("QMYSQL3"))
d->sqlGenerator = new MySqlGenerator(this); d->sqlGenerator = new MySqlGenerator(this);
else if (d->driver == "QSQLITE" || d->driver == "QSQLITE3") else if (d->driver == QStringLiteral("QSQLITE") || d->driver == QStringLiteral("QSQLITE3"))
d->sqlGenerator = new SqliteGenerator(this); d->sqlGenerator = new SqliteGenerator(this);
else if (d->driver == "QODBC" || d->driver == "QODBC3") { else if (d->driver == QStringLiteral("QODBC") || d->driver == QStringLiteral("QODBC3")) {
QString driverName = QString(); QString driverName = QString();
QStringList parts = d->databaseName.toLower().split(';'); QStringList parts = d->databaseName.toLower().split(';');
foreach (QString p, parts) foreach (QString p, parts)
if (p.trimmed().startsWith("driver=")) if (p.trimmed().startsWith(QStringLiteral("driver=")))
driverName = p.split('=').at(1).toLower().trimmed(); driverName = p.split('=').at(1).toLower().trimmed();
// if (driverName == "{sql server}") // if (driverName == "{sql server}")

2
src/nut/database.h
View File

@ -23,8 +23,8 @@
#include <QtCore/qglobal.h> #include <QtCore/qglobal.h>
#include <QtCore/QList> #include <QtCore/QList>
#include <QtCore/QSharedDataPointer>
#include <QtSql/QSqlDatabase> #include <QtSql/QSqlDatabase>
#include <QSharedDataPointer>
#include "defines.h" #include "defines.h"
#include "tableset.h" #include "tableset.h"

4
src/nut/database_p.h
View File

@ -24,8 +24,8 @@
#include "database.h" #include "database.h"
#include "databasemodel.h" #include "databasemodel.h"
#include <QDebug> #include <QtCore/QDebug>
#include <QSharedData> #include <QtCore/QSharedData>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

4
src/nut/databasemodel.cpp
View File

@ -21,8 +21,8 @@
#include "databasemodel.h" #include "databasemodel.h"
#include "tablemodel.h" #include "tablemodel.h"
#include <QJsonArray> #include <QtCore/QJsonArray>
#include <QJsonObject> #include <QtCore/QJsonObject>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

94
src/nut/defines.h
View File

@ -24,12 +24,12 @@
#define NUT_NAMESPACE Nut #define NUT_NAMESPACE Nut
#include "defines_p.h" #include "defines_p.h"
#include "qglobal.h" #include <QtCore/QtGlobal>
#include <QString> #include <QtCore/QString>
#include <QStringList> #include <QtCore/QStringList>
#include <QVariant> #include <QtCore/QVariant>
#include <QMetaClassInfo> #include <QtCore/QMetaClassInfo>
#if defined(NUT_SHARED) || !defined(NUT_STATIC) #if defined(NUT_SHARED) || !defined(NUT_STATIC)
# ifdef NUT_STATIC # ifdef NUT_STATIC
@ -89,33 +89,33 @@ public: \
} \ } \
void write(type name){ \ void write(type name){ \
m_##name = name; \ m_##name = name; \
propertyChanged(#name); \ propertyChanged(QString::fromUtf8(#name)); \
} }
#define NUT_FOREIGN_KEY(type, keytype, name, read, write) \ #define NUT_FOREIGN_KEY(type, keytype, name, read, write) \
Q_PROPERTY(Nut::Row<type> name READ read WRITE write) \ Q_PROPERTY(Nut::Row<type> name READ read WRITE write) \
NUT_DECLARE_FIELD(keytype, name##Id, read##Id, write##Id) \ NUT_DECLARE_FIELD(keytype, name##Id, read##Id, write##Id) \
NUT_INFO(__nut_FOREIGN_KEY, name, type) \ NUT_INFO(__nut_FOREIGN_KEY, name, type) \
Nut::Row<type> m_##name; \ Nut::Row<type> m_##name; \
public slots: \ public slots: \
Nut::Row<type> read() const { return m_##name ; } \ Nut::Row<type> read() const { return m_##name ; } \
Q_INVOKABLE void write(Nut::Row<type> name){ \ Q_INVOKABLE void write(Nut::Row<type> name){ \
m_##name = name; \ m_##name = name; \
} }
#define NUT_FOREIGN_KEY_DECLARE(type, keytype, name, read, write) \ #define NUT_FOREIGN_KEY_DECLARE(type, keytype, name, read, write) \
NUT_INFO(__nut_FIELD, name##Id, 0) \ NUT_INFO(__nut_FIELD, name##Id, 0) \
NUT_INFO(__nut_FOREIGN_KEY, name, type) \ NUT_INFO(__nut_FOREIGN_KEY, name, type) \
Nut::Row<type> m_##name; \ Nut::Row<type> m_##name; \
keytype m_##name##Id; \ keytype m_##name##Id; \
Q_PROPERTY(Nut::Row<type> name READ read WRITE write) \ Q_PROPERTY(Nut::Row<type> name READ read WRITE write) \
Q_PROPERTY(keytype name##Id READ read##Id WRITE write##Id) \ Q_PROPERTY(keytype name##Id READ read##Id WRITE write##Id) \
public: \ public: \
Nut::Row<type> read() const; \ Nut::Row<type> read() const; \
keytype read##Id() const; \ keytype read##Id() const; \
static NUT_WRAP_NAMESPACE(FieldPhrase<keytype>)& name##Id ## Field(){ \ static NUT_WRAP_NAMESPACE(FieldPhrase<keytype>)& name##Id ## Field(){ \
static NUT_WRAP_NAMESPACE(FieldPhrase<keytype>) f = \ static NUT_WRAP_NAMESPACE(FieldPhrase<keytype>) f = \
NUT_WRAP_NAMESPACE(FieldPhrase<keytype>) \ NUT_WRAP_NAMESPACE(FieldPhrase<keytype>) \
(staticMetaObject.className(), #name); \ (staticMetaObject.className(), #name); \
return f; \ return f; \
} \ } \
@ -123,25 +123,23 @@ public slots: \
void write(Nut::Row<type> name); \ void write(Nut::Row<type> name); \
void write##Id(keytype name##Id); void write##Id(keytype name##Id);
#define NUT_FOREIGN_KEY_IMPLEMENT(class, type, keytype, name, read, write) \ #define NUT_FOREIGN_KEY_IMPLEMENT(class, type, keytype, name, read, write) \
\ Nut::Row<type> class::read() const { return m_##name ; } \
Nut::Row<type> class::read() const { return m_##name ; } \ void class::write(Nut::Row<type> name){ \
void class::write(Nut::Row<type> name){ \ propertyChanged(QT_STRINGIFY2(name##Id)); \
propertyChanged(QT_STRINGIFY2(name##Id)); \
m_##name = name; \ m_##name = name; \
m_##name##Id = name->primaryValue().value<keytype>(); \ m_##name##Id = name->primaryValue().value<keytype>(); \
} \
\
keytype class::read##Id() const{ \
if (m_##name) \
return m_##name->primaryValue().value<keytype>(); \
return m_##name##Id; \
} \ } \
void class::write##Id(keytype name##Id){ \ keytype class::read##Id() const{ \
propertyChanged(QT_STRINGIFY2(name##Id)); \ if (m_##name) \
m_##name##Id = name##Id; \ return m_##name->primaryValue().value<keytype>(); \
m_##name = nullptr; \ return m_##name##Id; \
propertyChanged(QT_STRINGIFY2(name##Id)); \ } \
void class::write##Id(keytype name##Id){ \
propertyChanged(QT_STRINGIFY2(name##Id)); \
m_##name##Id = name##Id; \
m_##name = nullptr; \
propertyChanged(QT_STRINGIFY2(name##Id)); \
} }
@ -154,7 +152,7 @@ public slots: \
#define NUT_IMPLEMENT_CHILD_TABLE(class, type, n) \ #define NUT_IMPLEMENT_CHILD_TABLE(class, type, n) \
type *class::n##Table(){ \ type *class::n##Table(){ \
static auto f = new type(); \ static auto f = new type(); \
return f; \ return f; \
} \ } \
NUT_WRAP_NAMESPACE(TableSet)<type> *class::n(){ \ NUT_WRAP_NAMESPACE(TableSet)<type> *class::n(){ \
@ -162,14 +160,14 @@ public slots: \
} }
#define NUT_FIELD(name) NUT_INFO(__nut_FIELD, name, 0) #define NUT_FIELD(name) NUT_INFO(__nut_FIELD, name, 0)
#define NUT_PRIMARY_KEY(x) NUT_INFO(__nut_PRIMARY_KEY, x, 0) \ #define NUT_PRIMARY_KEY(x) NUT_INFO(__nut_PRIMARY_KEY, x, 0) \
public: \ public: \
QVariant primaryValue() const override { \ QVariant primaryValue() const override { \
return property(#x); \ return property(#x); \
} \ } \
void setPrimaryValue(const QVariant &value) override { \ void setPrimaryValue(const QVariant &value) override { \
setProperty(#x, value); \ setProperty(#x, value); \
} \ } \
private: private:

64
src/nut/generators/mysqlgenerator.cpp
View File

@ -21,14 +21,14 @@
#include "mysqlgenerator.h" #include "mysqlgenerator.h"
#include "../tablemodel.h" #include "../tablemodel.h"
#include <QPoint> #include <QtCore/QPoint>
#include <QPointF> #include <QtCore/QPointF>
#include <QTime> #include <QtCore/QTime>
#include <QDate> #include <QtCore/QDate>
#include <QDateTime> #include <QtCore/QDateTime>
#ifdef QT_GUI_LIB #ifdef QT_GUI_LIB
#include <QPolygon> # include <QtGui/QPolygon>
#include <QPolygonF> # include <QtGui/QPolygonF>
#endif #endif
#include "sqlserializer.h" #include "sqlserializer.h"
@ -45,42 +45,42 @@ QString MySqlGenerator::fieldType(FieldModel *field)
QString dbType; QString dbType;
switch (field->type) { switch (field->type) {
case QMetaType::Bool: return "BOOLEAN"; case QMetaType::Bool: return QStringLiteral("BOOLEAN");
case QMetaType::Char: case QMetaType::Char:
case QMetaType::QChar: return "CHAR(1)"; case QMetaType::QChar: return QStringLiteral("CHAR(1)");
case QMetaType::SChar: case QMetaType::SChar:
case QMetaType::UChar: return "TINYINT"; case QMetaType::UChar: return QStringLiteral("TINYINT");
case QMetaType::Short: case QMetaType::Short:
case QMetaType::UShort: return "SMALLINT"; case QMetaType::UShort: return QStringLiteral("SMALLINT");
case QMetaType::UInt: case QMetaType::UInt:
case QMetaType::Int: case QMetaType::Int:
dbType = "INT"; dbType = QStringLiteral("INT");
if(field->isAutoIncrement) if(field->isAutoIncrement)
dbType += " AUTO_INCREMENT"; dbType += QStringLiteral(" AUTO_INCREMENT");
break; break;
case QMetaType::Long: case QMetaType::Long:
case QMetaType::ULong: case QMetaType::ULong:
case QMetaType::LongLong: case QMetaType::LongLong:
case QMetaType::ULongLong: case QMetaType::ULongLong:
return "BIGINT"; return QStringLiteral("BIGINT");
case QMetaType::Float: case QMetaType::Float:
return "FLOAT"; return QStringLiteral("FLOAT");
case QMetaType::Double: case QMetaType::Double:
return "REAL"; return QStringLiteral("REAL");
case QMetaType::QBitArray: return "VARBINARY"; case QMetaType::QBitArray: return QStringLiteral("VARBINARY");
case QMetaType::QByteArray: return "BLOB"; case QMetaType::QByteArray: return QStringLiteral("BLOB");
case QMetaType::QDate: return "DATE"; case QMetaType::QDate: return QStringLiteral("DATE");
case QMetaType::QTime: return "TIME"; case QMetaType::QTime: return QStringLiteral("TIME");
case QMetaType::QDateTime: return "DATETIME"; case QMetaType::QDateTime: return QStringLiteral("DATETIME");
case QMetaType::QString: case QMetaType::QString:
if(field->length) if(field->length)
dbType = QString("VARCHAR(%1)").arg(field->length); dbType = QString::fromUtf8("VARCHAR(%1)").arg(field->length);
else else
dbType = "TEXT"; dbType = QStringLiteral("TEXT");
break; break;
@ -109,7 +109,7 @@ QString MySqlGenerator::fieldType(FieldModel *field)
case QMetaType::QJsonValue: case QMetaType::QJsonValue:
case QMetaType::QJsonObject: case QMetaType::QJsonObject:
case QMetaType::QJsonDocument: case QMetaType::QJsonDocument:
case QMetaType::QStringList: return "TEXT"; case QMetaType::QStringList: return QStringLiteral("TEXT");
default: default:
qWarning("Type %s::%s(%d) is not supported", qWarning("Type %s::%s(%d) is not supported",
@ -128,16 +128,16 @@ QString MySqlGenerator::fieldType(FieldModel *field)
QString MySqlGenerator::escapeValue(const QVariant &v) const QString MySqlGenerator::escapeValue(const QVariant &v) const
{ {
if (v.type() == QVariant::Bool) if (v.type() == QVariant::Bool)
return v.toBool() ? "1" : "0"; return v.toBool() ? QStringLiteral("1") : QStringLiteral("0");
if (v.type() == QVariant::Time) if (v.type() == QVariant::Time)
return "'" + v.toTime().toString("HH:mm:ss") + "'"; return v.toTime().toString(QStringLiteral("'HH:mm:ss'"));
if (v.type() == QVariant::Date) if (v.type() == QVariant::Date)
return "'" + v.toDate().toString("yyyy-MM-dd") + "'"; return v.toDate().toString(QStringLiteral("'yyyy-MM-dd'"));
if (v.type() == QVariant::DateTime) if (v.type() == QVariant::DateTime)
return "'" + v.toDateTime().toString("yyyy-MM-dd HH:mm:ss") + "'"; return v.toDateTime().toString(QStringLiteral("'yyyy-MM-dd HH:mm:ss'"));
//#ifdef QT_GUI_LIB //#ifdef QT_GUI_LIB
// if (v.type() == QVariant::Polygon) { // if (v.type() == QVariant::Polygon) {
@ -316,7 +316,7 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::AddMinutesDateTime: case PhraseData::AddMinutesDateTime:
case PhraseData::AddSeconds: case PhraseData::AddSeconds:
case PhraseData::AddSecondsDateTime: case PhraseData::AddSecondsDateTime:
return QString("DATE_ADD(%1, INTERVAL %2 %3)") return QString::fromUtf8("DATE_ADD(%1, INTERVAL %2 %3)")
.arg(createConditionalPhrase(d->left), .arg(createConditionalPhrase(d->left),
d->operand.toString(), d->operand.toString(),
SqlGeneratorBase::dateTimePartName(op)); SqlGeneratorBase::dateTimePartName(op));
@ -333,7 +333,7 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::DatePartHour: case PhraseData::DatePartHour:
case PhraseData::DatePartMinute: case PhraseData::DatePartMinute:
case PhraseData::DatePartSecond: case PhraseData::DatePartSecond:
return QString("%2(%1)") return QString::fromUtf8("%2(%1)")
.arg(createConditionalPhrase(d->left), .arg(createConditionalPhrase(d->left),
SqlGeneratorBase::dateTimePartName(op)); SqlGeneratorBase::dateTimePartName(op));
@ -348,11 +348,11 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
void MySqlGenerator::appendSkipTake(QString &sql, int skip, int take) void MySqlGenerator::appendSkipTake(QString &sql, int skip, int take)
{ {
if (take > 0 && skip > 0) { if (take > 0 && skip > 0) {
sql.append(QString(" LIMIT %1 OFFSET %2") sql.append(QString::fromUtf8(" LIMIT %1 OFFSET %2")
.arg(take) .arg(take)
.arg(skip)); .arg(skip));
} else if (take > 0) { } else if (take > 0) {
sql.append(QString(" LIMIT %1").arg(take)); sql.append(QString::fromUtf8(" LIMIT %1").arg(take));
} }
} }

115
src/nut/generators/postgresqlgenerator.cpp
View File

@ -18,14 +18,15 @@
** **
**************************************************************************/ **************************************************************************/
#include <QDateTime> #include <QtCore/QDateTime>
#include <QPoint> #include <QtCore/QPoint>
#ifdef QT_GUI_LIB #ifdef QT_GUI_LIB
#include <QPolygon> # include <QtGui/QPolygon>
#include <QPolygonF> # include <QtGui/QPolygonF>
#endif #endif
#include <QVariant> #include <QtCore/QVariant>
#include <QJsonDocument> #include <QtCore/QJsonDocument>
#include "postgresqlgenerator.h" #include "postgresqlgenerator.h"
#include "../table.h" #include "../table.h"
@ -83,44 +84,44 @@ QString PostgreSqlGenerator::fieldType(FieldModel *field)
switch (field->type) { switch (field->type) {
case QMetaType::Bool: case QMetaType::Bool:
dbType = "BOOLEAN"; dbType = QStringLiteral("BOOLEAN");
break; break;
case QMetaType::QBitArray: case QMetaType::QBitArray:
case QMetaType::QByteArray: case QMetaType::QByteArray:
dbType = "BYTEA"; dbType = QStringLiteral("BYTEA");
break; break;
case QMetaType::QDate: case QMetaType::QDate:
dbType = "DATE"; dbType = QStringLiteral("DATE");
break; break;
case QMetaType::QDateTime: case QMetaType::QDateTime:
dbType = "TIMESTAMP"; dbType = QStringLiteral("TIMESTAMP");
break; break;
case QMetaType::QTime: case QMetaType::QTime:
dbType = "TIME"; dbType = QStringLiteral("TIME");
break; break;
case QMetaType::SChar: case QMetaType::SChar:
case QMetaType::UChar: case QMetaType::UChar:
case QMetaType::Short: case QMetaType::Short:
case QMetaType::UShort: case QMetaType::UShort:
dbType = "SMALLINT"; dbType = QStringLiteral("SMALLINT");
break; break;
case QMetaType::Float: case QMetaType::Float:
dbType = "FLOAT"; dbType = QStringLiteral("FLOAT");
break; break;
case QMetaType::Double: case QMetaType::Double:
dbType = "REAL"; dbType = QStringLiteral("REAL");
break; break;
case QMetaType::Int: case QMetaType::Int:
case QMetaType::UInt: case QMetaType::UInt:
if(field->isAutoIncrement) if(field->isAutoIncrement)
dbType = "SERIAL"; dbType = QStringLiteral("SERIAL");
else else
dbType = "INTEGER"; dbType = QStringLiteral("INTEGER");
break; break;
case QMetaType::Long: case QMetaType::Long:
@ -128,58 +129,58 @@ QString PostgreSqlGenerator::fieldType(FieldModel *field)
case QMetaType::LongLong: case QMetaType::LongLong:
case QMetaType::ULongLong: case QMetaType::ULongLong:
if(field->isAutoIncrement) if(field->isAutoIncrement)
dbType = "BIGSERIAL"; dbType = QStringLiteral("BIGSERIAL");
else else
dbType = "BIGINT"; dbType = QStringLiteral("BIGINT");
break; break;
case QMetaType::Char: case QMetaType::Char:
case QMetaType::QChar: case QMetaType::QChar:
return "CHAR(1)"; return QStringLiteral("CHAR(1)");
case QMetaType::QString: case QMetaType::QString:
if(field->length) if(field->length)
dbType = QString("VARCHAR(%1)").arg(field->length); dbType = QString("VARCHAR(%1)").arg(field->length);
else else
dbType = "TEXT"; dbType = QStringLiteral("TEXT");
break; break;
case QMetaType::QPoint: case QMetaType::QPoint:
case QMetaType::QPointF: case QMetaType::QPointF:
dbType="POINT"; dbType = QStringLiteral("POINT");
break; break;
case QMetaType::QUuid: case QMetaType::QUuid:
dbType = "UUID"; dbType = QStringLiteral("UUID");
break; break;
case QMetaType::QPolygon: case QMetaType::QPolygon:
case QMetaType::QPolygonF: case QMetaType::QPolygonF:
dbType = "POLYGON"; dbType = QStringLiteral("POLYGON");
break; break;
case QMetaType::QLine: case QMetaType::QLine:
case QMetaType::QLineF: case QMetaType::QLineF:
return "LINE"; return QStringLiteral("LINE");
case QMetaType::QRect: case QMetaType::QRect:
case QMetaType::QRectF: case QMetaType::QRectF:
return "BOX"; return QStringLiteral("BOX");
case QMetaType::QJsonArray: case QMetaType::QJsonArray:
case QMetaType::QJsonValue: case QMetaType::QJsonValue:
case QMetaType::QJsonObject: case QMetaType::QJsonObject:
case QMetaType::QJsonDocument: case QMetaType::QJsonDocument:
return "JSONB"; return QStringLiteral("JSONB");
case QMetaType::QStringList: case QMetaType::QStringList:
return "TEXT[]"; return QStringLiteral("TEXT[]");
case QMetaType::QSize: case QMetaType::QSize:
case QMetaType::QSizeF: case QMetaType::QSizeF:
case QMetaType::QUrl: case QMetaType::QUrl:
case QMetaType::QColor: case QMetaType::QColor:
return "TEXT"; return QStringLiteral("TEXT");
default: default:
dbType = QString(); dbType = QString();
@ -196,13 +197,13 @@ QString PostgreSqlGenerator::diff(FieldModel *oldField, FieldModel *newField)
return QString(); return QString();
if(!newField){ if(!newField){
sql = "DROP COLUMN " + oldField->name; sql = QStringLiteral("DROP COLUMN ") + oldField->name;
}else{ }else{
if(oldField){ if(oldField){
sql = "ALTER COLUMN "; sql = QStringLiteral("ALTER COLUMN ");
sql.append(newField->name + " TYPE " + fieldType(newField)); sql.append(newField->name + QStringLiteral(" TYPE ") + fieldType(newField));
} else { } else {
sql = "ADD COLUMN "; sql = QStringLiteral("ADD COLUMN ");
sql.append(fieldDeclare(newField)); sql.append(fieldDeclare(newField));
} }
} }
@ -212,27 +213,31 @@ QString PostgreSqlGenerator::diff(FieldModel *oldField, FieldModel *newField)
QString PostgreSqlGenerator::escapeValue(const QVariant &v) const QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
{ {
if (v.type() == QVariant::Time) if (v.type() == QVariant::Time)
return "'" + v.toTime().toString("HH:mm:ss") + "'"; return v.toTime().toString(QStringLiteral("'HH:mm:ss'"));
if (v.type() == QVariant::Date) if (v.type() == QVariant::Date)
return "'" + v.toDate().toString("yyyy-MM-dd") + "'"; return v.toDate().toString(QStringLiteral("'yyyy-MM-dd'"));
if (v.type() == QVariant::DateTime) if (v.type() == QVariant::DateTime)
return "'" + v.toDateTime().toString("yyyy-MM-dd HH:mm:ss") + "'"; return v.toDateTime().toString(QStringLiteral("'yyyy-MM-dd HH:mm:ss'"));
if (v.type() == QVariant::StringList) if (v.type() == QVariant::StringList)
return "'{" + v.toStringList().join(",") + "}'"; return QStringLiteral("'{")
+ v.toStringList().join(QStringLiteral(","))
+ QStringLiteral("}'");
if (v.type() == QVariant::Point) { if (v.type() == QVariant::Point) {
QPoint pt = v.toPoint(); QPoint pt = v.toPoint();
return QString("point(%1, %2)").arg(pt.x()).arg(pt.y()); return QString::fromUtf8("point(%1, %2)").arg(pt.x()).arg(pt.y());
} }
if (v.type() == QVariant::PointF) { if (v.type() == QVariant::PointF) {
QPointF pt = v.toPointF(); QPointF pt = v.toPointF();
return QString("point(%1, %2)").arg(pt.x()).arg(pt.y()); return QString::fromUtf8("point(%1, %2)").arg(pt.x()).arg(pt.y());
} }
if (v.userType() == QMetaType::QJsonDocument) { if (v.userType() == QMetaType::QJsonDocument) {
return "'" + QString(v.toJsonDocument().toJson(QJsonDocument::Compact)) + "'"; return QStringLiteral("'")
+ QString::fromUtf8(v.toJsonDocument().toJson(QJsonDocument::Compact))
+ QStringLiteral("'");
} }
#ifdef QT_GUI_LIB #ifdef QT_GUI_LIB
@ -243,7 +248,7 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
for (int i = 0; i < pol.size(); ++i) { for (int i = 0; i < pol.size(); ++i) {
pt = pol.at(i); pt = pol.at(i);
if (!ret.isEmpty()) if (!ret.isEmpty())
ret.append("),("); ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y())); ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y()));
} }
return "'((" + ret + "))'"; return "'((" + ret + "))'";
@ -255,7 +260,7 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
for (int i = 0; i < pol.size(); ++i) { for (int i = 0; i < pol.size(); ++i) {
pt = pol.at(i); pt = pol.at(i);
if (!ret.isEmpty()) if (!ret.isEmpty())
ret.append("),("); ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y())); ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y()));
} }
return "'((" + ret + "))'"; return "'((" + ret + "))'";
@ -277,14 +282,24 @@ QVariant PostgreSqlGenerator::unescapeValue(const QMetaType::Type &type, const Q
return dbValue.toDate(); return dbValue.toDate();
if (type == QMetaType::QPoint) if (type == QMetaType::QPoint)
return SqlGeneratorBase::unescapeValue(QMetaType::QPoint, dbValue.toString() return SqlGeneratorBase::unescapeValue(QMetaType::QPoint,
.replace("(", "").replace(")", "")); dbValue.toString()
.replace(QStringLiteral("("),
QStringLiteral(""))
.replace(QStringLiteral(")"),
QStringLiteral("")));
if (type == QMetaType::QPointF) if (type == QMetaType::QPointF)
return SqlGeneratorBase::unescapeValue(QMetaType::QPointF, dbValue.toString() return SqlGeneratorBase::unescapeValue(QMetaType::QPointF,
.replace("(", "").replace(")", "")); dbValue.toString()
.replace(QStringLiteral("("),
QStringLiteral(""))
.replace(QStringLiteral(")"),
QStringLiteral("")));
if (type == QMetaType::QStringList) if (type == QMetaType::QStringList)
return dbValue.toString().replace("{", "").replace("}", "") return dbValue.toString()
.split(","); .replace(QStringLiteral("{"), QStringLiteral(""))
.replace(QStringLiteral("}"), QStringLiteral(""))
.split(QStringLiteral(","));
#ifdef QT_GUI_LIB #ifdef QT_GUI_LIB
if (type == QMetaType::QPolygon) { if (type == QMetaType::QPolygon) {
@ -337,7 +352,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
if (d->type == PhraseData::WithVariant) { if (d->type == PhraseData::WithVariant) {
if (isPostGisType(d->operand.type()) && d->operatorCond == PhraseData::Equal) { if (isPostGisType(d->operand.type()) && d->operatorCond == PhraseData::Equal) {
return QString("%1 ~= %2") return QString::fromUtf8("%1 ~= %2")
.arg(SqlGeneratorBase::createConditionalPhrase(d->left), .arg(SqlGeneratorBase::createConditionalPhrase(d->left),
escapeValue(d->operand)); escapeValue(d->operand));
} }
@ -354,7 +369,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::AddMinutesDateTime: case PhraseData::AddMinutesDateTime:
case PhraseData::AddSeconds: case PhraseData::AddSeconds:
case PhraseData::AddSecondsDateTime: case PhraseData::AddSecondsDateTime:
return QString("%1 + interval '%2 %3'") return QString::fromUtf8("%1 + interval '%2 %3'")
.arg(createConditionalPhrase(d->left), .arg(createConditionalPhrase(d->left),
d->operand.toString(), d->operand.toString(),
SqlGeneratorBase::dateTimePartName(op)); SqlGeneratorBase::dateTimePartName(op));
@ -372,7 +387,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::DatePartHour: case PhraseData::DatePartHour:
case PhraseData::DatePartMinute: case PhraseData::DatePartMinute:
case PhraseData::DatePartSecond: case PhraseData::DatePartSecond:
return QString("date_part('%2', %1)") return QString::fromUtf8("date_part('%2', %1)")
.arg(createConditionalPhrase(d->left), .arg(createConditionalPhrase(d->left),
SqlGeneratorBase::dateTimePartName(op)); SqlGeneratorBase::dateTimePartName(op));

40
src/nut/generators/sqlgeneratorbase.cpp
View File

@ -18,13 +18,12 @@
** **
**************************************************************************/ **************************************************************************/
#include <QDate> #include <QtCore/QDateTime>
#include <QDebug> #include <QtCore/QPointF>
#include <QDateTime> #include <QtCore/QTime>
#include <QPointF> #include <QtCore/QUuid>
#include <QTime> #include <QtCore/QVariant>
#include <QUuid> #include <QtCore/QDebug>
#include <QVariant>
#include "sqlgeneratorbase_p.h" #include "sqlgeneratorbase_p.h"
#include "../database.h" #include "../database.h"
@ -201,12 +200,12 @@ QString SqlGeneratorBase::diff(FieldModel *oldField, FieldModel *newField)
return sql; return sql;
if (!newField) { if (!newField) {
sql = "DROP COLUMN " + oldField->name; sql = QStringLiteral("DROP COLUMN ") + oldField->name;
} else { } else {
if (oldField) if (oldField)
sql = "MODIFY COLUMN "; sql = QStringLiteral("MODIFY COLUMN ");
else else
sql = "ADD COLUMN "; sql = QStringLiteral("ADD COLUMN ");
sql.append(fieldDeclare(newField)); sql.append(fieldDeclare(newField));
} }
return sql; return sql;
@ -273,8 +272,8 @@ QStringList SqlGeneratorBase::diff(TableModel *oldTable, TableModel *newTable)
// } // }
QString sql; QString sql;
if (oldTable) { if (oldTable) {
sql = QString("ALTER TABLE %1 \n%2") sql = QString::fromUtf8("ALTER TABLE %1 \n%2")
.arg(newTable->name(), columnSql.join(",\n")); .arg(newTable->name(), columnSql.join(QStringLiteral(",\n")));
} else { } else {
if (!newTable->primaryKey().isNull()) { if (!newTable->primaryKey().isNull()) {
QString pkCon = primaryKeyConstraint(newTable); QString pkCon = primaryKeyConstraint(newTable);
@ -283,8 +282,8 @@ QStringList SqlGeneratorBase::diff(TableModel *oldTable, TableModel *newTable)
columnSql << constraints(newTable); columnSql << constraints(newTable);
} }
sql = QString("CREATE TABLE %1 \n(%2)") sql = QString::fromUtf8("CREATE TABLE %1 \n(%2)")
.arg(newTable->name(), columnSql.join(",\n")); .arg(newTable->name(), columnSql.join(QStringLiteral(",\n")));
} }
return QStringList() << sql; return QStringList() << sql;
@ -298,10 +297,11 @@ QStringList SqlGeneratorBase::diffRelation(TableModel *oldTable, TableModel *new
QList<QString> relations; QList<QString> relations;
if (oldTable) if (oldTable) {
foreach (RelationModel *r, oldTable->foreignKeys()) foreach (RelationModel *r, oldTable->foreignKeys())
if (!relations.contains(r->localColumn)) if (!relations.contains(r->localColumn))
relations.append(r->localColumn); relations.append(r->localColumn);
}
foreach (RelationModel *r, newTable->foreignKeys()) foreach (RelationModel *r, newTable->foreignKeys())
if (!relations.contains(r->localColumn)) if (!relations.contains(r->localColumn))
@ -320,8 +320,9 @@ QStringList SqlGeneratorBase::diffRelation(TableModel *oldTable, TableModel *new
} }
if (columnSql.count()) if (columnSql.count())
ret.append("ALTER TABLE " + newTable->name() + "\n" ret.append(QStringLiteral("ALTER TABLE ") + newTable->name()
+ columnSql.join(",\n")); + QStringLiteral("\n")
+ columnSql.join(QStringLiteral(",\n")));
return ret; return ret;
} }
@ -900,7 +901,10 @@ QString SqlGeneratorBase::phrase(const PhraseData *d) const
break; break;
case PhraseData::WithVariant: case PhraseData::WithVariant:
ret = phrase(d->left) + " " + operatorString(d->operatorCond) + " " ret = phrase(d->left)
+ QStringLiteral(" ")
+ operatorString(d->operatorCond)
+ QStringLiteral(" ")
+ escapeValue(d->operand); + escapeValue(d->operand);
break; break;

4
src/nut/generators/sqlservergenerator.cpp
View File

@ -22,8 +22,8 @@
#include "../table.h" #include "../table.h"
#include "../tablemodel.h" #include "../tablemodel.h"
#include <QPoint> #include <QtCore/QPoint>
#include <QRegularExpression> #include <QtCore/QRegularExpression>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

7
src/nut/nut.pro
View File

@ -1,9 +1,6 @@
QT += sql gui
TARGET = QtNut TARGET = QtNut
#TARGET = nut
#TEMPLATE = lib QT = core sql gui
#CONFIG += c++11
DEFINES += QT_DEPRECATED_WARNINGS NUT_SHARED NUT_BUILD_LIB DEFINES += QT_DEPRECATED_WARNINGS NUT_SHARED NUT_BUILD_LIB

2
src/nut/phrase.cpp
View File

@ -20,7 +20,7 @@
#include "phrase.h" #include "phrase.h"
#include <QDebug> #include <QtCore/QDebug>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

2
src/nut/phrases/datephrase.h
View File

@ -22,7 +22,7 @@
#define DATEPHRASE_H #define DATEPHRASE_H
#include "fieldphrase.h" #include "fieldphrase.h"
#include <QDateTime> #include <QtCore/QDateTime>
#include <type_traits> #include <type_traits>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

3
src/nut/phrases/fieldphrase.h
View File

@ -65,7 +65,8 @@ public:
} }
ConditionalPhrase contains(const QString &term) { ConditionalPhrase contains(const QString &term) {
return ConditionalPhrase(this, PhraseData::Like, QStringLiteral("%") + term + QStringLiteral("%")); return ConditionalPhrase(this, PhraseData::Like,
QVariant(QStringLiteral("%") + term + QStringLiteral("%")));
} }
AssignmentPhrase operator =(const QVariant &v) { AssignmentPhrase operator =(const QVariant &v) {

8
src/nut/query.h
View File

@ -172,7 +172,7 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
{ {
Q_D(Query); Q_D(Query);
RowList<T> returnList; RowList<T> returnList;
d->select = "*"; d->select = QStringLiteral("*");
d->sql = d->database->sqlGenerator()->selectCommand( d->sql = d->database->sqlGenerator()->selectCommand(
d->tableName, d->fieldPhrase, d->wherePhrase, d->orderPhrase, d->tableName, d->fieldPhrase, d->wherePhrase, d->orderPhrase,
@ -629,8 +629,10 @@ Q_OUTOFLINE_TEMPLATE void Query<T>::toModel(QSqlQueryModel *model)
if (d->fieldPhrase.data.count()) { if (d->fieldPhrase.data.count()) {
foreach (const PhraseData *pd, d->fieldPhrase.data) { foreach (const PhraseData *pd, d->fieldPhrase.data) {
QString displayName = dbModel.tableByClassName(pd->className) QString displayName = dbModel
->field(pd->fieldName)->displayName; .tableByClassName(QString::fromUtf8(pd->className))
->field(QString::fromUtf8(pd->fieldName))
->displayName;
model->setHeaderData(fieldIndex++, model->setHeaderData(fieldIndex++,
Qt::Horizontal, Qt::Horizontal,

2
src/nut/serializableobject.h
View File

@ -1,7 +1,7 @@
#ifndef SERIALIZABLEOBJECT_H #ifndef SERIALIZABLEOBJECT_H
#define SERIALIZABLEOBJECT_H #define SERIALIZABLEOBJECT_H
#include <QVariant> #include <QtCore/QVariant>
class SerializableObject class SerializableObject
{ {

4
src/nut/sqlmodel.h
View File

@ -22,10 +22,10 @@
#define SQLMODEL_H #define SQLMODEL_H
#include <QtCore/QAbstractTableModel> #include <QtCore/QAbstractTableModel>
#include <QtCore/QExplicitlySharedDataPointer>
#include <QtCore/QList>
#include "defines.h" #include "defines.h"
#include "sqlmodel_p.h" #include "sqlmodel_p.h"
#include <QExplicitlySharedDataPointer>
#include <QList>
#include <functional> #include <functional>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

4
src/nut/sqlmodel_p.h
View File

@ -1,8 +1,8 @@
#ifndef SQLMODEL_P_H #ifndef SQLMODEL_P_H
#define SQLMODEL_P_H #define SQLMODEL_P_H
#include <QSharedPointer> #include <QtCore/QSharedPointer>
#include <QString> #include <QtCore/QString>
#include "defines.h" #include "defines.h"
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

6
src/nut/table.cpp
View File

@ -18,9 +18,9 @@
** **
**************************************************************************/ **************************************************************************/
#include <QMetaMethod> #include <QtCore/QMetaMethod>
#include <QVariant> #include <QtCore/QVariant>
#include <QSqlQuery> #include <QtSql/QSqlQuery>
#include "table.h" #include "table.h"
#include "table_p.h" #include "table_p.h"

2
src/nut/table_p.h
View File

@ -4,7 +4,7 @@
#include "defines.h" #include "defines.h"
#include <QtCore/QSet> #include <QtCore/QSet>
#include <QSharedData> #include <QtCore/QSharedData>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

5
src/nut/tablemodel.cpp
View File

@ -21,9 +21,8 @@
#include <QtCore/QMetaObject> #include <QtCore/QMetaObject>
#include <QtCore/QMetaProperty> #include <QtCore/QMetaProperty>
#include <QtCore/QDebug> #include <QtCore/QDebug>
#include <QtCore/QJsonArray>
#include <QJsonArray> #include <QtCore/QJsonObject>
#include <QJsonObject>
#include "tablemodel.h" #include "tablemodel.h"
#include "defines.h" #include "defines.h"

2
src/nut/tablemodel.h
View File

@ -22,7 +22,7 @@
#define TABLEMODEL_H #define TABLEMODEL_H
#include <QtCore/QVariant> #include <QtCore/QVariant>
#include <QDebug> #include <QtCore/QDebug>
#include "defines.h" #include "defines.h"
class QJsonObject; class QJsonObject;

3
src/nut/tableset.h
View File

@ -25,8 +25,9 @@
#include <QtCore/QMetaMethod> #include <QtCore/QMetaMethod>
#include <QtCore/QMetaType> #include <QtCore/QMetaType>
#include <QtCore/QVariant> #include <QtCore/QVariant>
#include <QtCore/QSharedPointer>
#include <QtSql/QSqlQuery> #include <QtSql/QSqlQuery>
#include <QSharedPointer>
#include "tablesetbase_p.h" #include "tablesetbase_p.h"
#include "table.h" #include "table.h"

2
src/nut/tablesetbase_p.h
View File

@ -24,7 +24,7 @@
#include <QtCore/QObject> #include <QtCore/QObject>
#include <QtCore/qglobal.h> #include <QtCore/qglobal.h>
#include <QtCore/QSet> #include <QtCore/QSet>
#include <QExplicitlySharedDataPointer> #include <QtCore/QExplicitlySharedDataPointer>
#include "defines.h" #include "defines.h"

2
src/nut/tablesetbasedata.h
View File

@ -21,7 +21,7 @@
#ifndef TABLESETBASEDATA_H #ifndef TABLESETBASEDATA_H
#define TABLESETBASEDATA_H #define TABLESETBASEDATA_H
#include <QSharedData> #include <QtCore/QSharedData>
#include "defines.h" #include "defines.h"
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

2
src/nut/types/dbgeography.h
View File

@ -24,7 +24,7 @@
#include "../defines.h" #include "../defines.h"
#include <QtCore/QObject> #include <QtCore/QObject>
#include <QtCore/qglobal.h> #include <QtCore/qglobal.h>
#include <QVariant> #include <QtCore/QVariant>
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE

2
sync.profile
View File

@ -1,5 +1,3 @@
%modules = ( %modules = (
"QtNut" => "$basedir/src/nut", "QtNut" => "$basedir/src/nut",
); );
$publicclassregexp = "^QtJsonSerializer::(?!__private::|MetaWriters::Implementations::|TypeExtractors::|Exception).+";

14
tests/auto/cmake/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 2.8)
project(qmake_cmake_files)
enable_testing()
find_package(Qt5Core REQUIRED)
include("${_Qt5CTestMacros}")
test_module_includes(
Nut QNut
)

7
tests/auto/cmake/cmake.pro Normal file
View File

@ -0,0 +1,7 @@
# Cause make to do nothing.
TEMPLATE = subdirs
CMAKE_QT_MODULES_UNDER_TEST = nut
CONFIG += ctest_testcase