Revision b0bf458e
Von Christian Ehringfeld vor mehr als 9 Jahren hinzugefügt
| EntityManager.pro | ||
|---|---|---|
|
src/tableschema.h \
|
||
|
src/schema/pgsqlschema.h \
|
||
|
src/schema/mysqlschema.h \
|
||
|
src/databasemigration.h \
|
||
|
src/querybuilder.h \
|
||
|
src/databasemigration.h
|
||
|
src/schema/sqlitequerybuilder.h
|
||
|
|
||
|
SOURCES += \
|
||
|
src/entity.cpp \
|
||
| ... | ... | |
|
src/tableschema.cpp \
|
||
|
src/schema/pgsqlschema.cpp \
|
||
|
src/schema/mysqlschema.cpp \
|
||
|
src/databasemigration.cpp \
|
||
|
src/querybuilder.cpp \
|
||
|
src/databasemigration.cpp
|
||
|
src/schema/sqlitequerybuilder.cpp
|
||
|
|
||
|
unix {
|
||
|
target.path = /usr/lib
|
||
| src/entitymanager.cpp | ||
|---|---|---|
|
|
||
|
#include "entitymanager.h"
|
||
|
#include "enums/databasetype.h"
|
||
|
#include <QMetaObject>
|
||
|
#include <QMetaProperty>
|
||
|
using namespace CuteEntityManager;
|
||
|
/**
|
||
|
* Relationen fehlen noch
|
||
| ... | ... | |
|
auto schema = CuteEntityManager::getSchema(CuteEntityManager::getDatabaseType(
|
||
|
this->db.data()->getDatabase().driverName()), this->db);
|
||
|
this->schema = QSharedPointer<Schema>(schema);
|
||
|
this->schema.data()->setTables(this->schema.data()->getTableSchemas());
|
||
|
}
|
||
|
|
||
|
EntityManager::EntityManager(QSqlDatabase database) {
|
||
| ... | ... | |
|
this->init();
|
||
|
}
|
||
|
|
||
|
//inline bool EntityManager::checkTable(Entity *entity) {
|
||
|
// bool rc = true;
|
||
|
// if (!this->db->containsTable(entity->getTablename())) {
|
||
|
// qDebug() << "Tabelle" << entity->getTablename() << "existiert noch nicht.";
|
||
|
// if (this->createTable(entity)) {
|
||
|
// this->db->refreshTableList();
|
||
|
// rc = this->db->containsTable(entity->getTablename());
|
||
|
// }
|
||
|
// }
|
||
|
// return rc;
|
||
|
//}
|
||
|
bool EntityManager::checkTable(const QSharedPointer<Entity> &entity) {
|
||
|
bool rc = true;
|
||
|
if (!this->schema.data()->containsTable(entity.data()->getTablename())) {
|
||
|
if (this->schema.data()->getQueryBuilder().data()->createTable(entity)) {
|
||
|
this->schema.data()->getTableSchema(entity.data()->getTablename(), true);
|
||
|
rc = this->schema.data()->getTables().contains(entity.data()->getTablename());
|
||
|
}
|
||
|
}
|
||
|
return rc;
|
||
|
}
|
||
|
|
||
|
QSharedPointer<Database> EntityManager::getDb() const {
|
||
|
return db;
|
||
| ... | ... | |
|
schema = value;
|
||
|
}
|
||
|
|
||
|
QHash<QString, QVariant> EntityManager::getEntityAttributes(const QSharedPointer<Entity> &entity) {
|
||
|
Entity *e = entity.data();
|
||
|
auto map = QHash<QString, QVariant>();
|
||
|
auto metaObject = e->metaObject();
|
||
|
auto transientAttrs = e->getTransientAttributes();
|
||
|
for (int var = 0; var < metaObject->propertyCount(); ++var) {
|
||
|
auto p = metaObject->property(var);
|
||
|
QString name = QString(p.name());
|
||
|
if (p.isValid() && !transientAttrs.contains(name)) {
|
||
|
QVariant v = p.read(e);
|
||
|
//Relation
|
||
|
if (v.canConvert<Entity *>()) {
|
||
|
this->insertRelationId(qvariant_cast<Entity *>(v),map,name);
|
||
|
} else if (v.canConvert<QSharedPointer<Entity>>()) {
|
||
|
this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(),map,name);
|
||
|
} else if (QString(p.typeName()).contains("QList")) {
|
||
|
/**
|
||
|
@TODO
|
||
|
//List and/or ManyToManyRelation
|
||
|
*/
|
||
|
auto n = static_cast<QList<CuteEntityManager::Entity *>*>(v.data());
|
||
|
for (int var = 0; var < n->size(); ++var) {
|
||
|
CuteEntityManager::Entity *entity = n->at(var);
|
||
|
qDebug() << entity->toString();
|
||
|
}
|
||
|
} else {
|
||
|
map.insert(name, v);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return map;
|
||
|
}
|
||
|
|
||
|
void EntityManager::insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) {
|
||
|
if (e && e->getId() > -1) {
|
||
|
map.insert(relName + "_id", e->getId());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
QString EntityManager::createConnection() {
|
||
|
QStringList l = EntityManager::getConnectionNames();
|
||
|
QString conName = "";
|
||
| ... | ... | |
|
return rc;
|
||
|
}
|
||
|
|
||
|
//QString EntityManager::createTableQuery(QSharedPointer<Entity> entity) {
|
||
|
// QChar c = this->db->escapeChar();
|
||
|
// QHash<QString, QString> m = entity->getProperties(this->db->getDatabaseType());
|
||
|
// bool first = true;
|
||
|
// QString s = "CREATE TABLE IF NOT EXISTS ";
|
||
|
// s.append(c).append(entity->getTablename()).append(c).append("(");
|
||
|
// QHash<QString, QString>::const_iterator i = m.constBegin();
|
||
|
// while (i != m.constEnd()) {
|
||
|
// if (first) {
|
||
|
// first = false;
|
||
|
// } else {
|
||
|
// s.append(',');
|
||
|
// }
|
||
|
// s.append(c).append(i.key()).append(c).append(" " + i.value());
|
||
|
// ++i;
|
||
|
// }
|
||
|
// s.append(");");
|
||
|
// return s;
|
||
|
//}
|
||
|
|
||
|
//bool EntityManager::createTable(Entity *entity) {
|
||
|
// bool rc = false;
|
||
|
// this->db->containsTable(entity->getTablename()) ? rc = true : rc = false;
|
||
|
// if (!rc) {
|
||
|
// QSqlQuery q = this->db->getQuery(this->createTableQuery(entity));
|
||
|
// if (this->db->transaction(q)) {
|
||
|
// this->db->refreshTableList();
|
||
|
// rc = true;
|
||
|
// }
|
||
|
// }
|
||
|
// return rc;
|
||
|
|
||
|
//}
|
||
|
|
||
|
void EntityManager::setConnectionNames(QStringList list) {
|
||
|
EntityManager::connectionNames = list;
|
||
|
}
|
||
| src/entitymanager.h | ||
|---|---|---|
|
void init();
|
||
|
QString where(const QSharedPointer<Entity> &entity, QString conjunction = ",", bool ignoreID = false);
|
||
|
QString where(const QHash<QString, QVariant> &m, const QString &conjunction = ",", bool ignoreID = false);
|
||
|
void insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName);
|
||
|
|
||
|
public:
|
||
|
EntityManager(QSqlDatabase database);
|
||
| ... | ... | |
|
void setDb(const QSharedPointer<Database> &value);
|
||
|
QSharedPointer<Schema> getSchema() const;
|
||
|
void setSchema(const QSharedPointer<Schema> &value);
|
||
|
QHash<QString, QVariant> getEntityAttributes(const QSharedPointer<Entity> &entity);
|
||
|
|
||
|
};
|
||
|
}
|
||
| src/querybuilder.cpp | ||
|---|---|---|
|
#include "querybuilder.h"
|
||
|
#include "database.h"
|
||
|
#include <QMetaObject>
|
||
|
#include <QMetaProperty>
|
||
|
#include "entity.h"
|
||
|
using namespace CuteEntityManager;
|
||
|
|
||
|
QueryBuilder::QueryBuilder() {
|
||
|
//bool QueryBuilder::createTable(QString tablename, QHash<QString, QString> tableDefinition) {
|
||
|
//// QHash<QString, QString> Artikel::getProperties(DatabaseType type) {
|
||
|
//// QHash<QString, QString> h = QHash<QString, QString>();
|
||
|
//// h.insert("id",this->idColumnSQL());
|
||
|
//// h.insert("preis","DOUBLE");
|
||
|
//// h.insert("name","TEXT");
|
||
|
//// return h;
|
||
|
//// }
|
||
|
//}
|
||
|
|
||
|
QueryBuilder::QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database) {
|
||
|
this->schema = schema;
|
||
|
this->database = database;
|
||
|
}
|
||
|
|
||
|
QueryBuilder::~QueryBuilder() {
|
||
|
bool QueryBuilder::createTable(const QSharedPointer<Entity> &entity) const {
|
||
|
return this->createTable(entity.data()->getTablename(), this->generateTableDefinition(entity));
|
||
|
}
|
||
|
|
||
|
bool QueryBuilder::createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
|
||
|
bool rc = false;
|
||
|
this->schema.data()->containsTable(tableName) ? rc = true : rc = false;
|
||
|
if (!rc) {
|
||
|
QSqlQuery q = this->database.data()->getQuery(this->createTableQuery(tableName, tableDefinition));
|
||
|
if (this->database.data()->transaction(q)) {
|
||
|
this->schema.data()->getTableSchema(tableName);
|
||
|
rc = true;
|
||
|
}
|
||
|
}
|
||
|
return rc;
|
||
|
}
|
||
|
|
||
|
QString QueryBuilder::createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
|
||
|
bool first = true;
|
||
|
QString s = "CREATE TABLE ";
|
||
|
s.append(this->schema.data()->quoteTableName(tableName).append(" (\n"));
|
||
|
QHash<QString, QString>::const_iterator i = tableDefinition.constBegin();
|
||
|
while (i != tableDefinition.constEnd()) {
|
||
|
if (first) {
|
||
|
first = false;
|
||
|
} else {
|
||
|
s.append(',');
|
||
|
}
|
||
|
s.append(this->schema.data()->quoteColumnName(i.key())).append(" " + i.value());
|
||
|
++i;
|
||
|
}
|
||
|
s.append("\n);");
|
||
|
return s;
|
||
|
}
|
||
|
|
||
|
QSharedPointer<Database> QueryBuilder::getDatabase() const {
|
||
|
return database;
|
||
|
}
|
||
|
|
||
|
void QueryBuilder::setDatabase(const QSharedPointer<Database> &value) {
|
||
|
database = value;
|
||
|
}
|
||
|
|
||
|
bool QueryBuilder::createTable(QString tablename, QHash<QString, QString> tableDefinition) {
|
||
|
// QHash<QString, QString> Artikel::getProperties(DatabaseType type) {
|
||
|
// QHash<QString, QString> h = QHash<QString, QString>();
|
||
|
// h.insert("id",this->idColumnSQL());
|
||
|
// h.insert("preis","DOUBLE");
|
||
|
// h.insert("name","TEXT");
|
||
|
// return h;
|
||
|
// }
|
||
|
QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPointer<Entity> &entity) const {
|
||
|
auto map = QHash<QString, QString>();
|
||
|
auto o = entity.data()->metaObject();
|
||
|
for (int var = 0; var < o->propertyCount(); ++var) {
|
||
|
auto m = o->property(var);
|
||
|
if (m.isReadable() && !entity.data()->getTransientAttributes().contains(m.name())) {
|
||
|
m.typeName();
|
||
|
/**
|
||
|
@TODO
|
||
|
*/
|
||
|
}
|
||
|
}
|
||
|
return map;
|
||
|
}
|
||
|
|
||
|
QHash<QString, QVariant> QueryBuilder::getEntityAttributes(const QSharedPointer<Entity> &entity) {
|
||
|
Entity *e = entity.data();
|
||
|
auto map = QHash<QString, QVariant>();
|
||
|
auto metaObject = e->metaObject();
|
||
|
auto transientAttrs = e->getTransientAttributes();
|
||
|
for (int var = 0; var < metaObject->propertyCount(); ++var) {
|
||
|
auto p = metaObject->property(var);
|
||
|
QString name = QString(p.name());
|
||
|
if (p.isValid() && !transientAttrs.contains(name)) {
|
||
|
QVariant v = p.read(e);
|
||
|
//Relation
|
||
|
if (v.canConvert<Entity *>()) {
|
||
|
this->insertRelationId(qvariant_cast<Entity *>(v), map, name);
|
||
|
} else if (v.canConvert<QSharedPointer<Entity>>()) {
|
||
|
this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(), map, name);
|
||
|
} else if (QString(p.typeName()).contains("QList")) {
|
||
|
/**
|
||
|
@TODO
|
||
|
//List and/or ManyToManyRelation
|
||
|
*/
|
||
|
auto n = static_cast<QList<CuteEntityManager::Entity *>*>(v.data());
|
||
|
for (int var = 0; var < n->size(); ++var) {
|
||
|
CuteEntityManager::Entity *entity = n->at(var);
|
||
|
qDebug() << entity->toString();
|
||
|
}
|
||
|
} else {
|
||
|
map.insert(name, v);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return map;
|
||
|
}
|
||
|
|
||
|
void QueryBuilder::insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) {
|
||
|
if (e && e->getId() > -1) {
|
||
|
map.insert(relName + "_id", e->getId());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
QSharedPointer<Schema> QueryBuilder::getSchema() const {
|
||
|
return schema;
|
||
|
}
|
||
|
|
||
|
void QueryBuilder::setSchema(const QSharedPointer<Schema> &value) {
|
||
|
schema = value;
|
||
|
}
|
||
|
|
||
| src/querybuilder.h | ||
|---|---|---|
|
#ifndef QUERYBUILDER_H
|
||
|
#define QUERYBUILDER_H
|
||
|
#include "schema.h"
|
||
|
#include <QString>
|
||
|
#include <QHash>
|
||
|
#include <QSharedPointer>
|
||
|
namespace CuteEntityManager {
|
||
|
class Schema;
|
||
|
class Entity;
|
||
|
class Database;
|
||
|
class QueryBuilder {
|
||
|
public:
|
||
|
QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
|
||
|
virtual ~QueryBuilder();
|
||
|
virtual bool createTable(const QSharedPointer<Entity> &entity) const;
|
||
|
virtual bool createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
|
||
|
virtual QString createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
|
||
|
virtual bool renameTable(QString tableName, QString newName) const;
|
||
|
virtual bool dropTable(QString tableName) const;
|
||
|
virtual bool truncateTable(QString tableName) const;
|
||
|
virtual bool addColumn(QString tableName, QString columnName, QString columnType) const;
|
||
|
virtual QString dropColumn(QString tableName, QString columName)const;
|
||
|
virtual QString renameColumn(QString tableName, QString oldName, QString newName);
|
||
|
virtual QString alterColumn(QString tableName, QString columnName, QString newType)const;
|
||
|
virtual QString addPrimaryKey(QString name, QString tableName, QStringList columns)const;
|
||
|
virtual QString dropPrimaryKey(QString name, QString tableName) const;
|
||
|
virtual QString addForeignKey(QString name, QString tableName, QStringList columns, QString refTableName,
|
||
|
QStringList refColumns, QString deleteConstraint, QString updateConstraint);
|
||
|
virtual QString dropForeignKey(QString name, QString tableName) const;
|
||
|
virtual QString createIndex(QString name, QString tableName, QStringList columns, bool unique)const;
|
||
|
virtual QString dropIndex(QString name, QString tableName)const;
|
||
|
QHash<QString, QVariant> getEntityAttributes(const QSharedPointer<Entity> &entity);
|
||
|
QSharedPointer<Schema> getSchema() const;
|
||
|
void setSchema(const QSharedPointer<Schema> &value);
|
||
|
|
||
|
class QueryBuilder
|
||
|
{
|
||
|
public:
|
||
|
QueryBuilder();
|
||
|
~QueryBuilder();
|
||
|
bool createTable(QString tablename, QHash<QString, QString> tableDefinition);
|
||
|
QSharedPointer<Database> getDatabase() const;
|
||
|
void setDatabase(const QSharedPointer<Database> &value);
|
||
|
|
||
|
QHash<QString, QString> generateTableDefinition(const QSharedPointer<Entity> &entity) const;
|
||
|
|
||
|
|
||
|
protected:
|
||
|
void insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName);
|
||
|
|
||
|
|
||
|
QSharedPointer<Schema> schema;
|
||
|
QSharedPointer<Database> database;
|
||
|
};
|
||
|
}
|
||
|
|
||
|
#endif // QUERYBUILDER_H
|
||
| src/schema.cpp | ||
|---|---|---|
|
Schema::Schema(QSharedPointer<Database> database) {
|
||
|
this->database = database;
|
||
|
this->typeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
|
||
|
this->queryBuilder = QSharedPointer<QueryBuilder>();
|
||
|
}
|
||
|
|
||
|
Schema::~Schema() {
|
||
|
|
||
|
}
|
||
|
|
||
|
QHash<QString, QString> Schema::getAbstractDatabaseTypes() {
|
||
|
auto typeMap = QHash<QString, QString>();
|
||
|
typeMap.insert("bool", TYPE_SMALLINT);
|
||
|
typeMap.insert("short", TYPE_SMALLINT);
|
||
|
typeMap.insert("int", TYPE_INTEGER);
|
||
|
typeMap.insert("long", TYPE_INTEGER);
|
||
|
typeMap.insert("long long", TYPE_INTEGER);
|
||
|
typeMap.insert("float", TYPE_FLOAT);
|
||
|
typeMap.insert("double", TYPE_FLOAT);
|
||
|
typeMap.insert("long double", TYPE_FLOAT);
|
||
|
typeMap.insert("qint", TYPE_INTEGER);
|
||
|
typeMap.insert("quint", TYPE_INTEGER);
|
||
|
typeMap.insert("quuid", TYPE_INTEGER);
|
||
|
typeMap.insert("qfloat", TYPE_FLOAT);
|
||
|
typeMap.insert("unsigned short", TYPE_SMALLINT);
|
||
|
typeMap.insert("unsigned int", TYPE_INTEGER);
|
||
|
typeMap.insert("unsigned long", TYPE_INTEGER);
|
||
|
typeMap.insert("unsigned long long", TYPE_INTEGER);
|
||
|
typeMap.insert("char",TYPE_CHAR);
|
||
|
typeMap.insert("std::string", TYPE_TEXT);
|
||
|
typeMap.insert("QString", TYPE_TEXT);
|
||
|
typeMap.insert("QVariant", TYPE_TEXT);
|
||
|
typeMap.insert("QUuid", TYPE_TEXT);
|
||
|
typeMap.insert("QDate", TYPE_DATE);
|
||
|
typeMap.insert("QTime", TYPE_TIME);
|
||
|
typeMap.insert("QDateTime", TYPE_DATETIME);
|
||
|
typeMap.insert("QByteArray", TYPE_BINARY);
|
||
|
typeMap.insert("QBitArray", TYPE_BINARY);
|
||
|
return typeMap;
|
||
|
}
|
||
|
|
||
|
QString Schema::quoteSimpleTableName(QString name) {
|
||
|
return name.indexOf("`") ? name : "`" + name + "`";
|
||
|
}
|
||
| ... | ... | |
|
if (schema != "") {
|
||
|
name = schema + "." + names.at(i);
|
||
|
}
|
||
|
TableSchema *t = this->getTableSchema(name, refresh);
|
||
|
if (t) {
|
||
|
this->tables.insert(name, QSharedPointer<TableSchema>(t));
|
||
|
}
|
||
|
this->getTableSchema(name, refresh);
|
||
|
}
|
||
|
return this->tables;
|
||
|
}
|
||
| ... | ... | |
|
return this->tables.contains(tblname);
|
||
|
}
|
||
|
|
||
|
QString Schema::quoteValue(QString str) {
|
||
|
|
||
|
}
|
||
|
|
||
|
TableSchema *Schema::getTableSchema(QString name, bool refresh) {
|
||
|
QSharedPointer<TableSchema> Schema::getTableSchema(QString name, bool refresh) {
|
||
|
if (refresh) {
|
||
|
this->refresh();
|
||
|
}
|
||
|
if (this->tables.contains(name)) {
|
||
|
return this->tables.value(name).data();
|
||
|
return this->tables.value(name);
|
||
|
}
|
||
|
QString realName = this->getRawTable(name);
|
||
|
auto ts = this->loadTableSchema(realName);
|
||
|
if (ts.data()) {
|
||
|
this->tables.insert(name, ts);
|
||
|
}
|
||
|
return ts.data();
|
||
|
return ts;
|
||
|
}
|
||
|
|
||
|
QSharedPointer<Database> Schema::getDatabase() const {
|
||
| ... | ... | |
|
void Schema::setDatabase(const QSharedPointer<Database> &value) {
|
||
|
database = value;
|
||
|
}
|
||
|
QSharedPointer<QueryBuilder> Schema::getQueryBuilder() const {
|
||
|
return queryBuilder;
|
||
|
}
|
||
|
|
||
|
QHash<QString, QSharedPointer<TableSchema> > Schema::getTables() const {
|
||
|
return this->tables;
|
||
| src/schema.h | ||
|---|---|---|
|
#include <QHash>
|
||
|
#include <QSharedPointer>
|
||
|
#include <QSqlField>
|
||
|
#include "querybuilder.h"
|
||
|
namespace CuteEntityManager {
|
||
|
class Database;
|
||
|
class Schema {
|
||
| ... | ... | |
|
|
||
|
|
||
|
virtual QHash<QString, QString> *getTypeMap() = 0;
|
||
|
QHash<QString, QString> getAbstractDatabaseTypes();
|
||
|
virtual QString quoteSimpleTableName(QString name);
|
||
|
virtual QString quoteTableName(QString name);
|
||
|
virtual QString quoteColumnName(QString name);
|
||
|
virtual QString quoteSimpleColumnName(QString name);
|
||
|
virtual QHash<QString, QSharedPointer<TableSchema>> getTableSchemas(QString schema = "", bool refresh = false);
|
||
|
virtual QSharedPointer<TableSchema> getTableSchema(QString name, bool refresh = false);
|
||
|
virtual QStringList getTableNames(QString schema = "");
|
||
|
//virtual QueryBuilder getQueryBuilder();
|
||
|
//virtual QueryBuilder createQueryBuilder();
|
||
|
virtual QVariant getLastInsertID();
|
||
|
virtual void refresh();
|
||
|
virtual QString getRawTable(QString name);
|
||
|
virtual bool containsTable(QString tblname);
|
||
|
virtual QString quoteValue(QString str);
|
||
|
virtual void initQueryBuilder();
|
||
|
|
||
|
QHash<QString, QSharedPointer<TableSchema> > getTables() const;
|
||
|
void setTables(const QHash<QString, QSharedPointer<TableSchema> > &value);
|
||
| ... | ... | |
|
QSharedPointer<Database> getDatabase() const;
|
||
|
void setDatabase(const QSharedPointer<Database> &value);
|
||
|
|
||
|
QSharedPointer<QueryBuilder> getQueryBuilder() const;
|
||
|
|
||
|
protected:
|
||
|
virtual QStringList findTableNames(QString schema = "") = 0;
|
||
|
virtual QHash<QString, QStringList> findUniqueIndexes(const QSharedPointer<TableSchema> &table) = 0;
|
||
|
virtual void findConstraints(const QSharedPointer<TableSchema> &ts) = 0;
|
||
|
virtual bool findColumns(const QSharedPointer<TableSchema> &ts) = 0;
|
||
|
virtual QSharedPointer<TableSchema> loadTableSchema(QString name) = 0;
|
||
|
virtual TableSchema *getTableSchema(QString name, bool refresh = false);
|
||
|
QSharedPointer<Database> database;
|
||
|
QSharedPointer<QHash<QString, QString>> typeMap;
|
||
|
QHash<QString, QSharedPointer<TableSchema>> tables;
|
||
|
QSharedPointer<QueryBuilder> queryBuilder;
|
||
|
|
||
|
|
||
|
};
|
||
| src/schema/sqlitequerybuilder.cpp | ||
|---|---|---|
|
#include "sqlitequerybuilder.h"
|
||
|
|
||
|
|
||
|
CuteEntityManager::SqliteQueryBuilder::SqliteQueryBuilder(QSharedPointer<CuteEntityManager::Schema> schema,
|
||
|
QSharedPointer<CuteEntityManager::Database> database) : QueryBuilder(schema, database) {
|
||
|
|
||
|
}
|
||
|
|
||
|
CuteEntityManager::SqliteQueryBuilder::~SqliteQueryBuilder() {
|
||
|
|
||
|
}
|
||
| src/schema/sqlitequerybuilder.h | ||
|---|---|---|
|
#ifndef SQLITEQUERYBUILDER_H
|
||
|
#define SQLITEQUERYBUILDER_H
|
||
|
#include "../querybuilder.h"
|
||
|
namespace CuteEntityManager {
|
||
|
class SqliteQueryBuilder : public QueryBuilder
|
||
|
{
|
||
|
public:
|
||
|
SqliteQueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
|
||
|
~SqliteQueryBuilder();
|
||
|
};
|
||
|
|
||
|
}
|
||
|
#endif // SQLITEQUERYBUILDER_H
|
||
| src/schema/sqliteschema.cpp | ||
|---|---|---|
|
#include "../database.h"
|
||
|
#include <QSqlRecord>
|
||
|
#include <QSqlResult>
|
||
|
#include "sqlitequerybuilder.h"
|
||
|
using namespace CuteEntityManager;
|
||
|
|
||
|
SqliteSchema::SqliteSchema(QSharedPointer<Database> database) : Schema(database) {
|
||
|
|
||
|
this->queryBuilder = QSharedPointer<QueryBuilder>(new SqliteQueryBuilder(QSharedPointer<Schema>(this), database));
|
||
|
}
|
||
|
|
||
|
SqliteSchema::~SqliteSchema() {
|
||
| ... | ... | |
|
}
|
||
|
|
||
|
QHash<QString, QString> *SqliteSchema::getTypeMap() {
|
||
|
/**
|
||
|
this->typeMap.data()->insert("bool", "SMALLINT");
|
||
|
this->typeMap.data()->insert("short", "SMALLINT");
|
||
|
this->typeMap.data()->insert("int", "INTEGER");
|
||
|
this->typeMap.data()->insert("long", "INTEGER");
|
||
|
this->typeMap.data()->insert("long long", "INTEGER");
|
||
|
this->typeMap.data()->insert("float", "FLOAT");
|
||
|
this->typeMap.data()->insert("double", "FLOAT");
|
||
|
this->typeMap.data()->insert("long double", "FLOAT");
|
||
|
this->typeMap.data()->insert("unsigned short", "SMALLINT");
|
||
|
this->typeMap.data()->insert("unsigned int", "INTEGER");
|
||
|
this->typeMap.data()->insert("unsigned long", "INTEGER");
|
||
|
this->typeMap.data()->insert("unsigned long long", "INTEGER");
|
||
|
this->typeMap.data()->insert("std::string", "TEXT");
|
||
|
this->typeMap.data()->insert("std::wstring", "TEXT");
|
||
|
this->typeMap.data()->insert("QString", "TEXT");
|
||
|
this->typeMap.data()->insert("QVariant", "TEXT");
|
||
|
this->typeMap.data()->insert("QUuid", "TEXT");
|
||
|
this->typeMap.data()->insert("QDate", "DATE");
|
||
|
this->typeMap.data()->insert("QTime", "TIME");
|
||
|
this->typeMap.data()->insert("QDateTime", "TIMESTAMP");
|
||
|
this->typeMap.data()->insert("QByteArray", "BLOB");
|
||
|
*/
|
||
|
if (this->typeMap.data()->empty()) {
|
||
|
this->typeMap.data()->insert(TYPE_SMALLINT, "tinyint");
|
||
|
this->typeMap.data()->insert(TYPE_BOOLEAN, "boolean");
|
||
| ... | ... | |
|
QSqlQuery q2 = this->database.data()->getQuery();
|
||
|
q2.setForwardOnly(true);
|
||
|
if (q.value("unique").toBool()) {
|
||
|
q2.exec("PRAGMA index_info(" + this->quoteValue(indexName) + ")");
|
||
|
q2.exec("PRAGMA index_info(" + this->quoteSimpleTableName(indexName) + ")");
|
||
|
QStringList indexInfo = QStringList();
|
||
|
while (q2.next()) {
|
||
|
indexInfo.append(q2.value("name").toString());
|
||
Auch abrufbar als: Unified diff
wip