471 lines
12 KiB
C++
471 lines
12 KiB
C++
/**************************************************************************
|
|
**
|
|
** This file is part of Nut project.
|
|
** https://github.com/HamedMasafi/Nut
|
|
**
|
|
** Nut is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU Lesser General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** Nut is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU Lesser General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU Lesser General Public License
|
|
** along with Nut. If not, see <http://www.gnu.org/licenses/>.
|
|
**
|
|
**************************************************************************/
|
|
|
|
#include <QtCore/QMetaObject>
|
|
#include <QtCore/QMetaProperty>
|
|
#include <QtCore/QDebug>
|
|
|
|
#include <QJsonArray>
|
|
#include <QJsonObject>
|
|
|
|
#include "tablemodel.h"
|
|
#include "defines.h"
|
|
|
|
NUT_BEGIN_NAMESPACE
|
|
|
|
/*
|
|
* TODO: It may be good idea if we replace this QSet with two QHash!
|
|
* one for className search and another for typeId.
|
|
*/
|
|
QSet<TableModel*> TableModel::_allModels;
|
|
|
|
QString TableModel::name() const
|
|
{
|
|
return _name;
|
|
}
|
|
|
|
void TableModel::setName(const QString &name)
|
|
{
|
|
_name = name;
|
|
}
|
|
|
|
QString TableModel::className() const
|
|
{
|
|
return _className;
|
|
}
|
|
|
|
void TableModel::setClassName(const QString &className)
|
|
{
|
|
_className = className;
|
|
}
|
|
|
|
int TableModel::typeId() const
|
|
{
|
|
return _typeId;
|
|
}
|
|
|
|
void TableModel::setTypeId(const int &typeId)
|
|
{
|
|
_typeId = typeId;
|
|
}
|
|
|
|
FieldModel *TableModel::field(int n) const
|
|
{
|
|
if (n < 0 || n >= _fields.count())
|
|
return nullptr;
|
|
|
|
return _fields.at(n);
|
|
}
|
|
|
|
FieldModel *TableModel::field(const QString &name) const
|
|
{
|
|
foreach (FieldModel *f, _fields)
|
|
if(f->name == name)
|
|
return f;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
QList<FieldModel *> TableModel::fields() const
|
|
{
|
|
return _fields;
|
|
}
|
|
|
|
QList<RelationModel *> TableModel::foregionKeys() const
|
|
{
|
|
return _foreignKeys;
|
|
}
|
|
|
|
QStringList TableModel::fieldsNames() const
|
|
{
|
|
QStringList ret;
|
|
foreach (FieldModel *f, _fields)
|
|
ret.append(f->name);
|
|
return ret;
|
|
}
|
|
|
|
QSet<TableModel *> TableModel::allModels()
|
|
{
|
|
return _allModels;
|
|
}
|
|
|
|
/*
|
|
* This is not used anywhere
|
|
*/
|
|
TableModel *TableModel::findByTypeId(int typeId)
|
|
{
|
|
foreach (TableModel *model, _allModels)
|
|
if(model->typeId() == typeId)
|
|
return model;
|
|
return nullptr;
|
|
}
|
|
|
|
/**
|
|
* @brief TableModel::findByClassName
|
|
* Find a table model by class name
|
|
* @param className
|
|
* @return
|
|
*/
|
|
TableModel *TableModel::findByClassName(const QString &className)
|
|
{
|
|
foreach (TableModel *model, _allModels){
|
|
if(model->className() == className)
|
|
return model;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool TableModel::operator ==(const TableModel &t) const{
|
|
if(_name != t.name())
|
|
return false;
|
|
|
|
if(fields().count() != t.fields().count())
|
|
return false;
|
|
|
|
foreach (FieldModel *f, _fields) {
|
|
FieldModel *tf = t.field(f->name);
|
|
if(!tf)
|
|
return false;
|
|
|
|
if(*f != *tf)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TableModel::operator !=(const TableModel &t) const
|
|
{
|
|
return !(*this == t);
|
|
}
|
|
|
|
//bool TableModel::checkClassInfo(const QMetaClassInfo &classInfo,
|
|
// QString &type, QString &name, QString &value)
|
|
//{
|
|
// if (!QString(classInfo.name()).startsWith(__nut_NAME_PERFIX)) {
|
|
// return false;
|
|
// } else {
|
|
// QStringList parts = QString(classInfo.value()).split("\n");
|
|
// if (parts.count() != 3)
|
|
// return false;
|
|
|
|
// type = parts[0];
|
|
// name = parts[1];
|
|
// value = parts[2];
|
|
// return true;
|
|
// }
|
|
//}
|
|
|
|
TableModel::TableModel(int typeId, const QString &tableName)
|
|
{
|
|
//TODO: check that
|
|
// if (findByTypeId(typeId))
|
|
// return;
|
|
|
|
const QMetaObject *tableMetaObject = QMetaType::metaObjectForType(typeId);
|
|
|
|
_typeId = typeId;
|
|
_name = tableName;
|
|
_className = tableMetaObject->className();
|
|
|
|
//#ifdef NUT_NAMESPACE
|
|
// if(_className.startsWith(QT_STRINGIFY(NUT_NAMESPACE) "::"))
|
|
// _className = _className.replace(QT_STRINGIFY(NUT_NAMESPACE) "::", "");
|
|
//#endif
|
|
|
|
// get fields names
|
|
for(int j = 0; j < tableMetaObject->classInfoCount(); j++){
|
|
QString type;
|
|
QString name;
|
|
QString value;
|
|
|
|
if (!nutClassInfoString(tableMetaObject->classInfo(j),
|
|
type, name, value)) {
|
|
continue;
|
|
}
|
|
|
|
if(type == __nut_FIELD){
|
|
auto *f = new FieldModel;
|
|
f->name = f->displayName = name;
|
|
_fields.append(f);
|
|
}
|
|
}
|
|
// Browse all fields
|
|
for(int j = 1; j < tableMetaObject->propertyCount(); j++){
|
|
QMetaProperty fieldProperty = tableMetaObject->property(j);
|
|
|
|
FieldModel *fieldObj = field(fieldProperty.name());
|
|
foreach (FieldModel *f, _fields)
|
|
if(f->name == fieldProperty.name())
|
|
f = fieldObj;
|
|
if(!fieldObj)
|
|
continue;
|
|
fieldObj->type = static_cast<QMetaType::Type>(fieldProperty.type());
|
|
fieldObj->typeName = QString(fieldProperty.typeName());
|
|
}
|
|
|
|
// Browse class infos
|
|
for(int j = 0; j < tableMetaObject->classInfoCount(); j++){
|
|
QString type;
|
|
QString name;
|
|
QString value;
|
|
|
|
if (!nutClassInfoString(tableMetaObject->classInfo(j),
|
|
type, name, value)) {
|
|
continue;
|
|
}
|
|
|
|
if(type == __nut_FOREGION_KEY){
|
|
auto *fk = new RelationModel;
|
|
fk->slaveTable = this;
|
|
fk->localColumn = name + "Id";
|
|
fk->localProperty = name;
|
|
fk->foreignColumn = value;
|
|
fk->masterClassName = value;
|
|
_foreignKeys.append(fk);
|
|
}
|
|
|
|
if(type == __nut_FIELD){
|
|
|
|
}
|
|
|
|
|
|
FieldModel *f = field(name);
|
|
if (!f)
|
|
continue;
|
|
|
|
if (type == __nut_LEN)
|
|
f->length = value.toInt();
|
|
else if (type == __nut_NOT_NULL)
|
|
f->notNull = true;
|
|
else if (type == __nut_DEFAULT_VALUE)
|
|
f->defaultValue = value;
|
|
else if (type == __nut_PRIMARY_KEY)
|
|
f->isPrimaryKey = true;
|
|
else if (type == __nut_AUTO_INCREMENT)
|
|
f->isAutoIncrement = true;
|
|
else if (type == __nut_UNIQUE)
|
|
f->isUnique = true;
|
|
else if (type == __nut_DISPLAY)
|
|
f->displayName = value.mid(1, value.length() - 2);
|
|
else if (type == __nut_PRIMARY_KEY_AI) {
|
|
f->isPrimaryKey = true;
|
|
f->isAutoIncrement = true;
|
|
}
|
|
}
|
|
|
|
if(!findByTypeId(typeId) && !tableName.isNull())
|
|
_allModels.insert(this);
|
|
}
|
|
|
|
/*
|
|
"comment": {
|
|
"auto_increment": "id",
|
|
"fields": {
|
|
"id": {
|
|
"name": "id",
|
|
"type": "int"
|
|
},
|
|
"userId": {
|
|
"name": "userId",
|
|
"type": "int"
|
|
}
|
|
},
|
|
"primary_key": "id"
|
|
},
|
|
*/
|
|
TableModel::TableModel(const QJsonObject &json, const QString &tableName) : _typeId(0)
|
|
{
|
|
_name = tableName;
|
|
|
|
QJsonObject fields = json.value(__FIELDS).toObject();
|
|
QJsonObject relations = json.value(__FOREIGN_KEYS).toObject();
|
|
foreach (QString key, fields.keys()) {
|
|
QJsonObject fieldObject = fields.value(key).toObject();
|
|
auto *f = new FieldModel;
|
|
f->name = fieldObject.value(__NAME).toString();
|
|
f->type = static_cast<QMetaType::Type>(QMetaType::type(fieldObject.value(__TYPE).toString().toLatin1().data()));
|
|
f->typeName = QMetaType::typeName(f->type);
|
|
|
|
if(fieldObject.contains(__nut_NOT_NULL))
|
|
f->notNull = fieldObject.value(__nut_NOT_NULL).toBool();
|
|
|
|
if(fieldObject.contains(__nut_LEN))
|
|
f->length = fieldObject.value(__nut_LEN).toInt();
|
|
|
|
if(fieldObject.contains(__nut_DEFAULT_VALUE))
|
|
f->defaultValue = fieldObject.value(__nut_DEFAULT_VALUE).toString();
|
|
_fields.append(f);
|
|
}
|
|
|
|
foreach (QString key, relations.keys()) {
|
|
QJsonObject relObject = fields.value(key).toObject();
|
|
_foreignKeys.append(new RelationModel(relObject));
|
|
}
|
|
|
|
// if(json.keys().contains(__nut_AUTO_INCREMENT))
|
|
// field(json.value(__nut_AUTO_INCREMENT).toString())->isAutoIncrement = true;
|
|
|
|
// if(json.keys().contains(__nut_PRIMARY_KEY))
|
|
// field(json.value(__nut_PRIMARY_KEY).toString())->isAutoIncrement = true;
|
|
|
|
_allModels.insert(this);
|
|
}
|
|
|
|
TableModel::~TableModel()
|
|
{
|
|
qDeleteAll(_fields);
|
|
qDeleteAll(_foreignKeys);
|
|
}
|
|
|
|
QJsonObject TableModel::toJson() const
|
|
{
|
|
QJsonObject obj;
|
|
QJsonObject fieldsObj;
|
|
QJsonObject foreignKeysObj;
|
|
|
|
foreach (FieldModel *f, _fields) {
|
|
QJsonObject fieldObj;
|
|
fieldObj.insert(__NAME, f->name);
|
|
fieldObj.insert(__TYPE, QString(QVariant::typeToName(f->type)));
|
|
|
|
if(f->length)
|
|
fieldObj.insert(__nut_LEN, f->length);
|
|
|
|
if(f->notNull)
|
|
fieldObj.insert(__nut_NOT_NULL, f->notNull);
|
|
|
|
if(!f->defaultValue.isNull())
|
|
fieldObj.insert(__nut_DEFAULT_VALUE, f->defaultValue);
|
|
|
|
if(f->isAutoIncrement)
|
|
obj.insert(__nut_AUTO_INCREMENT, f->name);
|
|
|
|
if(f->isPrimaryKey)
|
|
obj.insert(__nut_PRIMARY_KEY, f->name);
|
|
|
|
fieldsObj.insert(f->name, fieldObj);
|
|
}
|
|
foreach (RelationModel *rel, _foreignKeys)
|
|
foreignKeysObj.insert(rel->localColumn, rel->toJson());
|
|
|
|
obj.insert(__FIELDS, fieldsObj);
|
|
obj.insert(__FOREIGN_KEYS, foreignKeysObj);
|
|
|
|
return obj;
|
|
}
|
|
|
|
RelationModel *TableModel::foregionKey(const QString &otherTable) const
|
|
{
|
|
foreach (RelationModel *fk, _foreignKeys)
|
|
if(fk->masterClassName == otherTable)
|
|
return fk;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
RelationModel *TableModel::foregionKeyByField(const QString &fieldName) const
|
|
{
|
|
foreach (RelationModel *fk, _foreignKeys)
|
|
if(fk->localColumn == fieldName)
|
|
return fk;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
QString TableModel::toString() const
|
|
{
|
|
QStringList sl;
|
|
foreach (FieldModel *f, _fields)
|
|
sl.append(f->name + " " + QVariant::typeToName(f->type));
|
|
|
|
QString ret = QString("%1 (%2)")
|
|
.arg(_name, sl.join(", "));
|
|
return ret;
|
|
}
|
|
|
|
QString TableModel::primaryKey() const
|
|
{
|
|
foreach (FieldModel *f, _fields)
|
|
if(f->isPrimaryKey)
|
|
return f->name;
|
|
return QString();
|
|
}
|
|
|
|
FieldModel::FieldModel(const QJsonObject &json)
|
|
{
|
|
name = json.value(__NAME).toString();
|
|
type = static_cast<QMetaType::Type>(json.value(__TYPE).toInt());
|
|
length = json.value(__nut_LEN).toInt();
|
|
notNull = json.value(__nut_NOT_NULL).toBool();
|
|
isAutoIncrement = json.value(__nut_AUTO_INCREMENT).toBool();
|
|
isPrimaryKey = json.value(__nut_PRIMARY_KEY).toBool();
|
|
defaultValue = json.value(__nut_DEFAULT_VALUE).toString();
|
|
isUnique = json.value(__nut_UNIQUE).toBool();
|
|
}
|
|
|
|
QJsonObject FieldModel::toJson() const
|
|
{
|
|
QJsonObject fieldObj;
|
|
fieldObj.insert(__NAME, name);
|
|
fieldObj.insert(__TYPE, QString(QVariant::typeToName(type)));
|
|
fieldObj.insert(__nut_LEN, length);
|
|
fieldObj.insert(__nut_NOT_NULL, notNull);
|
|
fieldObj.insert(__nut_AUTO_INCREMENT, isAutoIncrement);
|
|
fieldObj.insert(__nut_PRIMARY_KEY, isPrimaryKey);
|
|
fieldObj.insert(__nut_DEFAULT_VALUE, defaultValue);
|
|
return fieldObj;
|
|
}
|
|
|
|
RelationModel::RelationModel(const QJsonObject &obj)
|
|
{
|
|
localColumn = obj.value("localColumn").toString();
|
|
localProperty = obj.value("localProperty").toString();
|
|
masterClassName = obj.value("masterClassName").toString();
|
|
foreignColumn = obj.value("foreignColumn").toString();
|
|
slaveTable = masterTable = nullptr;
|
|
}
|
|
|
|
QJsonObject RelationModel::toJson() const
|
|
{
|
|
QJsonObject o;
|
|
o.insert("localColumn", localColumn);
|
|
o.insert("localProperty", localProperty);
|
|
o.insert("masterClassName", masterClassName);
|
|
o.insert("foreignColumn", foreignColumn);
|
|
return o;
|
|
}
|
|
|
|
bool operator ==(const RelationModel &l, const RelationModel &r)
|
|
{
|
|
return r.foreignColumn == l.foreignColumn
|
|
&& r.localColumn == l.localColumn
|
|
&& r.localProperty == l.localColumn
|
|
&& r.masterClassName == l.masterClassName;
|
|
}
|
|
|
|
bool operator !=(const RelationModel &l, const RelationModel &r)
|
|
{
|
|
return !(l == r);
|
|
}
|
|
|
|
NUT_END_NAMESPACE
|