Projekt

Allgemein

Profil

« Zurück | Weiter » 

Revision e5a0d313

Von Christian Ehringfeld vor mehr als 8 Jahren hinzugefügt

bugfix

Unterschiede anzeigen:

src/entitymanager.cpp
QStringList EntityManager::connectionNames = QStringList();
QHash<QString, EntityManager *> EntityManager::instances =
QHash<QString, EntityManager *>();
QHash<QString, EntityManager *>();
QStringList EntityManager::getConnectionNames() {
return EntityManager::connectionNames;
......
void EntityManager::init(bool inspect, const MsgType msgType) {
EntityInstanceFactory::registerClass<DatabaseMigration>();
this->schema = QSharedPointer<Schema>(Database::getSchema(Database::getDatabaseType(
this->db->getDatabase().driverName()), this->db));
this->db->getDatabase().driverName()), this->db));
this->schema->setTables(this->schema->getTableSchemas());
this->queryInterpreter = QSharedPointer<QueryInterpreter>(new QueryInterpreter(
this->schema->getQueryBuilder().data()));
this->schema->getQueryBuilder().data()));
this->appendToInstanceList();
if (inspect) {
EntityInspector inspector = EntityInspector(msgType);
......
loggerFile.replace("[", "");
loggerFile.replace("]", "");
this->logger = QSharedPointer<Logger>(new Logger(QDir::currentPath() + "/" +
loggerFile, msgType));
loggerFile, msgType));
}
EntityManager::EntityManager(const QString &databaseType, QString databasename,
......
}
this->db->startTransaction();
QList<QSqlQuery> q = this->schema->getQueryBuilder()->merge(
entity);
entity);
ok = this->db->exec(q);
if (!ok || !this->db->commitTransaction()) {
......
mergedObjects.append(entity.data());
rc = false;
if (this->checkTable(entity) && (!validate || this->validate(entity))
&& !(checkDuplicate && this->count(entity) > 0)) {
&& (!checkDuplicate || this->count(entity) <= 0)) {
if (persistRelations) {
this->savePrePersistedRelations(entity, mergedObjects,
relationsIgnoreHasChanged);
}
this->db->startTransaction();
QList<QSqlQuery> q = this->schema->getQueryBuilder()->create(
entity);
entity);
bool first = true;
QVariant id = -1;
for (int var = 0; var < q.size(); ++var) {
......
}
bool EntityManager::create(QList<QSharedPointer<Entity> > &entities,
const bool persistRelations, const bool validate,
const bool relationsIgnoreHasChanged, const bool checkDuplicate) {
const bool persistRelations, const bool checkDuplicate, const bool validate,
const bool relationsIgnoreHasChanged) {
bool ok = true;
auto merged = QList<Entity *>();
foreach (QSharedPointer<Entity> ent, entities) {
ok = this->createObject(ent, merged, persistRelations,
checkDuplicate, validate, relationsIgnoreHasChanged);
if (!ok) {
break;
this->logger->logMsg("Object " + QString::number(ent->getId()) + " of class " +
EntityHelper::getClassName(ent.data()) + " couldn't created!",
MsgType::WARNING);
}
this->createObject(ent, merged, persistRelations,
checkDuplicate, validate, relationsIgnoreHasChanged);
}
return ok;
}
......
bool EntityManager::startup(QString version, QStringList toInitialize,
bool createIndices) {
QSharedPointer<Entity> dbm = QSharedPointer<DatabaseMigration>
(new DatabaseMigration());
(new DatabaseMigration());
QHash<QString, QVariant> map = QHash<QString, QVariant>();
bool ok = true;
map.insert("version", version);
......
if (ok) {
QString c = toInitialize.at(var);
auto entity = QSharedPointer<Entity>
(EntityInstanceFactory::createInstance(c));
(EntityInstanceFactory::createInstance(c));
ok = this->createTable(entity, false);
entities.append(entity);
} else {
this->logger->logMsg("startup of version " + version + " failed",
MsgType::CRITICAL);
this->logger->logMsg( "erroneous entity:" + (var == 0 ?
"null, this should not happen!" : toInitialize.at(var - 1)), MsgType::CRITICAL);
"null, this should not happen!" : toInitialize.at(var - 1)), MsgType::CRITICAL);
break;
}
}
......
}
QList<QHash<QString, QVariant> > EntityManager::selectBySql(
const QString &sql) {
const QString &sql) {
QSqlQuery q = this->db->select(sql);
return this->convertQueryResult(q);
}
......
for (int i = 0; i < rules.size(); ++i) {
ValidationRule rule = rules.at(i);
QSharedPointer<Validator> validator = ValidatorFactory::getValidatorObject(
rule.getValidatorName());
rule.getValidatorName());
if (validator) {
for (int var = 0; var < rule.getAttributes().size(); ++var) {
QString attr = rule.getAttributes().at(var);
QList<ErrorMsg> msgs = validator->validate(entity->getProperty(attr),
rule.getParams());
rule.getParams());
for (int i = 0; i < msgs.size(); ++i) {
QString emsg = msgs.at(i).getErrorMsg().replace("<property>", attr);
ErrorMsg m = msgs.at(i);
......
for (auto i = listmap.constBegin(); i != listmap.constEnd(); ++i) {
if (rels.contains(i.key())) {
QString appendix =
this->schema->getQueryBuilder()->columnNameIDAppendix();
this->schema->getQueryBuilder()->columnNameIDAppendix();
QString relKey = i.key();
QVariant v = entity->getProperty(relKey.remove(relKey.size() - appendix.size(),
appendix.size()));
appendix.size()));
if (!v.isNull()) {
auto entity = EntityInstanceFactory::castQVariant(v);
if (entity->getProperty(entity->getPrimaryKey()) != i.value()) {
......
}
QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
QSharedPointer<Entity> &e,
const bool refresh) {
QSharedPointer<Entity> &e,
const bool refresh) {
QSharedPointer<Entity> r;
if (!e.isNull() && (refresh
|| !(r = this->cache.get(id, EntityHelper::getClassname(e.data()))))) {
......
}
QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
const QString &classname) {
const QString &classname) {
QSharedPointer<Entity> e = QSharedPointer<Entity>
(EntityInstanceFactory::createInstance(classname));
(EntityInstanceFactory::createInstance(classname));
return this->findById(id, e);
}
......
bool ok = false;
if ((convertedId = id.toLongLong(&ok)) && ok && convertedId > -1) {
QString className = EntityInstanceFactory::extractEntityType(
property.typeName());
property.typeName());
QSharedPointer<Entity> ptr = QSharedPointer<Entity>();
if (refresh || !(this->cache.contains(convertedId, className)
&& (ptr = this->cache.get(convertedId, className)) && ptr)) {
......
property.typeName())));
if (e) {
QSqlQuery q = this->schema->getQueryBuilder()->oneToMany(e->getTablename(),
this->schema->getQueryBuilder()->generateColumnNameID(r.getMappedBy()),
entity->getId());
this->schema->getQueryBuilder()->generateColumnNameID(r.getMappedBy()),
entity->getId());
auto listMap = this->convertQueryResult(q);
auto entities = this->convert(listMap, EntityHelper::getClassname(e.data()),
refresh);
......
EntityInstanceFactory::extractEntityType(property.typeName())));
if (e) {
QSqlQuery q = this->schema->getQueryBuilder()->oneToMany(
e->getTablename(),
this->schema->getQueryBuilder()->generateColumnNameID(
r.getMappedBy()),
entity->getProperty(entity->getPrimaryKey()).toLongLong(), 1);
e->getTablename(),
this->schema->getQueryBuilder()->generateColumnNameID(
r.getMappedBy()),
entity->getProperty(entity->getPrimaryKey()).toLongLong(), 1);
auto listMap = this->convertQueryResult(q);
auto entities = this->convert(listMap, EntityHelper::getClassname(e.data()),
refresh);
......
}
void EntityManager::savePrePersistedRelations(const QSharedPointer<Entity>
&entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged) {
&entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged) {
auto relations = EntityHelper::getRelationProperties(entity.data());
auto iterator = relations.constBegin();
while (iterator != relations.constEnd()) {
......
}
void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
&entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged, bool newItem) {
&entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged, bool newItem) {
auto relations = EntityHelper::getRelationProperties(entity.data());
for (auto i = relations.constBegin(); i != relations.constEnd(); ++i) {
const Relation r = i.key();
......
newItem);
} else if (r.getType() == RelationType::ONE_TO_MANY) {
QList<QSharedPointer<Entity>> list = EntityInstanceFactory::castQVariantList(
var);
var);
if (!list.isEmpty()) {
auto fkProp = EntityHelper::mappedProperty(r, list.at(0));
for (int var = 0; var < list.size(); ++var) {
......
}
void EntityManager::persistMappedByRelation(const QList<QSharedPointer<Entity> >
&list, QSqlQuery &q, const QSharedPointer<Entity> &entity,
const QSharedPointer<Entity> &ptr, const Relation &r,
const QString &tblName, QList<Entity *> &mergedObjects) {
&list, QSqlQuery &q, const QSharedPointer<Entity> &entity,
const QSharedPointer<Entity> &ptr, const Relation &r,
const QString &tblName, QList<Entity *> &mergedObjects) {
q.clear();
QList<QSharedPointer<Entity>> saved =
r.getCascadeType().contains(CascadeType::ALL) ||
r.getCascadeType().contains(CascadeType::MERGE) ||
r.getCascadeType().contains(CascadeType::PERSIST) ?
this->saveRelationEntities(list, r, mergedObjects) : list;
r.getCascadeType().contains(CascadeType::ALL) ||
r.getCascadeType().contains(CascadeType::MERGE) ||
r.getCascadeType().contains(CascadeType::PERSIST) ?
this->saveRelationEntities(list, r, mergedObjects) : list;
this->db->startTransaction();
auto builder = this->schema->getQueryBuilder();
q = builder->manyToManyInsert(tblName,
......
EntityManager *EntityManager::getDefaultInstance() {
for (auto i = EntityManager::instances.constBegin();
i != EntityManager::instances.constEnd(); ++i) {
i != EntityManager::instances.constEnd(); ++i) {
return i.value();
}
return nullptr;
......
}
void EntityManager::setNullEntityPropertyRelation(QVariant &var,
const Relation &r) {
const Relation &r) {
if (r.getCascadeType().contains(CascadeType::REMOVE)
|| r.getCascadeType().contains(CascadeType::ALL)) {
this->removeEntity(var);
......
}
void EntityManager::removeManyToManyEntityList(const QSharedPointer<Entity> &e,
const Relation &r,
QVariant &var) {
const Relation &r,
QVariant &var) {
if (!var.isNull() && var.canConvert<QVariantList>()) {
auto list = EntityInstanceFactory::castQVariantList(var);
if (!list.isEmpty()) {
......
QString tblName = builder->generateManyToManyTableName(e, ptr, r);
if (this->schema->getTables().contains(tblName)) {
QSqlQuery q = builder->manyToManyDelete(
tblName, builder->generateManyToManyColumnName(e),
e->getProperty(e->getPrimaryKey()).toLongLong());
tblName, builder->generateManyToManyColumnName(e),
e->getProperty(e->getPrimaryKey()).toLongLong());
if (this->db->exec(q)) {
bool refresh = r.getCascadeType().contains(CascadeType::REFRESH)
|| r.getCascadeType().contains(CascadeType::ALL);
|| r.getCascadeType().contains(CascadeType::ALL);
bool remove = r.getCascadeType().contains(CascadeType::REMOVE)
|| r.getCascadeType().contains(CascadeType::ALL);
|| r.getCascadeType().contains(CascadeType::ALL);
auto fkProp = EntityHelper::mappedProperty(r, ptr);
for (int var = 0; var < list.size(); ++var) {
auto entity = list.at(var);
......
}
QList<QSharedPointer<Entity>> EntityManager::saveRelationEntities(
const QList<QSharedPointer<Entity> > &list, const Relation &r,
QList<Entity *> &mergedObjects) {
const QList<QSharedPointer<Entity> > &list, const Relation &r,
QList<Entity *> &mergedObjects) {
QList<QSharedPointer<Entity>> saved = QList<QSharedPointer<Entity>>();
QSharedPointer<Entity> ptr;
for (int var = 0; var < list.size(); ++var) {
......
QSqlQuery q;
if (!newItem) {
q = builder->manyToManyDelete(
tblName, builder->generateManyToManyColumnName(entity),
entity->getProperty(entity->getPrimaryKey()).toLongLong());
tblName, builder->generateManyToManyColumnName(entity),
entity->getProperty(entity->getPrimaryKey()).toLongLong());
ok = this->db->exec(q);
} else {
q = builder->getQuery();
......
}
void EntityManager::missingManyToManyTable(const QString &tblName,
const QSharedPointer<Entity> &e, const Relation &r) {
const QSharedPointer<Entity> &e, const Relation &r) {
this->logger->logMsg("MANY_TO_MANY Table " + tblName + " is missing.\n" +
"Entity " + EntityHelper::getClassName(e.data()) +
" is affected.\n" + "Relation of property: " + r.getPropertyName(),
......
void EntityManager::manyToMany(const QSharedPointer<Entity> &entity,
const QMetaProperty &property, const Relation &relation, const bool refresh) {
QSharedPointer<Entity> secEntityPtr = QSharedPointer<Entity>
(EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(
QString(property.typeName()))));
(EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(
QString(property.typeName()))));
auto builder = this->schema->getQueryBuilder();
if (secEntityPtr) {
QString tblName = builder->generateManyToManyTableName(entity, secEntityPtr,
relation);
relation);
if (this->schema->getTables().contains(tblName)) {
QSqlQuery q = builder->manyToMany(tblName,
builder->generateManyToManyColumnName(entity),
......
}
QList<QSharedPointer<Entity> > EntityManager::findEntityByAttributes(
const QSharedPointer<Entity>
&entity,
bool ignoreID) {
const QSharedPointer<Entity>
&entity,
bool ignoreID) {
auto maps = this->findAllByAttributes(entity, ignoreID);
return this->convert(maps, EntityHelper::getClassname(entity.data()));
}
QHash<QString, QVariant> EntityManager::findByPk(qint64 id,
const QSharedPointer<Entity>
&e) {
const QSharedPointer<Entity>
&e) {
QSqlQuery q = this->schema->getQueryBuilder()->find(id, e, 0,
e->getPrimaryKey());
e->getPrimaryKey());
auto listMap = this->convertQueryResult(q);
if (!listMap.isEmpty()) {
return listMap.at(0);
......
QList<QHash<QString, QVariant> > EntityManager::findAllByAttributes(
const QSharedPointer<Entity>
&entity,
bool ignoreID) {
const QSharedPointer<Entity>
&entity,
bool ignoreID) {
QSqlQuery q = this->schema->getQueryBuilder()->findByAttributes(
entity, ignoreID);
entity, ignoreID);
return this->convertQueryResult(q);
}
QList<QHash <QString, QVariant> > EntityManager::findAllByAttributes(
const QHash<QString, QVariant> &m, const QString &tblname, bool ignoreID) {
const QHash<QString, QVariant> &m, const QString &tblname, bool ignoreID) {
QSqlQuery q = this->schema->getQueryBuilder()->findByAttributes(m,
tblname, ignoreID);
tblname, ignoreID);
return this->convertQueryResult(q);
}
QList<QHash<QString, QVariant> > EntityManager::convertQueryResult(
QSqlQuery &q) {
QSqlQuery &q) {
QList<QHash <QString, QVariant> > listmap = QList<QHash <QString, QVariant> >();
this->db->select(q);
QSqlRecord rec = q.record();
......
}
QList<QHash <QString, QVariant> > EntityManager::findAll(
const QSharedPointer<Entity> &e) {
const QSharedPointer<Entity> &e) {
QSqlQuery q = this->schema->getQueryBuilder()->findAll(e);
return this->convertQueryResult(q);
}
......
const Relation r = iterator.key();
const QMetaProperty property = iterator.value();
QString colName = this->schema->getQueryBuilder()->generateColumnNameID(
r.getPropertyName());
r.getPropertyName());
switch (r.getType()) {
case RelationType::MANY_TO_ONE:
if (map.contains(colName)) {
......
bool EntityManager::createTable(const QSharedPointer<Entity> &entity,
bool createRelationTables) {
return this->schema->getQueryBuilder()->createTable(entity,
createRelationTables);
createRelationTables);
}
bool EntityManager::createTable(QString className, bool createRelationTables) {
QSharedPointer<Entity> e = QSharedPointer<Entity>
(EntityInstanceFactory::createInstance(className));
(EntityInstanceFactory::createInstance(className));
return this->schema->getQueryBuilder()->createTable(e, createRelationTables);
}
......
if (followInheritance) {
q.appendJoins(qb->joinBaseClasses(entity));
values = EntityHelper::getEntityAttributes(EntityHelper::getMetaProperties(
entity.data()), entity);
entity.data()), entity);
} else {
values = EntityHelper::getEntityAttributes(
EntityHelper::getNonInheritedMetaProperties(entity.data()), entity);
EntityHelper::getNonInheritedMetaProperties(entity.data()), entity);
}
//maybe filter MANY_TO_MANY and ONE_TO_MANY relations
q.appendFrom(entity->getTablename());
......
}
QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant>
&map,
const char *classname, const bool refresh, const bool resolveRelations) {
&map,
const char *classname, const bool refresh, const bool resolveRelations) {
auto ptr = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
classname, map));
this->cache.insert(ptr);
......
}
QList<QSharedPointer<Entity> > EntityManager::convert(
QList<QHash<QString, QVariant> > maps,
const char *classname, const bool refresh, const bool resolveRelations) {
QList<QHash<QString, QVariant> > maps,
const char *classname, const bool refresh, const bool resolveRelations) {
auto list = QList<QSharedPointer<Entity> >();
for (int var = 0; var < maps.size(); ++var) {
auto ptr = this->convert(maps.at(var), classname, refresh, resolveRelations);

Auch abrufbar als: Unified diff