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

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

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

2
.qmake.conf
View File

@ -1,7 +1,7 @@
load(qt_build_config)
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

1
nut.pro
View File

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

2
src/nut/bulkinserter.cpp
View File

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

2
src/nut/bulkinserter.h
View File

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

44
src/nut/database.cpp
View File

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

2
src/nut/database.h
View File

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

4
src/nut/database_p.h
View File

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

4
src/nut/databasemodel.cpp
View File

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

14
src/nut/defines.h
View File

@ -24,12 +24,12 @@
#define NUT_NAMESPACE Nut
#include "defines_p.h"
#include "qglobal.h"
#include <QtCore/QtGlobal>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QMetaClassInfo>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtCore/QMetaClassInfo>
#if defined(NUT_SHARED) || !defined(NUT_STATIC)
# ifdef NUT_STATIC
@ -89,7 +89,7 @@ public: \
} \
void write(type name){ \
m_##name = name; \
propertyChanged(#name); \
propertyChanged(QString::fromUtf8(#name)); \
}
#define NUT_FOREIGN_KEY(type, keytype, name, read, write) \
@ -124,14 +124,12 @@ public slots: \
void write##Id(keytype name##Id);
#define NUT_FOREIGN_KEY_IMPLEMENT(class, type, keytype, name, read, write) \
\
Nut::Row<type> class::read() const { return m_##name ; } \
void class::write(Nut::Row<type> name){ \
propertyChanged(QT_STRINGIFY2(name##Id)); \
m_##name = name; \
m_##name##Id = name->primaryValue().value<keytype>(); \
} \
\
keytype class::read##Id() const{ \
if (m_##name) \
return m_##name->primaryValue().value<keytype>(); \

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

@ -21,14 +21,14 @@
#include "mysqlgenerator.h"
#include "../tablemodel.h"
#include <QPoint>
#include <QPointF>
#include <QTime>
#include <QDate>
#include <QDateTime>
#include <QtCore/QPoint>
#include <QtCore/QPointF>
#include <QtCore/QTime>
#include <QtCore/QDate>
#include <QtCore/QDateTime>
#ifdef QT_GUI_LIB
#include <QPolygon>
#include <QPolygonF>
# include <QtGui/QPolygon>
# include <QtGui/QPolygonF>
#endif
#include "sqlserializer.h"
@ -45,42 +45,42 @@ QString MySqlGenerator::fieldType(FieldModel *field)
QString dbType;
switch (field->type) {
case QMetaType::Bool: return "BOOLEAN";
case QMetaType::Bool: return QStringLiteral("BOOLEAN");
case QMetaType::Char:
case QMetaType::QChar: return "CHAR(1)";
case QMetaType::QChar: return QStringLiteral("CHAR(1)");
case QMetaType::SChar:
case QMetaType::UChar: return "TINYINT";
case QMetaType::UChar: return QStringLiteral("TINYINT");
case QMetaType::Short:
case QMetaType::UShort: return "SMALLINT";
case QMetaType::UShort: return QStringLiteral("SMALLINT");
case QMetaType::UInt:
case QMetaType::Int:
dbType = "INT";
dbType = QStringLiteral("INT");
if(field->isAutoIncrement)
dbType += " AUTO_INCREMENT";
dbType += QStringLiteral(" AUTO_INCREMENT");
break;
case QMetaType::Long:
case QMetaType::ULong:
case QMetaType::LongLong:
case QMetaType::ULongLong:
return "BIGINT";
return QStringLiteral("BIGINT");
case QMetaType::Float:
return "FLOAT";
return QStringLiteral("FLOAT");
case QMetaType::Double:
return "REAL";
return QStringLiteral("REAL");
case QMetaType::QBitArray: return "VARBINARY";
case QMetaType::QByteArray: return "BLOB";
case QMetaType::QDate: return "DATE";
case QMetaType::QTime: return "TIME";
case QMetaType::QDateTime: return "DATETIME";
case QMetaType::QBitArray: return QStringLiteral("VARBINARY");
case QMetaType::QByteArray: return QStringLiteral("BLOB");
case QMetaType::QDate: return QStringLiteral("DATE");
case QMetaType::QTime: return QStringLiteral("TIME");
case QMetaType::QDateTime: return QStringLiteral("DATETIME");
case QMetaType::QString:
if(field->length)
dbType = QString("VARCHAR(%1)").arg(field->length);
dbType = QString::fromUtf8("VARCHAR(%1)").arg(field->length);
else
dbType = "TEXT";
dbType = QStringLiteral("TEXT");
break;
@ -109,7 +109,7 @@ QString MySqlGenerator::fieldType(FieldModel *field)
case QMetaType::QJsonValue:
case QMetaType::QJsonObject:
case QMetaType::QJsonDocument:
case QMetaType::QStringList: return "TEXT";
case QMetaType::QStringList: return QStringLiteral("TEXT");
default:
qWarning("Type %s::%s(%d) is not supported",
@ -128,16 +128,16 @@ QString MySqlGenerator::fieldType(FieldModel *field)
QString MySqlGenerator::escapeValue(const QVariant &v) const
{
if (v.type() == QVariant::Bool)
return v.toBool() ? "1" : "0";
return v.toBool() ? QStringLiteral("1") : QStringLiteral("0");
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)
return "'" + v.toDate().toString("yyyy-MM-dd") + "'";
return v.toDate().toString(QStringLiteral("'yyyy-MM-dd'"));
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
// if (v.type() == QVariant::Polygon) {
@ -316,7 +316,7 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::AddMinutesDateTime:
case PhraseData::AddSeconds:
case PhraseData::AddSecondsDateTime:
return QString("DATE_ADD(%1, INTERVAL %2 %3)")
return QString::fromUtf8("DATE_ADD(%1, INTERVAL %2 %3)")
.arg(createConditionalPhrase(d->left),
d->operand.toString(),
SqlGeneratorBase::dateTimePartName(op));
@ -333,7 +333,7 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::DatePartHour:
case PhraseData::DatePartMinute:
case PhraseData::DatePartSecond:
return QString("%2(%1)")
return QString::fromUtf8("%2(%1)")
.arg(createConditionalPhrase(d->left),
SqlGeneratorBase::dateTimePartName(op));
@ -348,11 +348,11 @@ QString MySqlGenerator::createConditionalPhrase(const PhraseData *d) const
void MySqlGenerator::appendSkipTake(QString &sql, int skip, int take)
{
if (take > 0 && skip > 0) {
sql.append(QString(" LIMIT %1 OFFSET %2")
sql.append(QString::fromUtf8(" LIMIT %1 OFFSET %2")
.arg(take)
.arg(skip));
} 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 <QPoint>
#include <QtCore/QDateTime>
#include <QtCore/QPoint>
#ifdef QT_GUI_LIB
#include <QPolygon>
#include <QPolygonF>
# include <QtGui/QPolygon>
# include <QtGui/QPolygonF>
#endif
#include <QVariant>
#include <QJsonDocument>
#include <QtCore/QVariant>
#include <QtCore/QJsonDocument>
#include "postgresqlgenerator.h"
#include "../table.h"
@ -83,44 +84,44 @@ QString PostgreSqlGenerator::fieldType(FieldModel *field)
switch (field->type) {
case QMetaType::Bool:
dbType = "BOOLEAN";
dbType = QStringLiteral("BOOLEAN");
break;
case QMetaType::QBitArray:
case QMetaType::QByteArray:
dbType = "BYTEA";
dbType = QStringLiteral("BYTEA");
break;
case QMetaType::QDate:
dbType = "DATE";
dbType = QStringLiteral("DATE");
break;
case QMetaType::QDateTime:
dbType = "TIMESTAMP";
dbType = QStringLiteral("TIMESTAMP");
break;
case QMetaType::QTime:
dbType = "TIME";
dbType = QStringLiteral("TIME");
break;
case QMetaType::SChar:
case QMetaType::UChar:
case QMetaType::Short:
case QMetaType::UShort:
dbType = "SMALLINT";
dbType = QStringLiteral("SMALLINT");
break;
case QMetaType::Float:
dbType = "FLOAT";
dbType = QStringLiteral("FLOAT");
break;
case QMetaType::Double:
dbType = "REAL";
dbType = QStringLiteral("REAL");
break;
case QMetaType::Int:
case QMetaType::UInt:
if(field->isAutoIncrement)
dbType = "SERIAL";
dbType = QStringLiteral("SERIAL");
else
dbType = "INTEGER";
dbType = QStringLiteral("INTEGER");
break;
case QMetaType::Long:
@ -128,58 +129,58 @@ QString PostgreSqlGenerator::fieldType(FieldModel *field)
case QMetaType::LongLong:
case QMetaType::ULongLong:
if(field->isAutoIncrement)
dbType = "BIGSERIAL";
dbType = QStringLiteral("BIGSERIAL");
else
dbType = "BIGINT";
dbType = QStringLiteral("BIGINT");
break;
case QMetaType::Char:
case QMetaType::QChar:
return "CHAR(1)";
return QStringLiteral("CHAR(1)");
case QMetaType::QString:
if(field->length)
dbType = QString("VARCHAR(%1)").arg(field->length);
else
dbType = "TEXT";
dbType = QStringLiteral("TEXT");
break;
case QMetaType::QPoint:
case QMetaType::QPointF:
dbType="POINT";
dbType = QStringLiteral("POINT");
break;
case QMetaType::QUuid:
dbType = "UUID";
dbType = QStringLiteral("UUID");
break;
case QMetaType::QPolygon:
case QMetaType::QPolygonF:
dbType = "POLYGON";
dbType = QStringLiteral("POLYGON");
break;
case QMetaType::QLine:
case QMetaType::QLineF:
return "LINE";
return QStringLiteral("LINE");
case QMetaType::QRect:
case QMetaType::QRectF:
return "BOX";
return QStringLiteral("BOX");
case QMetaType::QJsonArray:
case QMetaType::QJsonValue:
case QMetaType::QJsonObject:
case QMetaType::QJsonDocument:
return "JSONB";
return QStringLiteral("JSONB");
case QMetaType::QStringList:
return "TEXT[]";
return QStringLiteral("TEXT[]");
case QMetaType::QSize:
case QMetaType::QSizeF:
case QMetaType::QUrl:
case QMetaType::QColor:
return "TEXT";
return QStringLiteral("TEXT");
default:
dbType = QString();
@ -196,13 +197,13 @@ QString PostgreSqlGenerator::diff(FieldModel *oldField, FieldModel *newField)
return QString();
if(!newField){
sql = "DROP COLUMN " + oldField->name;
sql = QStringLiteral("DROP COLUMN ") + oldField->name;
}else{
if(oldField){
sql = "ALTER COLUMN ";
sql.append(newField->name + " TYPE " + fieldType(newField));
sql = QStringLiteral("ALTER COLUMN ");
sql.append(newField->name + QStringLiteral(" TYPE ") + fieldType(newField));
} else {
sql = "ADD COLUMN ";
sql = QStringLiteral("ADD COLUMN ");
sql.append(fieldDeclare(newField));
}
}
@ -212,27 +213,31 @@ QString PostgreSqlGenerator::diff(FieldModel *oldField, FieldModel *newField)
QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
{
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)
return "'" + v.toDate().toString("yyyy-MM-dd") + "'";
return v.toDate().toString(QStringLiteral("'yyyy-MM-dd'"));
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)
return "'{" + v.toStringList().join(",") + "}'";
return QStringLiteral("'{")
+ v.toStringList().join(QStringLiteral(","))
+ QStringLiteral("}'");
if (v.type() == QVariant::Point) {
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) {
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) {
return "'" + QString(v.toJsonDocument().toJson(QJsonDocument::Compact)) + "'";
return QStringLiteral("'")
+ QString::fromUtf8(v.toJsonDocument().toJson(QJsonDocument::Compact))
+ QStringLiteral("'");
}
#ifdef QT_GUI_LIB
@ -243,7 +248,7 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
for (int i = 0; i < pol.size(); ++i) {
pt = pol.at(i);
if (!ret.isEmpty())
ret.append("),(");
ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y()));
}
return "'((" + ret + "))'";
@ -255,7 +260,7 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
for (int i = 0; i < pol.size(); ++i) {
pt = pol.at(i);
if (!ret.isEmpty())
ret.append("),(");
ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y()));
}
return "'((" + ret + "))'";
@ -277,14 +282,24 @@ QVariant PostgreSqlGenerator::unescapeValue(const QMetaType::Type &type, const Q
return dbValue.toDate();
if (type == QMetaType::QPoint)
return SqlGeneratorBase::unescapeValue(QMetaType::QPoint, dbValue.toString()
.replace("(", "").replace(")", ""));
return SqlGeneratorBase::unescapeValue(QMetaType::QPoint,
dbValue.toString()
.replace(QStringLiteral("("),
QStringLiteral(""))
.replace(QStringLiteral(")"),
QStringLiteral("")));
if (type == QMetaType::QPointF)
return SqlGeneratorBase::unescapeValue(QMetaType::QPointF, dbValue.toString()
.replace("(", "").replace(")", ""));
return SqlGeneratorBase::unescapeValue(QMetaType::QPointF,
dbValue.toString()
.replace(QStringLiteral("("),
QStringLiteral(""))
.replace(QStringLiteral(")"),
QStringLiteral("")));
if (type == QMetaType::QStringList)
return dbValue.toString().replace("{", "").replace("}", "")
.split(",");
return dbValue.toString()
.replace(QStringLiteral("{"), QStringLiteral(""))
.replace(QStringLiteral("}"), QStringLiteral(""))
.split(QStringLiteral(","));
#ifdef QT_GUI_LIB
if (type == QMetaType::QPolygon) {
@ -337,7 +352,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
if (d->type == PhraseData::WithVariant) {
if (isPostGisType(d->operand.type()) && d->operatorCond == PhraseData::Equal) {
return QString("%1 ~= %2")
return QString::fromUtf8("%1 ~= %2")
.arg(SqlGeneratorBase::createConditionalPhrase(d->left),
escapeValue(d->operand));
}
@ -354,7 +369,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::AddMinutesDateTime:
case PhraseData::AddSeconds:
case PhraseData::AddSecondsDateTime:
return QString("%1 + interval '%2 %3'")
return QString::fromUtf8("%1 + interval '%2 %3'")
.arg(createConditionalPhrase(d->left),
d->operand.toString(),
SqlGeneratorBase::dateTimePartName(op));
@ -372,7 +387,7 @@ QString PostgreSqlGenerator::createConditionalPhrase(const PhraseData *d) const
case PhraseData::DatePartHour:
case PhraseData::DatePartMinute:
case PhraseData::DatePartSecond:
return QString("date_part('%2', %1)")
return QString::fromUtf8("date_part('%2', %1)")
.arg(createConditionalPhrase(d->left),
SqlGeneratorBase::dateTimePartName(op));

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

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

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

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

7
src/nut/nut.pro
View File

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

2
src/nut/phrase.cpp
View File

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

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

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

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

@ -65,7 +65,8 @@ public:
}
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) {

8
src/nut/query.h
View File

@ -172,7 +172,7 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
{
Q_D(Query);
RowList<T> returnList;
d->select = "*";
d->select = QStringLiteral("*");
d->sql = d->database->sqlGenerator()->selectCommand(
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()) {
foreach (const PhraseData *pd, d->fieldPhrase.data) {
QString displayName = dbModel.tableByClassName(pd->className)
->field(pd->fieldName)->displayName;
QString displayName = dbModel
.tableByClassName(QString::fromUtf8(pd->className))
->field(QString::fromUtf8(pd->fieldName))
->displayName;
model->setHeaderData(fieldIndex++,
Qt::Horizontal,

2
src/nut/serializableobject.h
View File

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

4
src/nut/sqlmodel.h
View File

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

4
src/nut/sqlmodel_p.h
View File

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

6
src/nut/table.cpp
View File

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

2
src/nut/table_p.h
View File

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

5
src/nut/tablemodel.cpp
View File

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

2
src/nut/tablemodel.h
View File

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

3
src/nut/tableset.h
View File

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

2
src/nut/tablesetbase_p.h
View File

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

2
src/nut/tablesetbasedata.h
View File

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

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

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

2
sync.profile
View File

@ -1,5 +1,3 @@
%modules = (
"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