QuasarApp/Heart
4
1
Fork 0
mirror of https://github.com/QuasarApp/Heart.git synced 2025-04-27 10:14:36 +00:00
Code Issues Projects Releases Wiki Activity

dev 8

Browse Source
This commit is contained in:
Andrei Yankovich 2019-10-25 18:18:28 +03:00
parent 0742aa1901
commit dcee108c20
9 changed files with 137 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ClientProtocol/dbobject.cpp
View File

@ -28,20 +28,20 @@ bool DBObject::getSaveQueryString(QSqlQuery *query) const {
bool DBObject::getSelectQueryString(QSqlQuery *query) const {
if (_dbId < 0) {
if (_id < 0) {
return false;
}
QString queryString = "SELECT (%1) from %0 where id=" + QString::number(_dbId);
QString queryString = "SELECT (%1) from %0 where id=" + QString::number(_id);
return getBaseQueryString(queryString, query);
}
bool DBObject::getDeleteQueryString(QSqlQuery *query) const {
if (_dbId < 0) {
if (_id < 0) {
return false;
}
QString queryString = "DELETE FROM %0 where id=" + QString::number(_dbId);
QString queryString = "DELETE FROM %0 where id=" + QString::number(_id);
return getBaseQueryString(queryString, query);
}
@ -145,6 +145,16 @@ QDataStream &DBObject::toStream(QDataStream &stream) const {
return stream;
}
QVariantMap &DBObject::fromVariantMap(QVariantMap &map) {
_dataTable = map;
return map;
}
QVariantMap &DBObject::toVariantmap(QVariantMap &map) const {
map = _dataTable;
return map;
}
int DBObject::getId() const {
return _id;
}

3
ClientProtocol/dbobject.h
View File

@ -88,13 +88,14 @@ protected:
QVariantMap _dataTable;
IDbTable * _tableStruct = nullptr;
int _dbId = -1;
int _id = -1;
//// StreamBase interface
QDataStream &fromStream(QDataStream &stream) override;
QDataStream &toStream(QDataStream &stream) const override;
QVariantMap &fromVariantMap(QVariantMap &map) override;
QVariantMap &toVariantmap(QVariantMap &map) const override;
};
}

97
ClientProtocol/dbtablebase.cpp
View File

@ -12,35 +12,35 @@ QString DbTableBase::name() const {
return _name;
}
QString DbTableBase::toStringQuery() const {
QString table = "CREATE TABLE IF NOT EXISTS" + _name + "(%0);";
QString columns = " id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,";
columns += " updateTime DATETIME NOT NULL DEFAULT NOW(),";
//QString DbTableBase::toStringQuery() const {
// QString table = "CREATE TABLE IF NOT EXISTS" + _name + "(%0);";
// QString columns = " id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,";
// columns += " updateTime DATETIME NOT NULL DEFAULT NOW(),";
for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
columns += it.key();
// for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
// columns += it.key();
auto val = it.value().toString();
// auto val = it.value().toString();
if (val.isEmpty()) {
columns += "BLOB";
} else {
columns += val;
}
// if (val.isEmpty()) {
// columns += "BLOB";
// } else {
// columns += val;
// }
columns += ',';
// columns += ',';
}
// }
for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) {
QString dep = " FOREIGN KEY(_group) REFERENCES groups(id)
columns += " FOREIGN KEY(_group) REFERENCES groups(id)"
ON UPDATE CASCADE
ON DELETE CASCADE,"
}
// for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) {
// QString dep = " FOREIGN KEY(_group) REFERENCES groups(id)
// columns += " FOREIGN KEY(_group) REFERENCES groups(id)"
// ON UPDATE CASCADE
// ON DELETE CASCADE,"
// }
return table.arg(columns);
}
// return table.arg(columns);
//}
QHash<QString, QVariant::Type> DbTableBase::keys() const {
return _keys;
@ -54,57 +54,8 @@ DbTableBase::~DbTableBase() {
}
QVariantMap DbTableBase::tableMap() const {
return _tableMap;
void DbTableBase::setKeys(const QHash<QString, QVariant::Type> &keys) {
_keys = keys;
}
void DbTableBase::setTableMap(const QVariantMap &tableMap) {
_tableMap = tableMap;
for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
_keys[it.key()] = getType(it.value().toString());
}
}
QHash<QString, QString> DbTableBase::dependencies() const {
return _dependencies;
}
void DbTableBase::setDependencies(const QHash<QString, QString> &dependencies) {
_dependencies = dependencies;
}
#define c(x) str.contains(x, Qt::CaseInsensitive)
QVariant::Type DbTableBase::getType(const QString &str) {
if (str.isEmpty() || c(" BINARY") || c(" BLOB") || c(" TINYBLOB") || c(" MEDIUMBLOB") || c(" LONGBLOB")) {
return QVariant::ByteArray;
} else if (c(" INT")) {
return QVariant::Int;
} else if (c(" VARCHAR") || c(" TEXT") || c(" TINYTEXT") || c(" MEDIUMTEXT") || c(" LONGTEXT")) {
return QVariant::String;
} else if (c(" FLOAT") || c(" DOUBLE") || c(" REAL")) {
return QVariant::Double;
} else if (c(" BOOL")) {
return QVariant::Bool;
} else if (c(" DATETIME")) {
return QVariant::DateTime;
} else if (c(" DATE")) {
return QVariant::Date;
} else if (c(" TIME")) {
return QVariant::Time;
}
return QVariant::ByteArray;
}
bool DbTableBase::addDependecies(const IDbTable *table, const QString &val) {
if (table->keys().contains(val)) {
_dependencies[table->name()] = val;
return true;
}
return false;
}
}

37
ClientProtocol/dbtablebase.h
View File

@ -20,56 +20,25 @@ public:
// IDbTable interface:
QString name() const override;
QString toStringQuery() const override;
QHash<QString, QVariant::Type> keys() const override;
void setKeys(const QHash<QString, QVariant::Type> &keys) override;
QString lastIdQuery() const override;
~DbTableBase() override;
/**
* @brief tableMap
* @return
*/
QVariantMap tableMap() const;
/**
* @brief setTableMap
* @param tableMap
*/
void setTableMap(const QVariantMap &tableMap);
void setTableMap(const QHash<QString, QVariant::Type> &);
/**
* @brief dependencies
* @return
*/
QHash<QString, QString> dependencies() const;
protected:
/**
* @brief setDependencies
* @param dependencies
*/
void setDependencies(const QHash<QString, QString> &dependencies);
/**
* @brief addDependecies
* @param table
* @param val
* @return
*/
bool addDependecies(const IDbTable* table, const QString &val);
QString _name;
QVariantMap _tableMap;
QHash<QString, QString> _dependencies;
private:
/**
* @brief getType
* @param str
* @return
*/
QVariant::Type getType(const QString& str);
QHash<QString, QVariant::Type> _keys;
};

5
ClientProtocol/idbtable.cpp
View File

@ -1 +1,6 @@
#include "idbtable.h"
ClientProtocol::IDbTable::IDbTable()
{
}

14
ClientProtocol/idbtable.h
View File

@ -24,26 +24,28 @@ public:
*/
virtual QString name() const = 0;
/**
* @brief toStringQuery
* @return
*/
virtual QString toStringQuery() const = 0;
/**
* @brief keys
* @return
*/
virtual QHash<QString, QVariant::Type> keys() const = 0;
/**
* @brief setKeys
* @param keys
*/
virtual void setKeys(const QHash<QString, QVariant::Type> &keys) = 0;
/**
* @brief lastId
* @return query for get last id of table in db
*/
virtual QString lastIdQuery() const = 0;
virtual ~IDbTable() = 0;
};
}
#endif // IDBTABLE_H

49
ClientProtocol/sqldbwriter.cpp
View File

@ -23,16 +23,24 @@ bool SqlDBWriter::exec(QSqlQuery *sq,const QString& sqlFile) {
stream.setCodec("UTF8");
while(!stream.atEnd()) {
temp += stream.readLine();
if (temp.lastIndexOf("delimiter", -1, Qt::CaseInsensitive) > -1) {
temp.remove("delimiter", Qt::CaseInsensitive);
int last = temp.indexOf(QRegularExpression("[^ \f\n\r\t\v]")) + 1;
int begin = temp.lastIndexOf(QRegularExpression("[^ \f\n\r\t\v]"));
delimiter = temp.mid(begin, last - begin);
temp = "";
} else {
if (temp.lastIndexOf(delimiter) >- 1) {
temp.remove(delimiter);
result = result && sq->exec(temp);
if (!result) {
@ -41,6 +49,18 @@ bool SqlDBWriter::exec(QSqlQuery *sq,const QString& sqlFile) {
return false;
}
if (temp.contains("CREATE TABLE ", Qt::CaseInsensitive)) {
int tableBegin = temp.indexOf('(');
int tableEnd = temp.indexOf(')');
QStringList columns = temp.mid(tableBegin, tableEnd - tableBegin).split(',');
for (QString & col : columns) {
getType(col);
}
}
temp = "";
}
}
@ -105,6 +125,11 @@ QVariantMap SqlDBWriter::defaultInitPararm() const {
return params;
}
QHash<QString, IDbTable *> SqlDBWriter::getDbStruct() const
{
return _dbStruct;
}
SqlDBWriter::SqlDBWriter() {
}
@ -173,4 +198,28 @@ SqlDBWriter::~SqlDBWriter() {
}
#define c(x) str.contains(x, Qt::CaseInsensitive)
QVariant::Type SqlDBWriter::getType(const QString &str) {
if (str.isEmpty() || c(" BINARY") || c(" BLOB") || c(" TINYBLOB") || c(" MEDIUMBLOB") || c(" LONGBLOB")) {
return QVariant::ByteArray;
} else if (c(" INT")) {
return QVariant::Int;
} else if (c(" VARCHAR") || c(" TEXT") || c(" TINYTEXT") || c(" MEDIUMTEXT") || c(" LONGTEXT")) {
return QVariant::String;
} else if (c(" FLOAT") || c(" DOUBLE") || c(" REAL")) {
return QVariant::Double;
} else if (c(" BOOL")) {
return QVariant::Bool;
} else if (c(" DATETIME")) {
return QVariant::DateTime;
} else if (c(" DATE")) {
return QVariant::Date;
} else if (c(" TIME")) {
return QVariant::Time;
}
return QVariant::ByteArray;
}
}

17
ClientProtocol/sqldbwriter.h
View File

@ -7,6 +7,7 @@
#include <QSqlQuery>
#include "clientprotocol_global.h"
#include "config.h"
#include <QVariant>
class QSqlQuery;
class QSqlDatabase;
@ -15,6 +16,8 @@ class PlayerDBData;
namespace ClientProtocol {
class IDbTable;
/**
* @brief The SqlDBWriter class
*/
@ -27,6 +30,12 @@ private:
protected:
/**
* @brief getDbStruct
* @return structure of the data base
*/
QHash<QString, IDbTable*> getDbStruct() const;
/**
* @brief enableFK - enavle forign ke for sqlite db
* @return return true if all good
@ -64,8 +73,16 @@ protected:
*/
virtual QVariantMap defaultInitPararm() const;
/**
* @brief getType
* @param str
* @return
*/
virtual QVariant::Type getType(const QString& str);
QSqlQuery query;
QSqlDatabase db;
QHash<QString, IDbTable *> _dbStruct;
public:

16
ClientProtocol/streambase.h
View File

@ -4,7 +4,7 @@
#include <QByteArray>
#include "clientprotocol_global.h"
class QVariantMap;
class QDataStream;
namespace ClientProtocol {
@ -42,6 +42,20 @@ public:
*/
virtual QDataStream& toStream(QDataStream& stream) const = 0;
/**
* @brief fromVariantMap
* @param map
* @return
*/
virtual QVariantMap& fromVariantMap(QVariantMap& map) = 0;
/**
* @brief toVariantmap
* @param map
* @return
*/
virtual QVariantMap& toVariantmap(QVariantMap& map) const = 0;
};
}
#endif // STREAMBASE_H