commit 0ec1cbfb60a883bb098a31471993d64bbd49b49f Author: Christian Ehringfeld Date: Tue Aug 11 22:18:59 2015 +0200 readme update, example updates, new method for entitymanager diff --git a/README.md b/README.md index 0c04a9f..fe2afee 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,64 @@ # CuteEntityManager for Qt ## German -Mit dem CuteEntityManager ist es möglich Entities zu persistieren, zu mergen, zu finden und zu löschen. Die Funktionalität ist dem EntityManager der JPA nachempfunden. Für eine Anwendung war ich auf der Suche nach einem leicht zu benutzenden ORM. Entweder enthielt die jeweilige Library zusätzliche Abhängigkeiten, hatte nicht den gewünschten Funktionsumfang, war in der Benutzung zu "kompliziert"(imho) oder war nur an bestimmte Plattformen gekoppelt. Der CuteEntityManager unterstützt grundsätzlich alle von Qt unterstützten Plattformen. Da ich hauptberuflich Java & PHP Entwickler bin, ist der CuteEntityManager dem o.g. EntityManager der JPA und zum Teil dem PHP Yii Framework nachempfunden. -Der CuteEntityManager basiert ausschließlich auf Qt/C++ Techniken. Der Properties für das ORM werden anhand von Q_PROPERTY Makros festgelegt. Es ist möglich Vererbung zu nutzen. Relationen (ONE_TO_ONE, MANY_TO_ONE, ONE_TO_MANY und MANY_TO_MANY) sind natürlich auch möglich. Um SELECT Statements zu vereinfachen gibt es eine Query API. Man kann also ohne ein Stückchen SQL eine komplette Anwendung mit SQL Datenbank Anbindung implementieren. Man sollte sich natürlich über die "Besonderheiten" einer relationalen Datenbank im Klaren sein (insbesondere eben bei Relationen). Aktuell ist nur einigermaßen die SQLite Unterstützung getestet. Eine Erweiterung für MySQL/PGSQL/MSSQL sollte relativ problemlos möglich sein. +Mit dem CuteEntityManager ist es möglich Entities zu persistieren, zu +mergen, zu finden und zu löschen. Die Funktionalität ist dem +EntityManager der JPA nachempfunden. Für eine andere Anwendung war ich +auf der Suche nach einem leicht zu benutzenden ORM. Entweder enthielten +die jeweiligen Librarys zusätzliche Abhängigkeiten, hatten nicht den +gewünschten Funktionsumfang, waren in der Benutzung zu +"kompliziert"(imho) oder an bestimmte Plattformen gekoppelt. -Der CuteEntityManager ist sicherlich weit davon entfernt in einem guten (getesteten) bzw. fertigen Zustand zu sein, da er aber für die Entwicklung einer anderen Anwendung genutzt wird, wird sich der Zustand sicherlich fortlaufend verbessern. Kritik, Lob, Verbesserungsvorschläge, Pull Requests, Code Reviews sind jederzeit Willkommen. Man kann mich auf direktem Wege per Mail an c.ehringfeld[at]t-online.de erreichen. +Der CuteEntityManager unterstützt grundsätzlich alle von Qt +unterstützten Plattformen. Da ich hauptberuflich Java & PHP Entwickler +bin, ist der CuteEntityManager dem o.g. EntityManager der JPA und zum +Teil dem PHP Yii Framework nachempfunden. + +Der CuteEntityManager basiert ausschließlich auf Qt/C++ Techniken. Der +Properties für das ORM werden anhand von Q_PROPERTY Makros festgelegt. +Es ist möglich Vererbung zu nutzen. Relationen (ONE_TO_ONE, MANY_TO_ONE, +ONE_TO_MANY und MANY_TO_MANY) sind natürlich auch möglich. Um SELECT +Statements zu vereinfachen gibt es eine Query API. Man kann also ohne +ein Stückchen SQL eine komplette Anwendung mit SQL-Datenbank Anbindung +implementieren. Man sollte sich natürlich über die "Besonderheiten" +einer relationalen Datenbank im Klaren sein (insbesondere eben bei +Relationen). Aktuell ist nur die SQLite Unterstützung einigermaßen +getestet. Erweiterungen für MySQL/PGSQL/MSSQL sollte relativ problemlos +möglich sein. + +Der CuteEntityManager ist sicherlich weit davon entfernt in einem guten +(getesteten) bzw. fertigen Zustand zu sein, da er aber für die +Entwicklung einer anderen Anwendung genutzt wird, wird sich der Zustand +sicherlich fortlaufend verbessern. Kritik, Lob, Verbesserungsvorschläge, +Pull Requests, Code Reviews sind jederzeit Willkommen. Man kann mich auf +direktem Wege per Mail an c.ehringfeld[at]t-online.de erreichen. ## English -tbc. +With CuteEntityManager it is possible to persist, merge, find or delete +entities. It's funcionality is based on JPA's EntityManager. For a +different application I was in search of an easy-to-use ORM. Either +those particular libraries had additional dependencies, a smaller +functional range, were too "complicated" to use (imho) or bound to +specific platforms. + +CuteEntityManager basically supports all platforms supported by Qt. +Because I am a Java & PHP developer for a living, CuteEntityManager is +conceptionally based on the aforementioned EntityManager of JPA and in +parts on the PHP Yii framework. + +CuteEntityManager builds solely on Qt/C++ techniqes. The properties for +the ORM are established by the usage of Q_PROPERTY macros. It is +possible to use inheritance. Of course, relations (ONE_TO_ONE, +MANY_TO_ONE, ONE_TO_MANY and MANY_TO_MANY) are also possible. To +simplify SELECT statements there is a Query API. Thus, it's possible to +implement a whole Application with database connection without using a +single bit of SQL. Of course, you should be aware of the "specifics" of +a relational database (notably in matters of relations). Currently, only +SQLite support is passably tested. Extensions for MySQL/PGSQL/MSSQL +should be possible quite smoothly. + +CuteEntityManager is definitely far from a proper (and tested) or even +finished state, but because of it's use for the creation of another +application, surely this state will successively improve. Criticism, +praise, improvement suggestions, pull requests and code reviews are +welcome at any time. You can reach me directly by mail under +c.ehringfeld[at]t-online.de. diff --git a/samples/simple/Simple.pro b/samples/simple/Simple.pro index 5738d33..abad0a4 100644 --- a/samples/simple/Simple.pro +++ b/samples/simple/Simple.pro @@ -22,13 +22,29 @@ SOURCES += \ main.cpp \ artikel.cpp -unix:!macx: LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Debug -lCuteEntityManager +unix:!macx:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Debug -lCuteEntityManager +else:unix:!macx:CONFIG(release, release|debug): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Release/ -lCuteEntityManager unix:INCLUDEPATH += $$PWD/../../src unix:DEPENDPATH += $$PWD/../../src CONFIG += c++14 +QMAKE_CXXFLAGS += -std=c++14 -win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../build-EntityManager-Desktop_Qt_5_4_1_MinGW_32bit-Debug/release/ -lCuteEntityManager -else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../build-EntityManager-Desktop_Qt_5_4_1_MinGW_32bit-Debug/debug/ -lCuteEntityManager +win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Release/release/ -lCuteEntityManager +else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Debug/debug/ -lCuteEntityManager -win32:INCLUDEPATH += $$PWD/../../build-EntityManager-Desktop_Qt_5_4_1_MinGW_32bit-Debug/debug -win32:DEPENDPATH += $$PWD/../../build-EntityManager-Desktop_Qt_5_4_1_MinGW_32bit-Debug/debug +win32:INCLUDEPATH += $$PWD/../../../build-EntityManager-Desktop-Debug/debug +win32:DEPENDPATH += $$PWD/../../../build-EntityManager-Desktop-Debug/debug + +INCLUDEPATH += $$PWD/../../src +DEPENDPATH += $$PWD/../../src + +unix { +QMAKE_CXXFLAGS += -Wall -Wextra -Wmaybe-uninitialized -Wsuggest-final-types -Wsuggest-final-methods -Wsuggest-override -Wunsafe-loop-optimizations -pedantic -Wfloat-equal -Wundef -Wpointer-arith -Wcast-align -Wunreachable-code -O -Winit-self +} + +win32-g++ { + CONFIG += c++11 + QMAKE_CXXFLAGS += -std=c++11 -Wall +} + +CONFIG(release, debug|release):DEFINES += QT_NO_DEBUG_OUTPUT diff --git a/samples/simple/main.cpp b/samples/simple/main.cpp index f7c9f9b..d4adc4b 100644 --- a/samples/simple/main.cpp +++ b/samples/simple/main.cpp @@ -4,9 +4,8 @@ #include "artikel.h" #include "../../src/entitymanager.h" #include "../../src/entityinstancefactory.h" -/** - * create,remove und merge funktionieren - */ + + using namespace CuteEntityManager; int main(int argc, char *argv[]) { Q_UNUSED(argc) Q_UNUSED(argv) @@ -14,14 +13,12 @@ int main(int argc, char *argv[]) { CuteEntityManager::EntityManager *e = new CuteEntityManager::EntityManager("QSQLITE", QDir::currentPath() + "/db.sqlite"); + EntityInstanceFactory::registerClass(); QStringList inits = QStringList() << "Artikel"; e->startup("0.1", inits); QSharedPointer a = QSharedPointer(new Artikel(20.0, "Müsli")); - auto ep = a.dynamicCast(); - e->create(ep, true, true); -// auto artikel = e->findById(1); -// qDebug() << "ArtikelID:" << artikel.data()->getId(); - + auto ep = a.objectCast(); + qDebug() << e->create(ep, true, true); return 0; } diff --git a/samples/validators/Validators.pro b/samples/validators/Validators.pro new file mode 100644 index 0000000..05f513d --- /dev/null +++ b/samples/validators/Validators.pro @@ -0,0 +1,52 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2013-08-01T15:03:24 +# +#------------------------------------------------- + +QT += core +QT += sql + +QT -= gui + +#TARGET = EntityManager +CONFIG += console +CONFIG -= app_bundle + +TEMPLATE = app + +HEADERS += \ + address.h \ + person.h + +SOURCES += \ + main.cpp \ + address.cpp \ + person.cpp + +unix:!macx:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Debug -lCuteEntityManager +else:unix:!macx:CONFIG(release, release|debug): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Release/ -lCuteEntityManager +unix:INCLUDEPATH += $$PWD/../../src +unix:DEPENDPATH += $$PWD/../../src +CONFIG += c++14 +QMAKE_CXXFLAGS += -std=c++14 + +win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Release/release/ -lCuteEntityManager +else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build-EntityManager-Desktop-Debug/debug/ -lCuteEntityManager + +win32:INCLUDEPATH += $$PWD/../../../build-EntityManager-Desktop-Debug/debug +win32:DEPENDPATH += $$PWD/../../../build-EntityManager-Desktop-Debug/debug + +INCLUDEPATH += $$PWD/../../src +DEPENDPATH += $$PWD/../../src + +unix { +QMAKE_CXXFLAGS += -Wall -Wextra -Wmaybe-uninitialized -Wsuggest-final-types -Wsuggest-final-methods -Wsuggest-override -Wunsafe-loop-optimizations -pedantic -Wfloat-equal -Wundef -Wpointer-arith -Wcast-align -Wunreachable-code -O -Winit-self +} + +win32-g++ { + CONFIG += c++11 + QMAKE_CXXFLAGS += -std=c++11 -Wall +} + +CONFIG(release, debug|release):DEFINES += QT_NO_DEBUG_OUTPUT diff --git a/samples/validators/address.cpp b/samples/validators/address.cpp new file mode 100644 index 0000000..a5b937f --- /dev/null +++ b/samples/validators/address.cpp @@ -0,0 +1,67 @@ +#include "address.h" +#include "person.h" +Address::Address(QString label, QString street, QString postcode, + QString city) { + this->label = label; + this->street = street; + this->postcode = postcode; + this->city = city; +} + +QList Address::validationRules() const { + QList rules = QList(); + rules.append(ValidationRule("required", {"street", "postcode","label"})); + //rules.append(ValidationRule("required")); + return rules; +} + +QString Address::getLabel() const { + return label; +} + +void Address::setLabel(const QString &value) { + label = value; +} + +QString Address::getStreet() const { + return street; +} + +void Address::setStreet(const QString &value) { + street = value; +} + +QString Address::getPostcode() const { + return postcode; +} + +void Address::setPostcode(const QString &value) { + postcode = value; +} + +QString Address::getCity() const { + return city; +} + +void Address::setCity(const QString &value) { + city = value; +} + +QList > Address::getPersons() const { + return persons; +} + +void Address::setPersons(const QList > &value) { + persons = value; +} + +const QHash Address::getRelations() +const { + auto hash = Entity::getRelations(); + hash.insert("persons", CuteEntityManager::Relation("persons", + RelationType::MANY_TO_MANY, + QString("addresses"))); + return hash; +} + + diff --git a/samples/validators/address.h b/samples/validators/address.h new file mode 100644 index 0000000..0248af9 --- /dev/null +++ b/samples/validators/address.h @@ -0,0 +1,51 @@ +#ifndef ADDRESS_H +#define ADDRESS_H + +#include +#include +#include "entity.h" + +class Person; +class Relation; +class Pupil; +class Address: public CuteEntityManager::Entity { + Q_OBJECT + Q_PROPERTY(QString label READ getLabel WRITE setLabel) + Q_PROPERTY(QString street READ getStreet WRITE setStreet) + Q_PROPERTY(QString postcode READ getPostcode WRITE setPostcode) + Q_PROPERTY(QString city READ getCity WRITE setCity) + Q_PROPERTY(QList> persons READ + getPersons WRITE setPersons) + + public: + Q_INVOKABLE Address() {} + Address(QString label, QString street, QString postcode, QString city); + virtual QList validationRules() const + override; + + QString getLabel() const; + void setLabel(const QString &value); + + QString getStreet() const; + void setStreet(const QString &value); + + QString getPostcode() const; + void setPostcode(const QString &value); + + QString getCity() const; + void setCity(const QString &value); + + QList > getPersons() const; + void setPersons(const QList > &value); + + const QHash getRelations() const override; + + protected: + QString label; + QString street; + QString postcode; + QString city; + QList> persons; +}; + +#endif // ADDRESS_H diff --git a/samples/validators/main.cpp b/samples/validators/main.cpp new file mode 100644 index 0000000..7919943 --- /dev/null +++ b/samples/validators/main.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +#include "person.h" +#include "address.h" +#include "../../src/entitymanager.h" +#include "../../src/entityinstancefactory.h" +/** + * create,remove und merge funktionieren + */ +using namespace CuteEntityManager; +int main(int argc, char *argv[]) { + Q_UNUSED(argc) Q_UNUSED(argv) + CuteEntityManager::EntityManager *e = new + CuteEntityManager::EntityManager("QSQLITE", QDir::currentPath() + "/db.sqlite"); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass
(); + e->createTable("Person"); + e->createTable("Address"); + + QSharedPointer p1 = QSharedPointer(new Person("Thomas", "Berg", + Person::Gender::MALE, "", QString(), QString(), QDate(1971, 7, 13), 0)); + QSharedPointerp2 = QSharedPointer(new Person("Teresa", "Conrad", + Person::Gender::FEMALE, "", QString(), QString(), QDate(1970, 7, 13), 0)); + QSharedPointer p3 = QSharedPointer(new Person("Heinz", "Dunst", + Person::Gender::MALE, "", QString(), QString(), QDate(1972, 7, 13), 0)); + + //validation takes also place before save/create/merge + qDebug() << "p1 valid:" << e->validate(p1); + qDebug() << "p2 valid:" << e->validate(p2); + qDebug() << "p3 valid:" << e->validate(p3); + + QSharedPointer a1 = QSharedPointer
(new Address("", + "Mentzelstraße 327", + "33617", "Bielefeld")); + QSharedPointer a2 = QSharedPointer
(new Address("Erzieher", + "Bundesallee 252", + "49082", "Osnabrück")); + + qDebug() << "a1 valid:" << e->validate(a1); + qDebug() << "a2 valid:" << e->validate(a2); + + + return 0; +} diff --git a/samples/validators/person.cpp b/samples/validators/person.cpp new file mode 100644 index 0000000..bb49405 --- /dev/null +++ b/samples/validators/person.cpp @@ -0,0 +1,112 @@ +#include "person.h" +#include "address.h" + +Person::Person(QObject *parent): Entity(parent) { +} + +Person::Person(QString firstName, QString familyName, Gender gender, + QString customPictureFileName, QString namePrefix, QString nickName, + QDate birthday, QObject *parent): Entity(parent) { + setFirstName(firstName); + setFamilyName(familyName); + setNamePrefix(namePrefix); + setNickName(nickName); + setBirthday(birthday); + setGender(gender); + setCustomPictureFileName(customPictureFileName); +} + +const QHash Person::getRelations() const { + auto hash = QHash(); + hash.insert("addresses", CuteEntityManager::Relation("addresses", + RelationType::MANY_TO_MANY)); + return hash; +} + +QList Person::validationRules() const { + return Entity::validationRules(); +} + +QString Person::fullName(NameOrder nameOrder) const { + QString name = QString(); + if (nameOrder == NameOrder::FAMILY_FIRST_NAME_ORDER) { + name += this->getFamilyName(); + name += ", "; + if (!this->getNamePrefix().isEmpty()) { + name += this->getNamePrefix(); + name += " "; + } + name += this->getFirstName(); + } else { + name += this->getFirstName(); + name += " "; + name += this->getFamilyName(); + if (!this->getNamePrefix().isEmpty()) { + name += ", "; + name += this->getNamePrefix(); + } + } + return name; +} +QString Person::getFirstName() const { + return firstName; +} + +void Person::setFirstName(const QString &value) { + firstName = value; +} +QString Person::getFamilyName() const { + return familyName; +} + +void Person::setFamilyName(const QString &value) { + familyName = value; +} +QString Person::getNamePrefix() const { + return namePrefix; +} + +void Person::setNamePrefix(const QString &value) { + namePrefix = value; +} +QString Person::getNickName() const { + return nickName; +} + +void Person::setNickName(const QString &value) { + nickName = value; +} +QDate Person::getBirthday() const { + return birthday; +} + +void Person::setBirthday(const QDate &value) { + birthday = value; +} +Person::Gender Person::getGender() const { + return gender; +} + +void Person::setGender(const Gender &value) { + gender = value; +} +QString Person::getCustomPictureFileName() const { + return customPictureFileName; +} + +void Person::setCustomPictureFileName(const QString &value) { + customPictureFileName = value; +} + +QList > Person::getAddresses() const { + return addresses; +} + +void Person::setAddresses(const QList > &value) { + addresses = value; +} + +void Person::addAddress(Address *address) { + this->addresses.append(QSharedPointer
(address)); +} + diff --git a/samples/validators/person.h b/samples/validators/person.h new file mode 100644 index 0000000..a5142f8 --- /dev/null +++ b/samples/validators/person.h @@ -0,0 +1,89 @@ +#ifndef PERSON_H +#define PERSON_H + +#include +#include +#include +#include +#include +#include +#include "../../entitymanager/src/entity.h" + +using namespace CuteEntityManager; +class Group; +class Contact; +class Address; + +class Person: public Entity { + Q_OBJECT + Q_PROPERTY(QString firstName READ getFirstName WRITE setFirstName) + Q_PROPERTY(QString familyName READ getFamilyName WRITE setFamilyName) + Q_PROPERTY(QString namePrefix READ getNamePrefix WRITE setNamePrefix) + Q_PROPERTY(QString nickName READ getNickName WRITE setNickName) + Q_PROPERTY(QString customPictureFileName READ getCustomPictureFileName WRITE + setCustomPictureFileName) + Q_PROPERTY(QDate birthday READ getBirthday WRITE setBirthday) + Q_PROPERTY(Gender gender READ getGender WRITE setGender) + Q_PROPERTY(QList> addresses READ + getAddresses WRITE setAddresses) + + public: + enum class Gender {MALE, FEMALE, UNKNOWNGENDER}; + Q_ENUM(Gender) + enum class NameOrder {FIRST_FAMILY_NAME_ORDER, FAMILY_FIRST_NAME_ORDER}; + Q_ENUM(NameOrder) + Q_INVOKABLE explicit Person(QObject *parent = 0); + Person(QString firstName, QString familyName, + Gender gender = Gender::UNKNOWNGENDER, + QString customPictureFileName = QString(), QString namePrefix = QString(), + QString nickName = QString(), QDate birthday = QDate(), QObject *parent = 0); + + virtual const QHash getRelations() const override; + virtual QList validationRules() const override; + + + bool isPresent(QDateTime date = QDateTime::currentDateTime()); + QString fullName(NameOrder nameOrder = NameOrder::FAMILY_FIRST_NAME_ORDER) + const; + + QString getFirstName() const; + void setFirstName(const QString &value); + + QString getFamilyName() const; + void setFamilyName(const QString &value); + + QString getNamePrefix() const; + void setNamePrefix(const QString &value); + + QString getNickName() const; + void setNickName(const QString &value); + + QDate getBirthday() const; + void setBirthday(const QDate &value); + + Gender getGender() const; + void setGender(const Gender &value); + + QString getCustomPictureFileName() const; + void setCustomPictureFileName(const QString &value); + + QList > getAddresses() const; + void setAddresses(const QList > &value); + + void addAddress(Address *address); + + protected: + QString firstName; + QString familyName; + QString namePrefix; + QString nickName; + QDate birthday; + Gender gender; + QString customPictureFileName; + QList > addresses; + + +}; + + +#endif // PERSON_H diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp index 283bc12..41c0c28 100644 --- a/src/entitymanager.cpp +++ b/src/entitymanager.cpp @@ -173,6 +173,7 @@ bool EntityManager::validate(QSharedPointer &entity) { ValidationRule rule = rules.at(i); QSharedPointer validator = ValidatorFactory::getValidatorObject( rule.getValidatorName()); + qDebug() << "VALIDATOR" << validator; if (validator) { for (int var = 0; var < rule.getAttributes().size(); ++var) { QString attr = rule.getAttributes().at(var); @@ -918,6 +919,12 @@ bool EntityManager::createTable(const QSharedPointer &entity, createRelationTables); } +bool EntityManager::createTable(QString className, bool createRelationTables) { + QSharedPointer e = QSharedPointer + (EntityInstanceFactory::createInstance(className)); + return this->schema->getQueryBuilder()->createTable(e, createRelationTables); +} + quint8 EntityManager::count(const QSharedPointer &entity, bool ignoreID) { qint8 rc = -1; diff --git a/src/entitymanager.h b/src/entitymanager.h index c184c05..02b1c8d 100644 --- a/src/entitymanager.h +++ b/src/entitymanager.h @@ -67,6 +67,7 @@ class EntityManager : public QObject { bool removeAll(QString tblname); bool createTable(const QSharedPointer &entity, bool createRelationTables = true); + bool createTable(QString className, bool createRelationTables = true); quint8 count(const QSharedPointer &entity, bool ignoreID = true); quint8 count(const QString &tableName); QSharedPointer getDb() const;