Revision bcd2b697
Von Christian Ehringfeld vor mehr als 8 Jahren hinzugefügt
| EntityManager.pro | ||
|---|---|---|
|
src/join.h \
|
||
|
src/queryinterpreter.h \
|
||
|
src/expression.h \
|
||
|
src/orderby.h
|
||
|
src/orderby.h \
|
||
|
src/sqlitebackupprocessor.h
|
||
|
|
||
|
SOURCES += \
|
||
|
src/entity.cpp \
|
||
| ... | ... | |
|
src/join.cpp \
|
||
|
src/queryinterpreter.cpp \
|
||
|
src/expression.cpp \
|
||
|
src/orderby.cpp
|
||
|
src/orderby.cpp \
|
||
|
src/sqlitebackupprocessor.cpp
|
||
|
|
||
|
CONFIG += c++14
|
||
|
QMAKE_CXXFLAGS += -std=c++14
|
||
|
|
||
|
LIBS += -lsqlite3
|
||
|
unix {
|
||
|
target.path = /usr/lib
|
||
|
INSTALLS += target
|
||
| samples/example/main.cpp | ||
|---|---|---|
|
#include "models/faker/createfakemodeldata.h"
|
||
|
#include "querybuilder.h"
|
||
|
#include "orderby.h"
|
||
|
#include "sqlitebackupprocessor.h"
|
||
|
|
||
|
using namespace CuteEntityManager;
|
||
|
int main(int argc, char *argv[]) {
|
||
|
Q_UNUSED(argc) Q_UNUSED(argv)
|
||
|
QTime t;
|
||
|
t.start();
|
||
|
|
||
|
CuteEntityManager::EntityManager *e = new
|
||
|
// CuteEntityManager::EntityManager("QSQLITE",
|
||
|
// QDir::currentPath() + "/db.sqlite", "", "", "", 0, true);
|
||
|
//QSqlDatabase db = QSqlDatabase()
|
||
|
CuteEntityManager::EntityManager("QSQLITE",
|
||
|
QDir::currentPath() + "/db.sqlite", "", "", "", 0, true);
|
||
|
// CuteEntityManager::EntityManager("QSQLITE",
|
||
|
// ":memory:");
|
||
|
|
||
|
":memory:");
|
||
|
SqliteBackupProcessor *sqliteproc = new SqliteBackupProcessor(e->getDb(),
|
||
|
QDir::currentPath());
|
||
|
qWarning() << "DB Loaded:" << sqliteproc->sqliteDBMemFile(false, "db.sqlite");
|
||
|
/**
|
||
|
* @brief EntityInstanceFactory::registerClass<EntityClass>
|
||
|
* You must register every EntityClass, cause Qt is not creating all meta object informations for entity manager
|
||
| ... | ... | |
|
* Instead of startup(version,qstringlist) you can call method createTable of EntityManager (e->create(sharedptr))
|
||
|
* startup will create tables inclusive relation tables for classes in QStringList inits
|
||
|
*/
|
||
|
e->startup("0.1", inits);
|
||
|
qWarning() << "Tables created:" << e->startup("0.1", inits);
|
||
|
QSharedPointer<CuteEntityManager::Entity> p =
|
||
|
QSharedPointer<CuteEntityManager::Entity>(new Person("Max", "Mustermann",
|
||
|
Person::Gender::MALE, "", "", "",
|
||
| ... | ... | |
|
e->remove(entityGroupFindPtr);
|
||
|
|
||
|
qWarning() << "Duration:" << t.elapsed();
|
||
|
sqliteproc->sqliteDBMemFile(true, "db.sqlite");
|
||
|
delete sqliteproc;
|
||
|
return 0;
|
||
|
}
|
||
| src/entitymanager.cpp | ||
|---|---|---|
|
return this->schema->getQueryBuilder();
|
||
|
}
|
||
|
|
||
|
EntityManager::EntityManager(QSqlDatabase database) : QObject() {
|
||
|
auto db = new Database(database);
|
||
|
EntityManager::EntityManager(QSqlDatabase database,
|
||
|
bool logQueries) : QObject() {
|
||
|
auto db = new Database(database, true, logQueries);
|
||
|
this->db = QSharedPointer<Database>(db);
|
||
|
this->init();
|
||
|
}
|
||
| ... | ... | |
|
if (!propertyIsValid) {
|
||
|
qWarning() << "Relation is incomplete:" << r.getPropertyName();
|
||
|
qWarning() << "Involved entities: " << EntityHelper::getClassName(
|
||
|
e.data()) <<
|
||
|
"(MainEntitiy) and " << EntityHelper::getClassName(relatedEntity.data());
|
||
|
e.data()) <<
|
||
|
"(MainEntitiy) and " << EntityHelper::getClassName(relatedEntity.data());
|
||
|
}
|
||
|
return propertyIsValid;
|
||
|
}
|
||
| ... | ... | |
|
void EntityManager::missingManyToManyTable(const QString &tblName,
|
||
|
const QSharedPointer<Entity> &e, const Relation &r) {
|
||
|
qWarning() << "MANY_TO_MANY Table " << tblName << " is missing";
|
||
|
qWarning() << "Entity " << EntityHelper::getClassName(e.data()) << " is affected";
|
||
|
qWarning() << "Entity " << EntityHelper::getClassName(e.data()) <<
|
||
|
" is affected";
|
||
|
qWarning() << "Relation of property: " << r.getPropertyName();
|
||
|
/**
|
||
|
@todo wait for Qt 5.5.1
|
||
| ... | ... | |
|
}
|
||
|
rc = this->db->exec(query);
|
||
|
if (!rc) {
|
||
|
qWarning() << "class is erroneous:" << EntityHelper::getClassname(entity.data());
|
||
|
qWarning() << "class is erroneous:" << EntityHelper::getClassname(
|
||
|
entity.data());
|
||
|
break;
|
||
|
}
|
||
|
if (first) {
|
||
| src/entitymanager.h | ||
|---|---|---|
|
qint8 count(Query &query);
|
||
|
|
||
|
public:
|
||
|
EntityManager(QSqlDatabase database);
|
||
|
EntityManager(QSqlDatabase database, bool logQueries = false);
|
||
|
EntityManager(const QString &databaseType, QString databasename = "" ,
|
||
|
QString hostname = "",
|
||
|
QString username = "",
|
||
| src/sqlitebackupprocessor.cpp | ||
|---|---|---|
|
#include "sqlitebackupprocessor.h"
|
||
|
#include "sqlite3.h"
|
||
|
#include <sqlite3.h>
|
||
|
|
||
|
using namespace CuteEntityManager;
|
||
|
SqliteBackupProcessor::SqliteBackupProcessor(QSharedPointer<Database> database,
|
||
|
QString destination) {
|
||
|
QString destination) : QObject() {
|
||
|
this->database = database;
|
||
|
this->destination = destination;
|
||
|
}
|
||
|
|
||
|
SqliteBackupProcessor::~SqliteBackupProcessor() {
|
||
|
|
||
|
}
|
||
|
QSharedPointer<Database> SqliteBackupProcessor::getDatabase() const {
|
||
|
return database;
|
||
|
}
|
||
| ... | ... | |
|
destination = value;
|
||
|
}
|
||
|
|
||
|
bool SqliteBackupProcessor::backup(QString fileName = "db.sqlite.bak") {
|
||
|
/**
|
||
|
* @see http://www.qtcentre.org/threads/36131-Attempting-to-use-Sqlite-backup-api-from-driver-handle-fails
|
||
|
* @brief SqliteBackupProcessor::backup
|
||
|
* @param fileName
|
||
|
* @return
|
||
|
* This function is used to load the contents of a database file on disk
|
||
|
* into the "main" database of open database connection pInMemory, or
|
||
|
* to save the current contents of the database opened by pInMemory into
|
||
|
* a database file on disk. pInMemory is probably an in-memory database,
|
||
|
* but this function will also work fine if it is not.
|
||
|
*
|
||
|
* Parameter zFilename points to a nul-terminated string containing the
|
||
|
* name of the database file on disk to load from or save to. If parameter
|
||
|
* isSave is non-zero, then the contents of the file zFilename are
|
||
|
* overwritten with the contents of the database opened by pInMemory. If
|
||
|
* parameter isSave is zero, then the contents of the database opened by
|
||
|
* pInMemory are replaced by data loaded from the file zFilename.
|
||
|
*
|
||
|
* If the operation is successful, SQLITE_OK is returned. Otherwise, if
|
||
|
* an error occurs, an SQLite error code is returned.
|
||
|
*/
|
||
|
bool SqliteBackupProcessor::sqliteDBMemFile(bool save, QString fileName) {
|
||
|
bool state = false;
|
||
|
bool save = true;
|
||
|
QVariant v = this->database->getDatabase().driver()->handle();
|
||
|
if ( v.isValid() && qstrcmp(v.typeName(), "sqlite3*") == 0 ) {
|
||
|
// v.data() returns a pointer to the handle
|
||
| ... | ... | |
|
** for any reason. */
|
||
|
rc = sqlite3_open( zFilename, &pFile );
|
||
|
if ( rc == SQLITE_OK ) {
|
||
|
|
||
|
/* If this is a 'load' operation (isSave==0), then data is copied
|
||
|
** from the database file just opened to database pInMemory.
|
||
|
** Otherwise, if this is a 'save' operation (isSave==1), then data
|
||
| ... | ... | |
|
** pTo accordingly. */
|
||
|
pFrom = ( save ? pInMemory : pFile);
|
||
|
pTo = ( save ? pFile : pInMemory);
|
||
|
|
||
|
/* Set up the backup procedure to copy from the "main" database of
|
||
|
** connection pFile to the main database of connection pInMemory.
|
||
|
** If something goes wrong, pBackup will be set to NULL and an error
|
||
| ... | ... | |
|
}
|
||
|
rc = sqlite3_errcode(pTo);
|
||
|
}
|
||
|
|
||
|
/* Close the database connection opened on database file zFilename
|
||
|
** and return the result of this function. */
|
||
|
(void)sqlite3_close(pFile);
|
||
|
|
||
|
if ( rc == SQLITE_OK ) {
|
||
|
state = true;
|
||
|
}
|
||
| src/sqlitebackupprocessor.h | ||
|---|---|---|
|
namespace CuteEntityManager {
|
||
|
class SqliteBackupProcessor : public QObject {
|
||
|
public:
|
||
|
SqliteBackupProcessor(QSharedPointer<Database> database, QString destination);
|
||
|
explicit SqliteBackupProcessor(QSharedPointer<Database> database, QString destination);
|
||
|
~SqliteBackupProcessor();
|
||
|
QSharedPointer<Database> getDatabase() const;
|
||
|
void setDatabase(const QSharedPointer<Database> &value);
|
||
|
|
||
| ... | ... | |
|
void setDestination(const QString &value);
|
||
|
|
||
|
public slots:
|
||
|
bool backup(QString fileName);
|
||
|
bool sqliteDBMemFile(bool save,QString fileName= "db.sqlite.bak");
|
||
|
private:
|
||
|
QSharedPointer<Database> database;
|
||
|
QString destination;
|
||
Auch abrufbar als: Unified diff
sqlitebackups