commit da565582698d8e26cfc84ba36a51874c1aaf958d
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Thu Jul 23 23:48:52 2015 +0200

    small update

diff --git a/samples/example/main.cpp b/samples/example/main.cpp
index f5ac428..8478052 100644
--- a/samples/example/main.cpp
+++ b/samples/example/main.cpp
@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
     EntityInstanceFactory::registerClass<Address>();
     QThread *entityManager = new QThread();
     e->moveToThread(entityManager);
-    QStringList inits = QStringList() << "Contact" << "Address" << "Person" <<
+    QStringList inits = QStringList() << "Contact" << "Address" <<
                         "Pupil" << "Group";
     e->startup("0.1", inits);
 
@@ -41,10 +41,10 @@ int main(int argc, char *argv[]) {
      * PERSIST
      * ---------------------------------
      */
-    Group *g = new Group();
-    g->setName("9b");
-    CreateFakeModelData::fillGroup(g);
-    QSharedPointer<Group> gPtr = QSharedPointer<Group>(g);
+
+    QSharedPointer<Group> gPtr = QSharedPointer<Group>(new Group());
+    CreateFakeModelData::fillGroup(gPtr.data());
+    gPtr->setName("9b");
     e->createTable(gPtr);
     QSharedPointer<Entity> groupPtr = gPtr.objectCast<Entity>();
     QSharedPointer<Person> mainTeacher = QSharedPointer<Person>(new Person("Max",
@@ -57,6 +57,10 @@ int main(int argc, char *argv[]) {
      * FIND
      * ---------------------------------
      */
+    QSharedPointer<Person> foundMainTeacher = e->findById<Person*>(1).objectCast<Person>();
+    qDebug() << "Founded:" << foundMainTeacher->toString();
+    qDebug() << "FoundedGroupSize:" << foundMainTeacher->getMaintainedGroups().size();
+
     QSharedPointer<Entity> groupFindPtr = e->findById<Group *>(1);
     QSharedPointer<Group> grp = groupFindPtr.objectCast<Group>();
     qDebug()<< "Group:" << groupFindPtr->toString();
diff --git a/samples/example/models/group.cpp b/samples/example/models/group.cpp
index 69dc6aa..656585f 100644
--- a/samples/example/models/group.cpp
+++ b/samples/example/models/group.cpp
@@ -9,10 +9,10 @@ Group::Group() : Entity() {
 
 const QHash<QString, CuteEntityManager::Relation> Group::getRelations() const {
     auto hash = QHash<QString, CuteEntityManager::Relation>();
-    //hash.insert("pupils", CuteEntityManager::Relation("pupils", MANY_TO_MANY));
-    hash.insert("persons", CuteEntityManager::Relation("persons", MANY_TO_MANY));
+    hash.insert("pupils", CuteEntityManager::Relation("pupils", RelationType::MANY_TO_MANY));
+    hash.insert("persons", CuteEntityManager::Relation("persons", RelationType::MANY_TO_MANY));
     hash.insert("mainTeacher", CuteEntityManager::Relation("mainTeacher",
-                MANY_TO_ONE));
+                RelationType::MANY_TO_ONE));
     return hash;
 }
 
diff --git a/samples/example/models/group.h b/samples/example/models/group.h
index 0ab5382..5e9d9d3 100644
--- a/samples/example/models/group.h
+++ b/samples/example/models/group.h
@@ -17,7 +17,7 @@ using namespace CuteEntityManager;
 
 class Group: public CuteEntityManager::Entity {
     Q_OBJECT
-    //Q_PROPERTY(QList<QSharedPointer<Pupil>> pupils READ getPupils WRITE setPupils)
+    Q_PROPERTY(QList<QSharedPointer<Pupil>> pupils READ getPupils WRITE setPupils)
     Q_PROPERTY(QList<QSharedPointer<Person>> persons READ getPersons WRITE setPersons)
     Q_PROPERTY(QString name READ getName WRITE setName)
     Q_PROPERTY(QSharedPointer<Person> mainTeacher READ getMainTeacher WRITE
diff --git a/samples/example/models/person.cpp b/samples/example/models/person.cpp
index 38c9dfa..96d0863 100644
--- a/samples/example/models/person.cpp
+++ b/samples/example/models/person.cpp
@@ -16,8 +16,12 @@ Person::Person(QString firstName, QString familyName, Gender gender,
 
 const QHash<QString, CuteEntityManager::Relation> Person::getRelations() const {
     auto hash = QHash<QString, CuteEntityManager::Relation>();
-    hash.insert("groups", CuteEntityManager::Relation("groups", MANY_TO_MANY,
+    hash.insert("groups", CuteEntityManager::Relation("groups",
+                RelationType::MANY_TO_MANY,
                 QString("persons")));
+    hash.insert("maintainedGroups", CuteEntityManager::Relation("maintainedGroups",
+                RelationType::ONE_TO_MANY,
+                QString("mainTeacher")));
     return hash;
 }
 
@@ -120,3 +124,13 @@ void Person::addContact(Contact *contact) {
 void Person::addAddress(Address *address) {
     this->addresses.append(QSharedPointer<Address>(address));
 }
+QList<QSharedPointer<Group> > Person::getMaintainedGroups() const
+{
+    return maintainedGroups;
+}
+
+void Person::setMaintainedGroups(const QList<QSharedPointer<Group> > &value)
+{
+    maintainedGroups = value;
+}
+
diff --git a/samples/example/models/person.h b/samples/example/models/person.h
index c22a575..004a046 100644
--- a/samples/example/models/person.h
+++ b/samples/example/models/person.h
@@ -25,6 +25,8 @@ class Person: public Entity {
     Q_PROPERTY(QDate birthday READ getBirthday WRITE setBirthday)
     Q_PROPERTY(Gender gender READ getGender WRITE setGender)
     Q_PROPERTY(QList<QSharedPointer<Group>> groups READ getGroups WRITE setGroups)
+    Q_PROPERTY(QList<QSharedPointer<Group>> maintainedGroups READ
+               getMaintainedGroups WRITE setMaintainedGroups)
 
   public:
     enum class Gender {MALE, FEMALE, UNKNOWNGENDER};
@@ -76,6 +78,9 @@ class Person: public Entity {
     void addContact(Contact *contact);
     void addAddress(Address *address);
 
+    QList<QSharedPointer<Group> > getMaintainedGroups() const;
+    void setMaintainedGroups(const QList<QSharedPointer<Group> > &value);
+
   protected:
     QString firstName;
     QString familyName;
@@ -87,6 +92,7 @@ class Person: public Entity {
     QList <QSharedPointer<Contact>> contacts;
     QList <QSharedPointer<Address>> addresses;
     QList <QSharedPointer<Group>> groups;
+    QList <QSharedPointer<Group>> maintainedGroups;
 };
 
 
diff --git a/samples/example/models/pupil.cpp b/samples/example/models/pupil.cpp
index ae91954..5e855a6 100644
--- a/samples/example/models/pupil.cpp
+++ b/samples/example/models/pupil.cpp
@@ -6,7 +6,7 @@ Pupil::Pupil() : Person() {
 
 Pupil::Pupil(QString firstName, QString familyName, Gender gender,
              QString customPictureFileName, QString namePrefix, QString nickName,
-             QDate birthday, QString form, QObject *parent)
+             QDate birthday, QString legalGuardianNote, QObject *parent)
     : Person(firstName, familyName, gender, customPictureFileName, namePrefix,
              nickName, birthday, parent) {
     setFirstName(firstName);
@@ -16,7 +16,7 @@ Pupil::Pupil(QString firstName, QString familyName, Gender gender,
     setBirthday(birthday);
     setGender(gender);
     setCustomPictureFileName(customPictureFileName);
-    setForm(form);
+    this->setLegalGuardianNote(legalGuardianNote);
 }
 
 QString Pupil::getLegalGuardianNote() const {
@@ -27,13 +27,5 @@ void Pupil::setLegalGuardianNote(const QString &value) {
     legalGuardianNote = value;
 }
 
-QString Pupil::getForm() const {
-    return form;
-}
-
-void Pupil::setForm(const QString &value) {
-    form = value;
-}
-
 
 
diff --git a/samples/example/models/pupil.h b/samples/example/models/pupil.h
index 57f6784..626bad3 100644
--- a/samples/example/models/pupil.h
+++ b/samples/example/models/pupil.h
@@ -11,8 +11,7 @@ class Pupil : public Person {
     Pupil(QString firstName, QString familyName,
           Gender gender = Gender::UNKNOWNGENDER,
           QString customPictureFileName = QString(), QString namePrefix = QString(),
-          QString nickName = QString(), QDate birthday = QDate(),
-          QString form = QString(), QObject *parent = 0);
+          QString nickName = QString(), QDate birthday = QDate(), QString legalGuardianNote = "", QObject *parent = 0);
 
     QString getLegalGuardianNote() const;
     void setLegalGuardianNote(const QString &value);
@@ -22,7 +21,6 @@ class Pupil : public Person {
 
   protected:
     QString legalGuardianNote;
-    QString form;
 
 };
 
diff --git a/src/entity.cpp b/src/entity.cpp
index 807c9ba..83ab0bc 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -95,7 +95,7 @@ const QStringList Entity::getBLOBColumns() const {
 }
 
 InheritanceStrategy Entity::getInheritanceStrategy() const {
-    return JOINED_TABLE;
+    return InheritanceStrategy::JOINED_TABLE;
 }
 
 bool Entity::isInheritanceCascaded() const {
@@ -110,7 +110,7 @@ const QList<const QMetaObject *> Entity::superClasses(bool
         stopAtSingleTableInheritance) const {
     QList<const QMetaObject *> classes = QList<const QMetaObject *>();
     auto superMetaObject = this->metaObject()->superClass();
-    if (this->getInheritanceStrategy() == JOINED_TABLE) {
+    if (this->getInheritanceStrategy() == InheritanceStrategy::JOINED_TABLE) {
         Entity *e = nullptr;
         while (superMetaObject && QString(superMetaObject->className()) !=
                 QString("CuteEntityManager::Entity")) {
@@ -118,10 +118,10 @@ const QList<const QMetaObject *> Entity::superClasses(bool
             if (e) {
                 classes.append(superMetaObject);
                 superMetaObject = superMetaObject->superClass();
-                quint8 s = e->getInheritanceStrategy();
+                InheritanceStrategy s = e->getInheritanceStrategy();
                 delete e;
                 e = nullptr;
-                if (stopAtSingleTableInheritance && s == PER_CLASS_TABLE) {
+                if (stopAtSingleTableInheritance && s == InheritanceStrategy::PER_CLASS_TABLE) {
                     break;
                 }
             } else {
@@ -140,7 +140,7 @@ const QHash<QString, QMetaProperty> Entity::getSuperMetaProperties() const {
     auto superMetaObjectPropertyMap = QHash<QString, QMetaProperty>();
     auto superMeta = this->metaObject()->superClass();
     if (QString(superMeta->className()) != QString("CuteEntityManager::Entity")
-            && this->getInheritanceStrategy() == JOINED_TABLE) {
+            && this->getInheritanceStrategy() == InheritanceStrategy::JOINED_TABLE) {
         for (int var = 0; var < superMeta->propertyCount(); ++var) {
             QMetaProperty prop = superMeta->property(var);
             if (prop.isReadable() && prop.isWritable()) {
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index cfaa37a..3089b96 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -288,12 +288,13 @@ void EntityManager::savePrePersistedRelations(const QSharedPointer<Entity>
         const Relation r = iterator.key();
         auto var = iterator.value().read(entity.data());
         if (!var.isNull()) {
-            if (r.getType() == MANY_TO_ONE) {
+            if (r.getType() == RelationType::MANY_TO_ONE) {
                 auto e = EntityInstanceFactory::castQVariant(var);
                 if (this->shouldBeSaved(e, r)) {
                     this->save(e);
                 }
-            } else if (r.getType() == ONE_TO_ONE && r.getMappedBy().isEmpty()) {
+            } else if (r.getType() == RelationType::ONE_TO_ONE
+                       && r.getMappedBy().isEmpty()) {
                 auto entity =  EntityInstanceFactory::castQVariant(var);
                 this->save(entity);
             }
@@ -310,9 +311,9 @@ void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
         const Relation r = iterator.key();
         auto var = iterator.value().read(entity.data());
         if (!var.isNull()) {
-            if (this->canPersistRelation(r, MANY_TO_MANY, var)) {
+            if (this->canPersistRelation(r, RelationType::MANY_TO_MANY, var)) {
                 this->persistManyToMany(entity, r, var);
-            } else if (this->canPersistRelation(r, ONE_TO_MANY, var)) {
+            } else if (this->canPersistRelation(r, RelationType::ONE_TO_MANY, var)) {
                 QList<QSharedPointer<Entity>> list = EntityInstanceFactory::castQVariantList(
                         var);
                 for (int var = 0; var < list.size(); ++var) {
@@ -321,7 +322,8 @@ void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
                         this->save(entity);
                     }
                 }
-            } else if (r.getType() == ONE_TO_ONE && !r.getMappedBy().isEmpty()) {
+            } else if (r.getType() == RelationType::ONE_TO_ONE
+                       && !r.getMappedBy().isEmpty()) {
                 auto entity =  EntityInstanceFactory::castQVariant(var);
                 this->save(entity);
             }
@@ -335,9 +337,11 @@ void EntityManager::persistMappedByRelation(const QList<QSharedPointer<Entity> >
         const QSharedPointer<Entity> &ptr, const Relation &r,
         const QString &tblName) {
     q.clear();
-    QList<QSharedPointer<Entity>> saved = r.getCascadeType().contains(ALL)
-                                          || r.getCascadeType().contains(MERGE)
-                                          || r.getCascadeType().contains(PERSIST) ? this->saveRelationEntities(list,
+    QList<QSharedPointer<Entity>> saved = r.getCascadeType().contains(
+            CascadeType::ALL)
+                                          || r.getCascadeType().contains(CascadeType::MERGE)
+                                          || r.getCascadeType().contains(CascadeType::PERSIST) ?
+                                          this->saveRelationEntities(list,
                                                   r) : list;
     this->db->startTransaction();
     auto builder = this->schema->getQueryBuilder();
@@ -359,7 +363,7 @@ void EntityManager::persistMappedByRelation(const QList<QSharedPointer<Entity> >
                          q.lastError().text();
                 qDebug() << "Involved entities: " << entity->getClassname() <<
                          "(MainEntitiy) and "  << entity->getClassname();
-                qDebug() << "Relation:" << r.getType() << r.getPropertyName();
+                qDebug() << "Relation:" << r.getPropertyName();
             }
         }
     }
@@ -391,11 +395,11 @@ QMetaProperty EntityManager::mappedProperty(const Relation &r,
 
 bool EntityManager::shouldBeSaved(QSharedPointer<Entity> &entity,
                                   const Relation &r) {
-    return entity && (r.getCascadeType().contains(ALL)
+    return entity && (r.getCascadeType().contains(CascadeType::ALL)
                       || (entity->getProperty(entity->getPrimaryKey()) > -1
-                          && r.getCascadeType().contains(MERGE))
+                          && r.getCascadeType().contains(CascadeType::MERGE))
                       || (entity->getProperty(entity->getPrimaryKey()) <= -1
-                          && r.getCascadeType().contains(PERSIST)));
+                          && r.getCascadeType().contains(CascadeType::PERSIST)));
 }
 
 void EntityManager::removeRelations(const QSharedPointer<Entity> &entity) {
@@ -405,15 +409,17 @@ void EntityManager::removeRelations(const QSharedPointer<Entity> &entity) {
         const Relation r = iterator.key();
         auto property = iterator.value();
         auto var = property.read(entity.data());
-        if (r.getType() == MANY_TO_MANY) {
+        if (r.getType() == RelationType::MANY_TO_MANY) {
             this->removeManyToManyEntityList(entity, r, var);
-        } else if (r.getType() == ONE_TO_MANY) {
-            if (r.getCascadeType().contains(REMOVE) || r.getCascadeType().contains(ALL)) {
+        } else if (r.getType() == RelationType::ONE_TO_MANY) {
+            if (r.getCascadeType().contains(CascadeType::REMOVE)
+                    || r.getCascadeType().contains(CascadeType::ALL)) {
                 this->removeEntityList(var);
             } else {
                 this->setNullOneToManyRelation(var, r);
             }
-        }  else if (r.getType() == MANY_TO_ONE || r.getType() == MANY_TO_ONE) {
+        }  else if (r.getType() == RelationType::MANY_TO_ONE
+                    || r.getType() == RelationType::MANY_TO_ONE) {
             this->setNullEntityPropertyRelation(var, r);
         }
         ++iterator;
@@ -441,7 +447,8 @@ void EntityManager::setNullOneToManyRelation(QVariant &var, const Relation &r) {
 
 void EntityManager::setNullEntityPropertyRelation(QVariant &var,
         const Relation &r) {
-    if (r.getCascadeType().contains(REMOVE) || r.getCascadeType().contains(ALL)) {
+    if (r.getCascadeType().contains(CascadeType::REMOVE)
+            || r.getCascadeType().contains(CascadeType::ALL)) {
         this->removeEntity(var);
     } else if (!r.getMappedBy().isEmpty() && !var.isNull()) {
         auto e = EntityInstanceFactory::castQVariant(var);
@@ -484,10 +491,10 @@ void EntityManager::removeManyToManyEntityList(const QSharedPointer<Entity> &e,
                 QSqlQuery q = builder->manyToManyDelete(
                                   tblName, builder->generateManyToManyColumnName(e),
                                   e->getProperty(e->getPrimaryKey()).toLongLong());
-                bool refresh = r.getCascadeType().contains(REFRESH)
-                               || r.getCascadeType().contains(ALL);
-                bool remove = r.getCascadeType().contains(REMOVE)
-                              || r.getCascadeType().contains(ALL);
+                bool refresh = r.getCascadeType().contains(CascadeType::REFRESH)
+                               || r.getCascadeType().contains(CascadeType::ALL);
+                bool remove = r.getCascadeType().contains(CascadeType::REMOVE)
+                              || r.getCascadeType().contains(CascadeType::ALL);
                 if (q.exec()) {
                     for (int var = 0; var < list.size(); ++var) {
                         auto entity = list.at(var);
@@ -732,18 +739,18 @@ void EntityManager::resolveRelations(const QSharedPointer<Entity> &entity,
         QString colName = this->schema->getQueryBuilder()->generateColumnNameID(
                               r.getPropertyName());
         switch (r.getType()) {
-        case MANY_TO_ONE:
+        case RelationType::MANY_TO_ONE:
             if (map.contains(colName)) {
                 this->manyToOne(entity, map.value(colName), property, refresh);
             }
             break;
-        case MANY_TO_MANY:
+        case RelationType::MANY_TO_MANY:
             this->manyToMany(entity, property, refresh);
             break;
-        case ONE_TO_MANY:
+        case RelationType::ONE_TO_MANY:
             this->oneToMany(entity, r, property, refresh);
             break;
-        case ONE_TO_ONE:
+        case RelationType::ONE_TO_ONE:
             this->oneToOne(entity, r, property, refresh, map.value(colName));
             break;
         }
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index d3fc750..3d14925 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -34,7 +34,7 @@ QueryBuilder::~QueryBuilder() {
 bool QueryBuilder::createTable(const QSharedPointer<Entity> &entity,
                                bool createRelationTables) const {
     bool rc = false;
-    if (entity.data()) {
+    if (entity) {
         auto tableDefinition = this->generateTableDefinition(entity);
         QString tableName = entity->getTablename();
         this->schema->containsTable(tableName) ? rc = true : rc = false;
@@ -86,12 +86,14 @@ const {
         while (iterator != relations.constEnd()) {
             auto relation = iterator.value();
             if (relation.getMappedBy().isEmpty() && !relation.getCascadeType().isEmpty()) {
-                QString update = relation.getCascadeType().contains(MERGE)
-                                 || relation.getCascadeType().contains(ALL) ?  this->getForeignKeyCascade(
+                QString update = relation.getCascadeType().contains(CascadeType::MERGE)
+                                 || relation.getCascadeType().contains(CascadeType::ALL) ?
+                                 this->getForeignKeyCascade(
                                      CASCADE) : this->getForeignKeyCascade(NO_ACTION);
-                QString remove = relation.getCascadeType().contains(REMOVE)
-                                 || relation.getCascadeType().contains(ALL) ?  this->getForeignKeyCascade(
-                                     CASCADE) : this->getForeignKeyCascade(SET_NULL);
+                QString remove = relation.getCascadeType().contains(CascadeType::REMOVE)
+                                 || relation.getCascadeType().contains(CascadeType::ALL) ?
+                                 this->getForeignKeyCascade(
+                                     CASCADE) : this->getForeignKeyCascade(DbForeignKeyCascade::SET_NULL);
                 this->createRelationFK(queries, entity, relation,
                                        props.value(relation.getPropertyName()), update, remove);
             }
@@ -112,7 +114,8 @@ void QueryBuilder::createRelationFK(QStringList &queries,
     auto ptr = QSharedPointer<Entity>
                (EntityInstanceFactory::createInstance(metaProperty.type()));
     if (ptr) {
-        if (relation.getType() == ONE_TO_ONE || relation.getType() == MANY_TO_ONE) {
+        if (relation.getType() == RelationType::ONE_TO_ONE
+                || relation.getType() == RelationType::MANY_TO_ONE) {
             QString indexName = this->generateIndexName(relation.getPropertyName(),
                                 entity->getTablename(),
                                 this->generateColumnNameID(relation.getPropertyName()),
@@ -122,7 +125,7 @@ void QueryBuilder::createRelationFK(QStringList &queries,
                                                ptr->getTablename(),
                                                QStringList(ptr->getPrimaryKey()), remove, update));
 
-        } else if (relation.getType() == MANY_TO_MANY) {
+        } else if (relation.getType() == RelationType::MANY_TO_MANY) {
             QString tableName = this->generateManyToManyTableName(entity, ptr);
             queries.append(this->createForeignKeyManyToMany(tableName, entity, update,
                            remove));
@@ -153,7 +156,7 @@ QString QueryBuilder::createTable(const QString &tableName,
 QString QueryBuilder::createFkSuperClass(const Entity *e) const {
     QString r = "";
     auto superMetaObject = e->metaObject()->superClass();
-    if (e->getInheritanceStrategy() == JOINED_TABLE
+    if (e->getInheritanceStrategy() == InheritanceStrategy::JOINED_TABLE
             && QString(superMetaObject->className()) !=
             this->entityClassname()) {
         Entity *superClass  = EntityInstanceFactory::createInstance(
@@ -369,7 +372,8 @@ const {
     QHash<QString, Relation> relations = entity->getRelations();
     for (int var = 0; var < o->propertyCount(); ++var) {
         auto m = o->property(var);
-        if (!superMetaObjectPropertyMap.contains(QString(m.name()))
+        if ((!superMetaObjectPropertyMap.contains(QString(m.name()))
+                || entity->getInheritanceStrategy() == InheritanceStrategy::PER_CLASS_TABLE)
                 && m.name() != QString("objectName") && m.isReadable()
                 && !entity->getTransientAttributes().contains(m.name())) {
             if (m.isEnumType()) {
@@ -393,10 +397,12 @@ const {
             }
         }
     }
-    if (!(QString(superMetaObject->className()) !=
+    if (QString(superMetaObject->className()) ==
             this->entityClassname()
-            && entity->getInheritanceStrategy() == JOINED_TABLE)) {
+            || entity->getInheritanceStrategy() == InheritanceStrategy::PER_CLASS_TABLE) {
         map.insert(entity->getPrimaryKey(), this->schema->TYPE_BIGPK);
+    } else {
+        map.insert(entity->getPrimaryKey(), this->schema->TYPE_BIGINT);
     }
     return map;
 }
@@ -423,7 +429,7 @@ const {
     auto props = entity->getMetaProperties();
     for (auto i = m.begin(); i != m.end(); ++i) {
         Relation r = i.value();
-        if (r.getType() == MANY_TO_MANY && r.getMappedBy().isEmpty()) {
+        if (r.getType() == RelationType::MANY_TO_MANY && r.getMappedBy().isEmpty()) {
             QHash<QString, QString> h = QHash<QString, QString>();
             h.insert(entity->getPrimaryKey(), this->schema->TYPE_BIGPK);
             h.insert(this->generateManyToManyColumnName(entity),
@@ -582,7 +588,7 @@ const {
     QList<QSqlQuery> queries = QList<QSqlQuery>();
     queries.append(this->remove(entity->getTablename(),
                                 entity->getProperty(entity->getPrimaryKey()).toLongLong()));
-    if (entity->getInheritanceStrategy() != PER_CLASS_TABLE
+    if (entity->getInheritanceStrategy() != InheritanceStrategy::PER_CLASS_TABLE
             && entity->isInheritanceCascaded()) {
         auto classes = entity->superClasses(true);
         for (int var = 0; var < classes.size(); ++var) {
@@ -857,7 +863,7 @@ QHash<QString, Relation> QueryBuilder::processRelations(
 QList<QueryBuilder::ClassAttributes> QueryBuilder::inheritedAttributes(
     const QSharedPointer<Entity> &entity) const {
     auto list = QList<QueryBuilder::ClassAttributes>();
-    if (entity->getInheritanceStrategy() == JOINED_TABLE) {
+    if (entity->getInheritanceStrategy() == InheritanceStrategy::JOINED_TABLE) {
         auto classes = QList<const QMetaObject *>();
         classes.append(entity->metaObject());
         classes.append(entity->superClasses(true));
@@ -923,8 +929,8 @@ QHash<QString, QVariant> QueryBuilder::getManyToOneAttributes(
     auto i = relations.constBegin();
     while (i != relations.constEnd()) {
         Relation r = i.value();
-        if ((r.getType() == MANY_TO_ONE && props.contains(i.key()))
-                || (r.getType() == ONE_TO_ONE && r.getMappedBy().isEmpty())) {
+        if ((r.getType() == RelationType::MANY_TO_ONE && props.contains(i.key()))
+                || (r.getType() == RelationType::ONE_TO_ONE && r.getMappedBy().isEmpty())) {
             auto v = props.value(i.key()).read(entity.data());
             QSharedPointer<Entity> e = EntityInstanceFactory::castQVariant(v);
             if (e) {
diff --git a/src/relation.cpp b/src/relation.cpp
index 0222f2f..ae55ff0 100644
--- a/src/relation.cpp
+++ b/src/relation.cpp
@@ -24,9 +24,9 @@ Relation::Relation(QString propertyName, bool optional, RelationType type) {
     this->propertyName = propertyName;
     this->type = type;
     this->optional = optional;
-    this->cascadeType = {MERGE,
-                         PERSIST,
-                         REFRESH
+    this->cascadeType = {CascadeType::MERGE,
+                         CascadeType::PERSIST,
+                         CascadeType::REFRESH
                         };
 }
 
@@ -36,8 +36,8 @@ Relation::Relation(QString propertyName, RelationType type, QString mappedBy,
     this->type = type;
     this->mappedBy = mappedBy;
     this->optional = true;
-    if (this->type == ONE_TO_ONE) {
-        this->cascadeType = {ALL};
+    if (this->type == RelationType::ONE_TO_ONE) {
+        this->cascadeType = {CascadeType::ALL};
     } else {
         this->cascadeType = cascadeType;
     }
diff --git a/src/relation.h b/src/relation.h
index 64d3fbb..886adfe 100644
--- a/src/relation.h
+++ b/src/relation.h
@@ -18,7 +18,7 @@
 #include <QString>
 #include <QHash>
 namespace CuteEntityManager {
-enum RelationType {
+enum class RelationType {
     ONE_TO_ONE = 0, //e.g. specialization, heritage
     ONE_TO_MANY = 1, //@OneToMany(cascade=ALL, mappedBy="customer") e.g. QList<QSharedPointer<Person>>
     MANY_TO_ONE = 2, //e.g. QSharedPointer<Person>
@@ -26,12 +26,12 @@ enum RelationType {
     MANY_TO_MANY = 3, //e.g. QList<QSharedPointer<Person>> - realized with seperated database table
 };
 
-enum InheritanceStrategy {
+enum class InheritanceStrategy {
     PER_CLASS_TABLE,
     JOINED_TABLE,
 };
 
-enum CascadeType {
+enum class CascadeType {
     ALL,
     MERGE,
     PERSIST,
@@ -51,7 +51,7 @@ class Relation {
      */
     explicit Relation(QString propertyName, RelationType type,
                       QString mappedBy = QString(),
-                      QList<CascadeType> cascadeType = {MERGE, PERSIST, REFRESH});
+                      QList<CascadeType> cascadeType = {CascadeType::MERGE, CascadeType::PERSIST, CascadeType::REFRESH});
     ~Relation();
     RelationType getType() const;
     void setType(const RelationType &value);