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

all warnings was fixed !!!

This commit is contained in:
Hamed Masafi 2020-07-30 19:35:11 +04:30
parent 3a2115b309
commit 94c2c4ad5f
14 changed files with 126 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nut/3rdparty/serializer vendored

@ -1 +1 @@
Subproject commit 2dc11b380a07424a4face3046cc6b5e50aefb700 Subproject commit 0e794d6317595d077e95e8a06f1f3a8c92543b05

24
src/nut/database.cpp
View File

@ -66,7 +66,7 @@ bool DatabasePrivate::open(bool update)
return true; return true;
Q_Q(Database); Q_Q(Database);
// if (update) // if (update)
connectionName = q->metaObject()->className() connectionName = QString::fromUtf8(q->metaObject()->className())
+ QString::number(DatabasePrivate::lastId); + QString::number(DatabasePrivate::lastId);
db = QSqlDatabase::addDatabase(driver, connectionName); db = QSqlDatabase::addDatabase(driver, connectionName);
@ -77,7 +77,7 @@ bool DatabasePrivate::open(bool update)
db.setUserName(userName); db.setUserName(userName);
db.setPassword(password); db.setPassword(password);
if (driver.startsWith("qsqlite", Qt::CaseInsensitive) if (driver.startsWith(QStringLiteral("qsqlite"), Qt::CaseInsensitive)
&& !QFile::exists(databaseName)) { && !QFile::exists(databaseName)) {
//Force to execute update database //Force to execute update database
isDatabaseNew = true; isDatabaseNew = true;
@ -89,18 +89,20 @@ bool DatabasePrivate::open(bool update)
qWarning("Could not connect to database, error = %s", qWarning("Could not connect to database, error = %s",
db.lastError().text().toLocal8Bit().data()); db.lastError().text().toLocal8Bit().data());
if (db.lastError().text().contains("database \"" + databaseName if (db.lastError().text().contains(QStringLiteral("database \"")
+ "\" does not exist") + databaseName
|| db.lastError().text().contains("Cannot open database") + QStringLiteral("\" does not exist"))
|| db.lastError().text().contains("Unknown database '" || db.lastError().text().contains(QStringLiteral("Cannot open database"))
+ databaseName + "'")) { || db.lastError().text().contains(QStringLiteral("Unknown database '")
+ databaseName
+ QStringLiteral("'"))) {
db.close(); db.close();
db.setDatabaseName(sqlGenerator->masterDatabaseName(databaseName)); db.setDatabaseName(sqlGenerator->masterDatabaseName(databaseName));
ok = db.open(); ok = db.open();
qDebug("Creating database"); qDebug("Creating database");
if (ok) { if (ok) {
db.exec("CREATE DATABASE " + databaseName); db.exec(QStringLiteral("CREATE DATABASE ") + databaseName);
db.close(); db.close();
if (db.lastError().type() != QSqlError::NoError) { if (db.lastError().type() != QSqlError::NoError) {
@ -219,8 +221,8 @@ bool DatabasePrivate::getCurrectSchema()
if (!nutClassInfoString(q->metaObject()->classInfo(i), if (!nutClassInfoString(q->metaObject()->classInfo(i),
type, name, value)) { type, name, value)) {
errorMessage = QStringLiteral("No valid table in %1") errorMessage = QStringLiteral("No valid table in ")
.arg(q->metaObject()->classInfo(i).value()); + QString::fromUtf8(q->metaObject()->classInfo(i).value());
continue; continue;
} }
if (type == QStringLiteral(__nut_TABLE)) { if (type == QStringLiteral(__nut_TABLE)) {
@ -326,7 +328,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(QString(QJsonDocument(current.toJson()).toJson(QJsonDocument::Compact))); changeLog->setData(QString::fromUtf8(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);

4
src/nut/databasemodel.cpp
View File

@ -28,8 +28,8 @@ NUT_BEGIN_NAMESPACE
QMap<QString, DatabaseModel*> DatabaseModel::_models; QMap<QString, DatabaseModel*> DatabaseModel::_models;
#define NODE_VERSION "version" #define NODE_VERSION QStringLiteral("version")
#define NODE_TABLES "tables" #define NODE_TABLES QStringLiteral("tables")
DatabaseModel::DatabaseModel(const QString &name) : DatabaseModel::DatabaseModel(const QString &name) :
QList<TableModel*>(), _databaseClassName(name), _version(0) QList<TableModel*>(), _databaseClassName(name), _version(0)
{ {

2
src/nut/defines_p.h
View File

@ -41,7 +41,7 @@
#define __nut_DEFAULT_VALUE "def" #define __nut_DEFAULT_VALUE "def"
#define __nut_NOT_NULL "notnull" #define __nut_NOT_NULL "notnull"
#define __nut_FOREIGN_KEY "foreign_key" #define __nut_FOREIGN_KEY "foreign_key"
#define __nut_NEW "new" #define __nut_NEW "new"
#define __nut_REMOVE "remove" #define __nut_REMOVE "remove"
#define __nut_CHANGE "change" #define __nut_CHANGE "change"

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

@ -262,7 +262,8 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
pt = pol.at(i); pt = pol.at(i);
if (!ret.isEmpty()) if (!ret.isEmpty())
ret.append(QStringLiteral("),(")); ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y())); ret.append(QString::number(pt.x())
+ QStringLiteral(", ") + QString::number(pt.y()));
} }
return QStringLiteral("'((") + ret + QStringLiteral("))'"); return QStringLiteral("'((") + ret + QStringLiteral("))'");
} }

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

@ -383,7 +383,8 @@ QString SqlGeneratorBase::join(const QString &mainTable,
(*i)->masterTable->primaryKey())); (*i)->masterTable->primaryKey()));
if (order != Q_NULLPTR) if (order != Q_NULLPTR)
order->append((*i)->masterTable->name() + "." + (*i)->masterTable->primaryKey()); order->append((*i)->masterTable->name() + QStringLiteral(".")
+ (*i)->masterTable->primaryKey());
} }
} }
return ret; return ret;
@ -426,7 +427,8 @@ QString SqlGeneratorBase::join(const QStringList &list, QStringList *order)
rel->localColumn, mainTable)); rel->localColumn, mainTable));
if (order != Q_NULLPTR) if (order != Q_NULLPTR)
order->append(mainTable + "." + rel->masterTable->primaryKey()); order->append(mainTable + QStringLiteral(".")
+ rel->masterTable->primaryKey());
} else{ } else{
rel = model.relationByClassNames(clone.first(), mainTable); rel = model.relationByClassNames(clone.first(), mainTable);
@ -437,7 +439,8 @@ QString SqlGeneratorBase::join(const QStringList &list, QStringList *order)
rel->masterTable->primaryKey(), mainTable)); rel->masterTable->primaryKey(), mainTable));
if (order != Q_NULLPTR) if (order != Q_NULLPTR)
order->append(mainTable + "." + rel->localColumn); order->append(mainTable + QStringLiteral(".")
+ rel->localColumn);
} else { } else {
// qInfo("Relation for %s and %s not exists", // qInfo("Relation for %s and %s not exists",
@ -552,7 +555,7 @@ QString SqlGeneratorBase::fromTableText(const QString &tableName,
tableNameText = QStringLiteral("%1 INNER JOIN %2 ON (%1.%3 = %2.%4)") tableNameText = QStringLiteral("%1 INNER JOIN %2 ON (%1.%3 = %2.%4)")
.arg(tableName, joinTableName, .arg(tableName, joinTableName,
pk, rel->localColumn); pk, rel->localColumn);
orderBy = tableName + "." + pk; orderBy = tableName + QStringLiteral(".") + pk;
} else { } else {
qWarning("Relation between table %s and class %s (%s) not exists!", qWarning("Relation between table %s and class %s (%s) not exists!",
qPrintable(tableName), qPrintable(tableName),
@ -927,7 +930,7 @@ QString SqlGeneratorBase::phrase(const PhraseData *d) const
break; break;
case PhraseData::WithoutOperand: case PhraseData::WithoutOperand:
ret = phrase(d->left) + " " + operatorString(d->operatorCond); ret = phrase(d->left) + QStringLiteral(" ") + operatorString(d->operatorCond);
break; break;
} }

3
src/nut/phrases/phrasedata.cpp
View File

@ -73,7 +73,8 @@ PhraseData &PhraseData::operator =(PhraseData &other)
QString PhraseData::toString() const QString PhraseData::toString() const
{ {
return QString(QStringLiteral("[%1].%2")).arg(className, fieldName); return QStringLiteral("[%1].%2")
.arg(QString::fromUtf8(className), QString::fromUtf8(fieldName));
} }
void PhraseData::cleanUp() void PhraseData::cleanUp()

6
src/nut/phrases/phraselist.cpp
View File

@ -30,13 +30,13 @@ PhraseList::PhraseList() : isValid(false)
PhraseList::PhraseList(const PhraseList &other) : isValid(true) PhraseList::PhraseList(const PhraseList &other) : isValid(true)
{ {
data = qMove(other.data); data = other.data;
const_cast<PhraseList&>(other).data.clear();
} }
PhraseList::PhraseList(PhraseList &&other) PhraseList::PhraseList(PhraseList &&other)
{ {
data = other.data; data = qMove(other.data);
const_cast<PhraseList&>(other).data.clear();
} }
PhraseList::PhraseList(const AbstractFieldPhrase &other) : isValid(true) PhraseList::PhraseList(const AbstractFieldPhrase &other) : isValid(true)

25
src/nut/query.h
View File

@ -118,12 +118,13 @@ Q_OUTOFLINE_TEMPLATE QList<O> Query<T>::select(const std::function<O (const QSql
QList<O> ret; QList<O> ret;
d->joins.prepend(d->tableName); d->joins.prepend(d->tableName);
d->sql = d->database->sqlGenerator()->selectCommand( d->sql = d->database->sqlGenerator()->selectCommand(d->tableName,
d->tableName, SqlGeneratorBase::SingleField,
SqlGeneratorBase::SingleField, "*", QStringLiteral("*"),
d->wherePhrase, d->wherePhrase,
d->relations, d->relations,
d->skip, d->take); d->skip,
d->take);
QSqlQuery q = d->database->exec(d->sql); QSqlQuery q = d->database->exec(d->sql);
@ -153,7 +154,7 @@ Q_OUTOFLINE_TEMPLATE Query<T>::Query(Database *database, TableSetBase *tableSet,
d->database = database; d->database = database;
d->tableSet = tableSet; d->tableSet = tableSet;
d->className = T::staticMetaObject.className(); d->className = QString::fromUtf8(T::staticMetaObject.className());
d->tableName = d->tableName =
d->database->model() d->database->model()
.tableByClassName(d->className) .tableByClassName(d->className)
@ -207,7 +208,9 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
LevelData data; LevelData data;
data.table = table; data.table = table;
data.keyFiledname = data.table->name() + "." + data.table->primaryKey(); data.keyFiledname = data.table->name()
+ QStringLiteral(".")
+ data.table->primaryKey();
data.lastKeyValue = QVariant(); data.lastKeyValue = QVariant();
QHash<QString, QString> masters; QHash<QString, QString> masters;
@ -241,7 +244,7 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
if (!importedTables.count()) { if (!importedTables.count()) {
LevelData data; LevelData data;
data.table = d->database->model().tableByName(d->tableName); data.table = d->database->model().tableByName(d->tableName);
data.keyFiledname = d->tableName + "." + data.table->primaryKey(); data.keyFiledname = d->tableName + QStringLiteral(".") + data.table->primaryKey();
data.lastKeyValue = QVariant(); data.lastKeyValue = QVariant();
levels.append(data); levels.append(data);
@ -314,8 +317,8 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
foreach (FieldModel *field, childFields) foreach (FieldModel *field, childFields)
row->setProperty(field->name.toLatin1().data(), row->setProperty(field->name.toLatin1().data(),
d->database->sqlGenerator()->unescapeValue( d->database->sqlGenerator()->unescapeValue(
field->type, field->type,
q.value(data.table->name() + "." + field->name))); q.value(data.table->name() + QStringLiteral(".") + field->name)));
for (int i = 0; i < data.masters.count(); ++i) { for (int i = 0; i < data.masters.count(); ++i) {
int master = data.masters[i]; int master = data.masters[i];

2
src/nut/sqlmodel.cpp
View File

@ -70,7 +70,7 @@ QVariant SqlModel::data(const QModelIndex &index, int role) const
return QVariant(); return QVariant();
if (index.row() >= d->rows.count() || index.row() < 0) if (index.row() >= d->rows.count() || index.row() < 0)
return QVariant("-"); return QVariant::fromValue(QStringLiteral("-"));
if (role == Qt::DisplayRole) { if (role == Qt::DisplayRole) {
Row<Table> t = d->rows.at(index.row()); Row<Table> t = d->rows.at(index.row());

6
src/nut/table.cpp
View File

@ -127,7 +127,7 @@ bool Table::setParentTable(Table *master, TableModel *masterModel, TableModel *m
//Q_D(Table); //Q_D(Table);
d.detach(); d.detach();
QString masterClassName = master->metaObject()->className(); QString masterClassName = QString::fromUtf8(master->metaObject()->className());
d->refreshModel(); d->refreshModel();
// if (!d->model) // if (!d->model)
@ -173,9 +173,9 @@ int Table::save(Database *db)
{ {
//Q_D(Table); //Q_D(Table);
QSqlQuery q = db->exec(db->sqlGenerator()->saveRecord(this, db->tableName(metaObject()->className()))); QSqlQuery q = db->exec(db->sqlGenerator()->saveRecord(this, db->tableName(QString::fromUtf8(metaObject()->className()))));
auto model = db->model().tableByClassName(metaObject()->className()); auto model = db->model().tableByClassName(QString::fromUtf8(metaObject()->className()));
if(status() == Added && model->isPrimaryKeyAutoIncrement()) if(status() == Added && model->isPrimaryKeyAutoIncrement())
setProperty(model->primaryKey().toLatin1().data(), q.lastInsertId()); setProperty(model->primaryKey().toLatin1().data(), q.lastInsertId());

138
src/nut/tablemodel.cpp
View File

@ -29,6 +29,11 @@
NUT_BEGIN_NAMESPACE NUT_BEGIN_NAMESPACE
#define REL_LOCAL_COLUMN QStringLiteral("localColumn")
#define REL_LOCAL_PROPERTY QStringLiteral("localProperty")
#define REL_MASTER_CLASS_NAME QStringLiteral("masterClassName")
#define REL_FOREIGIN_COLUMN QStringLiteral("foreignColumn")
QString TableModel::name() const QString TableModel::name() const
{ {
return _name; return _name;
@ -128,7 +133,7 @@ TableModel::TableModel(int typeId, const QString &tableName)
_typeId = typeId; _typeId = typeId;
_name = tableName; _name = tableName;
_className = tableMetaObject->className(); _className = QString::fromUtf8(tableMetaObject->className());
//#ifdef NUT_NAMESPACE //#ifdef NUT_NAMESPACE
// if(_className.startsWith(QT_STRINGIFY(NUT_NAMESPACE) "::")) // if(_className.startsWith(QT_STRINGIFY(NUT_NAMESPACE) "::"))
@ -146,7 +151,7 @@ TableModel::TableModel(int typeId, const QString &tableName)
continue; continue;
} }
if(type == __nut_FIELD){ if(type == QStringLiteral(__nut_FIELD)) {
auto *f = new FieldModel; auto *f = new FieldModel;
f->name = f->displayName = name; f->name = f->displayName = name;
_fields.append(f); _fields.append(f);
@ -155,15 +160,15 @@ TableModel::TableModel(int typeId, const QString &tableName)
// Browse all fields // Browse all fields
for(int j = 1; j < tableMetaObject->propertyCount(); j++){ for(int j = 1; j < tableMetaObject->propertyCount(); j++){
QMetaProperty fieldProperty = tableMetaObject->property(j); QMetaProperty fieldProperty = tableMetaObject->property(j);
auto name = QString::fromUtf8(fieldProperty.name());
FieldModel *fieldObj = field(fieldProperty.name()); FieldModel *fieldObj = field(name);
foreach (FieldModel *f, _fields) foreach (FieldModel *f, _fields)
if(f->name == fieldProperty.name()) if(f->name == name)
f = fieldObj; f = fieldObj;
if(!fieldObj) if(!fieldObj)
continue; continue;
fieldObj->type = static_cast<QMetaType::Type>(fieldProperty.type()); fieldObj->type = static_cast<QMetaType::Type>(fieldProperty.type());
fieldObj->typeName = QString(fieldProperty.typeName()); fieldObj->typeName = QString::fromUtf8(fieldProperty.typeName());
} }
// Browse class infos // Browse class infos
@ -177,17 +182,17 @@ TableModel::TableModel(int typeId, const QString &tableName)
continue; continue;
} }
if(type == __nut_FOREIGN_KEY){ if(type == QStringLiteral(__nut_FOREIGN_KEY)) {
auto *fk = new RelationModel; auto *fk = new RelationModel;
fk->slaveTable = this; fk->slaveTable = this;
fk->localColumn = name + "Id"; fk->localColumn = name + QStringLiteral("Id");
fk->localProperty = name; fk->localProperty = name;
fk->foreignColumn = value; fk->foreignColumn = value;
fk->masterClassName = value; fk->masterClassName = value;
_foreignKeys.append(fk); _foreignKeys.append(fk);
} }
if(type == __nut_FIELD){ if(type == QStringLiteral(__nut_FIELD)) {
} }
@ -196,21 +201,21 @@ TableModel::TableModel(int typeId, const QString &tableName)
if (!f) if (!f)
continue; continue;
if (type == __nut_LEN) if (type == QStringLiteral(__nut_LEN))
f->length = value.toInt(); f->length = value.toInt();
else if (type == __nut_NOT_NULL) else if (type == QStringLiteral(__nut_NOT_NULL))
f->notNull = true; f->notNull = true;
else if (type == __nut_DEFAULT_VALUE) else if (type == QStringLiteral(__nut_DEFAULT_VALUE))
f->defaultValue = value; f->defaultValue = value;
else if (type == __nut_PRIMARY_KEY) else if (type == QStringLiteral(__nut_PRIMARY_KEY))
f->isPrimaryKey = true; f->isPrimaryKey = true;
else if (type == __nut_AUTO_INCREMENT) else if (type == QStringLiteral(__nut_AUTO_INCREMENT))
f->isAutoIncrement = true; f->isAutoIncrement = true;
else if (type == __nut_UNIQUE) else if (type == QStringLiteral(__nut_UNIQUE))
f->isUnique = true; f->isUnique = true;
else if (type == __nut_DISPLAY) else if (type == QStringLiteral(__nut_DISPLAY))
f->displayName = value.mid(1, value.length() - 2); f->displayName = value.mid(1, value.length() - 2);
else if (type == __nut_PRIMARY_KEY_AI) { else if (type == QStringLiteral(__nut_PRIMARY_KEY_AI)) {
f->isPrimaryKey = true; f->isPrimaryKey = true;
f->isAutoIncrement = true; f->isAutoIncrement = true;
} }
@ -237,27 +242,27 @@ TableModel::TableModel(const QJsonObject &json, const QString &tableName) : _typ
{ {
_name = tableName; _name = tableName;
QJsonObject fields = json.value(__FIELDS).toObject(); QJsonObject fields = json.value(QStringLiteral(__FIELDS)).toObject();
QJsonObject relations = json.value(__FOREIGN_KEYS).toObject(); QJsonObject relations = json.value(QStringLiteral(__FOREIGN_KEYS)).toObject();
foreach (QString key, fields.keys()) { foreach (QString key, fields.keys()) {
QJsonObject fieldObject = fields.value(key).toObject(); QJsonObject fieldObject = fields.value(key).toObject();
//TODO: use FieldModel(QJsonObject) ctor //TODO: use FieldModel(QJsonObject) ctor
auto *f = new FieldModel; auto *f = new FieldModel;
f->name = fieldObject.value(__NAME).toString(); f->name = fieldObject.value(QStringLiteral(__NAME)).toString();
f->type = static_cast<QMetaType::Type>(QMetaType::type(fieldObject.value(__TYPE).toString().toLatin1().data())); f->type = static_cast<QMetaType::Type>(QMetaType::type(fieldObject.value(QStringLiteral(__TYPE)).toString().toLatin1().data()));
f->typeName = QMetaType::typeName(f->type); f->typeName = QString::fromUtf8(QMetaType::typeName(f->type));
if(fieldObject.contains(__nut_NOT_NULL)) if(fieldObject.contains(QStringLiteral(__nut_NOT_NULL)))
f->notNull = fieldObject.value(__nut_NOT_NULL).toBool(); f->notNull = fieldObject.value(QStringLiteral(__nut_NOT_NULL)).toBool();
if(fieldObject.contains(__nut_UNIQUE)) if(fieldObject.contains(QStringLiteral(__nut_UNIQUE)))
f->isUnique = fieldObject.value(__nut_UNIQUE).toBool(); f->isUnique = fieldObject.value(QStringLiteral(__nut_UNIQUE)).toBool();
if(fieldObject.contains(__nut_LEN)) if(fieldObject.contains(QStringLiteral(__nut_LEN)))
f->length = fieldObject.value(__nut_LEN).toInt(); f->length = fieldObject.value(QStringLiteral(__nut_LEN)).toInt();
if(fieldObject.contains(__nut_DEFAULT_VALUE)) if(fieldObject.contains(QStringLiteral(__nut_DEFAULT_VALUE)))
f->defaultValue = fieldObject.value(__nut_DEFAULT_VALUE).toString(); f->defaultValue = fieldObject.value(QStringLiteral(__nut_DEFAULT_VALUE)).toString();
_fields.append(f); _fields.append(f);
} }
@ -281,34 +286,34 @@ QJsonObject TableModel::toJson() const
foreach (FieldModel *f, _fields) { foreach (FieldModel *f, _fields) {
QJsonObject fieldObj; QJsonObject fieldObj;
fieldObj.insert(__NAME, f->name); fieldObj.insert(QStringLiteral(__NAME), f->name);
fieldObj.insert(__TYPE, QString(QVariant::typeToName(f->type))); fieldObj.insert(QStringLiteral(__TYPE), QString::fromUtf8(QVariant::typeToName(f->type)));
if(f->length) if(f->length)
fieldObj.insert(__nut_LEN, f->length); fieldObj.insert(QStringLiteral(__nut_LEN), f->length);
if(f->notNull) if(f->notNull)
fieldObj.insert(__nut_NOT_NULL, f->notNull); fieldObj.insert(QStringLiteral(__nut_NOT_NULL), f->notNull);
if(f->isUnique) if(f->isUnique)
fieldObj.insert(__nut_UNIQUE, f->isUnique); fieldObj.insert(QStringLiteral(__nut_UNIQUE), f->isUnique);
if(!f->defaultValue.isNull()) if(!f->defaultValue.isNull())
fieldObj.insert(__nut_DEFAULT_VALUE, f->defaultValue); fieldObj.insert(QStringLiteral(__nut_DEFAULT_VALUE), f->defaultValue);
if(f->isAutoIncrement) if(f->isAutoIncrement)
obj.insert(__nut_AUTO_INCREMENT, f->name); obj.insert(QStringLiteral(__nut_AUTO_INCREMENT), f->name);
if(f->isPrimaryKey) if(f->isPrimaryKey)
obj.insert(__nut_PRIMARY_KEY, f->name); obj.insert(QStringLiteral(__nut_PRIMARY_KEY), f->name);
fieldsObj.insert(f->name, fieldObj); fieldsObj.insert(f->name, fieldObj);
} }
foreach (RelationModel *rel, _foreignKeys) foreach (RelationModel *rel, _foreignKeys)
foreignKeysObj.insert(rel->localColumn, rel->toJson()); foreignKeysObj.insert(rel->localColumn, rel->toJson());
obj.insert(__FIELDS, fieldsObj); obj.insert(QStringLiteral(__FIELDS), fieldsObj);
obj.insert(__FOREIGN_KEYS, foreignKeysObj); obj.insert(QStringLiteral(__FOREIGN_KEYS), foreignKeysObj);
return obj; return obj;
} }
@ -335,7 +340,8 @@ QString TableModel::toString() const
{ {
QStringList sl; QStringList sl;
foreach (FieldModel *f, _fields) foreach (FieldModel *f, _fields)
sl.append(f->name + QStringLiteral(" ") + QVariant::typeToName(f->type)); sl.append(f->name + QStringLiteral(" ")
+ QString::fromUtf8(QVariant::typeToName(f->type)));
QString ret = QStringLiteral("%1 (%2)") QString ret = QStringLiteral("%1 (%2)")
.arg(_name, sl.join(QStringLiteral(", "))); .arg(_name, sl.join(QStringLiteral(", ")));
@ -360,47 +366,47 @@ bool TableModel::isPrimaryKeyAutoIncrement() const
FieldModel::FieldModel(const QJsonObject &json) FieldModel::FieldModel(const QJsonObject &json)
{ {
name = json.value(__NAME).toString(); name = json.value(QStringLiteral(__NAME)).toString();
type = static_cast<QMetaType::Type>(json.value(__TYPE).toInt()); type = static_cast<QMetaType::Type>(json.value(QStringLiteral(__TYPE)).toInt());
length = json.value(__nut_LEN).toInt(); length = json.value(QStringLiteral(__nut_LEN)).toInt();
notNull = json.value(__nut_NOT_NULL).toBool(); notNull = json.value(QStringLiteral(__nut_NOT_NULL)).toBool();
isUnique = json.value(__nut_UNIQUE).toBool(); isUnique = json.value(QStringLiteral(__nut_UNIQUE)).toBool();
isAutoIncrement = json.value(__nut_AUTO_INCREMENT).toBool(); isAutoIncrement = json.value(QStringLiteral(__nut_AUTO_INCREMENT)).toBool();
isPrimaryKey = json.value(__nut_PRIMARY_KEY).toBool(); isPrimaryKey = json.value(QStringLiteral(__nut_PRIMARY_KEY)).toBool();
defaultValue = json.value(__nut_DEFAULT_VALUE).toString(); defaultValue = json.value(QStringLiteral(__nut_DEFAULT_VALUE)).toString();
isUnique = json.value(__nut_UNIQUE).toBool(); isUnique = json.value(QStringLiteral(__nut_UNIQUE)).toBool();
} }
QJsonObject FieldModel::toJson() const QJsonObject FieldModel::toJson() const
{ {
QJsonObject fieldObj; QJsonObject fieldObj;
fieldObj.insert(__NAME, name); fieldObj.insert(QStringLiteral(__NAME), name);
fieldObj.insert(__TYPE, QString(QVariant::typeToName(type))); fieldObj.insert(QStringLiteral(__TYPE), QString::fromUtf8(QVariant::typeToName(type)));
fieldObj.insert(__nut_LEN, length); fieldObj.insert(QStringLiteral(__nut_LEN), length);
fieldObj.insert(__nut_NOT_NULL, notNull); fieldObj.insert(QStringLiteral(__nut_NOT_NULL), notNull);
fieldObj.insert(__nut_UNIQUE, isUnique); fieldObj.insert(QStringLiteral(__nut_UNIQUE), isUnique);
fieldObj.insert(__nut_AUTO_INCREMENT, isAutoIncrement); fieldObj.insert(QStringLiteral(__nut_AUTO_INCREMENT), isAutoIncrement);
fieldObj.insert(__nut_PRIMARY_KEY, isPrimaryKey); fieldObj.insert(QStringLiteral(__nut_PRIMARY_KEY), isPrimaryKey);
fieldObj.insert(__nut_DEFAULT_VALUE, defaultValue); fieldObj.insert(QStringLiteral(__nut_DEFAULT_VALUE), defaultValue);
return fieldObj; return fieldObj;
} }
RelationModel::RelationModel(const QJsonObject &obj) RelationModel::RelationModel(const QJsonObject &obj)
{ {
localColumn = obj.value("localColumn").toString(); localColumn = obj.value(REL_LOCAL_COLUMN).toString();
localProperty = obj.value("localProperty").toString(); localProperty = obj.value(REL_LOCAL_PROPERTY).toString();
masterClassName = obj.value("masterClassName").toString(); masterClassName = obj.value(REL_MASTER_CLASS_NAME).toString();
foreignColumn = obj.value("foreignColumn").toString(); foreignColumn = obj.value(REL_FOREIGIN_COLUMN).toString();
slaveTable = masterTable = nullptr; slaveTable = masterTable = nullptr;
} }
QJsonObject RelationModel::toJson() const QJsonObject RelationModel::toJson() const
{ {
QJsonObject o; QJsonObject o;
o.insert("localColumn", localColumn); o.insert(REL_LOCAL_COLUMN, localColumn);
o.insert("localProperty", localProperty); o.insert(REL_LOCAL_PROPERTY, localProperty);
o.insert("masterClassName", masterClassName); o.insert(REL_MASTER_CLASS_NAME, masterClassName);
o.insert("foreignColumn", foreignColumn); o.insert(REL_FOREIGIN_COLUMN, foreignColumn);
return o; return o;
} }

4
src/nut/tableset.h
View File

@ -70,13 +70,13 @@ public:
template<class T> template<class T>
Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Database *parent) : TableSetBase(parent) Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Database *parent) : TableSetBase(parent)
{ {
data->childClassName = T::staticMetaObject.className(); data->childClassName = QString::fromUtf8(T::staticMetaObject.className());
} }
template<class T> template<class T>
Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Table *parent) : TableSetBase(parent) Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Table *parent) : TableSetBase(parent)
{ {
data->childClassName = T::staticMetaObject.className(); data->childClassName = QString::fromUtf8(T::staticMetaObject.className());
} }
template<class T> template<class T>

4
src/nut/tablesetbase.cpp
View File

@ -50,13 +50,13 @@ int TableSetBase::save(Database *db, bool cleanUp)
int rowsAffected = 0; int rowsAffected = 0;
TableModel *masterModel = nullptr; TableModel *masterModel = nullptr;
if (data->table) if (data->table)
masterModel = db->model().tableByClassName(data->table->metaObject()->className()); masterModel = db->model().tableByClassName(QString::fromUtf8(data->table->metaObject()->className()));
foreach (Row<Table> t, data->childs) { foreach (Row<Table> t, data->childs) {
if (data->table) if (data->table)
t->setParentTable(data->table, t->setParentTable(data->table,
masterModel, masterModel,
db->model().tableByClassName(t->metaObject()->className())); db->model().tableByClassName(QString::fromUtf8(t->metaObject()->className())));
if (t->status() == Table::Added if (t->status() == Table::Added
|| t->status() == Table::Modified || t->status() == Table::Modified