commit 9cf4747e45c35e2c641172018799bed127159c89
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Tue Mar 31 20:47:52 2015 +0200

    wip

diff --git a/src/database.cpp b/src/database.cpp
index 86c6bcc..31713fc 100644
--- a/src/database.cpp
+++ b/src/database.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "database.h"
-namespace CuteEntityManager {
+using namespace CuteEntityManager;
 
 Database::Database(QSqlDatabase database) {
     this->database = database;
@@ -47,9 +47,8 @@ void Database::init() {
     this->database.open();
     this->databasetype = this->getDatabaseType();
     this->supportTransactions = this->database.driver()->hasFeature(QSqlDriver::Transactions);
-    this->tableList = new QStringList();
+    this->tableList = QStringList();
     this->getTableListFromDatabase();
-    this->createSequenceTable();
 }
 
 
@@ -60,13 +59,6 @@ DatabaseType Database::getDatabaseType() {
 void Database::getTableListFromDatabase() {
     if (this->database.open()) {
         QString q = "";
-        if (this->databasetype == CuteEntityManager::SQLITE) {
-            q = this->sqliteTableList();
-        } else if (this->databasetype == CuteEntityManager::MYSQL) {
-            q = this->mysqlTableList();
-        } else if (this->databasetype == CuteEntityManager::PGSQL) {
-            q = this->pgsqlSeqTable();
-        }
         QSqlQuery query = QSqlQuery(this->database);
         query.prepare(q);
         this->select(query);
@@ -74,13 +66,6 @@ void Database::getTableListFromDatabase() {
     }
 }
 
-void Database::setTableList(QSqlQuery &q) {
-    while (q.next()) {
-        this->tableList->append(q.value(0).toString());
-    }
-}
-
-
 //QString Database::mysqlTableList() {
 //    return "SHOW TABLES;";
 //}
@@ -101,14 +86,6 @@ QString Database::getConnectionName() {
     return this->connectionName;
 }
 
-void Database::setSeqTable(bool seqTable) {
-    this->seqTable = seqTable;
-}
-
-bool Database::isSeqTable() {
-    return this->seqTable;
-}
-
 //QString Database::pgsqlSeqTable() {
 //    return "CREATE TABLE IF NOT EXISTS sequence (SEQ_NAME varchar(255) NOT NULL UNIQUE , SEQ_COUNT bigint NOT NULL);";
 //}
@@ -264,29 +241,6 @@ bool Database::containsTable(QString tblname) {
     return this->tableList->contains(tblname);
 }
 
-void Database::createSequenceTable() {
-    if (this->database.open() && this->getLastId() == -1) {
-        QString query = "";
-        QStringList l = QStringList();
-        if (this->databasetype == CuteEntityManager::MYSQL) {
-            query = this->mysqlSeqTable();
-        } else if (this->databasetype == CuteEntityManager::SQLITE) {
-            query = this->sqliteSeqTable();
-        } else if (this->databasetype == CuteEntityManager::PGSQL) {
-            query = this->pgsqlSeqTable();
-        }
-        l.append(query);
-        l.append(this->querySequenceCounter());
-        if (this->transaction(l)) {
-            this->setSeqTable(true);
-        } else {
-            this->setSeqTable(false);
-        }
-    } else {
-        this->setSeqTable(true);
-    }
-}
-
 bool Database::updateSequenceCounter(QSqlQuery &q) {
     QList<QSqlQuery> l = QList<QSqlQuery>();
     l.append(QSqlQuery("UPDATE sequence SET SEQ_COUNT=(SEQ_COUNT+1);", this->database));
@@ -306,5 +260,3 @@ qint64 Database::getLastId() {
 QSqlDatabase Database::getDatabase() {
     return this->database;
 }
-
-}
diff --git a/src/database.h b/src/database.h
index 843bc88..9120f77 100644
--- a/src/database.h
+++ b/src/database.h
@@ -35,11 +35,8 @@ class Database {
     bool seqTable;
     DatabaseType databasetype;
     bool supportTransactions;
-    void setSeqTable(bool seqTable);
     void init();
-    void createSequenceTable();
-    QString querySequenceCounter();
-    QStringList *tableList;
+    QStringList tableList;
 
   protected:
 //    inline QString pgsqlSeqTable();
@@ -76,7 +73,6 @@ class Database {
     void setTableList(QSqlQuery &q);
     void refreshTableList();
     bool containsTable(QString tblname);
-    bool updateSequenceCounter(QSqlQuery &q);
     DatabaseType getDatabaseType();
     QChar escapeChar();
 };
diff --git a/src/entity.cpp b/src/entity.cpp
index e79ab3d..7f77bc9 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -16,7 +16,7 @@
 
 #include "entity.h"
 
-namespace CuteEntityManager {
+using namespace CuteEntityManager;
 
 Entity::Entity() : QObject() {
     this->id = -1;
@@ -36,4 +36,3 @@ Entity::~Entity() {
 QString Entity::getTablename() {
     return QString(this->metaObject()->className());
 }
-}
diff --git a/src/schema.cpp b/src/schema.cpp
index 206f5b1..304ea21 100644
--- a/src/schema.cpp
+++ b/src/schema.cpp
@@ -1,7 +1,11 @@
 #include "schema.h"
+#include <QRegularExpression>
+#include <QSqlRecord>
+#include <QSqlQuery>
 using namespace CuteEntityManager;
 
-Schema::Schema() {
+Schema::Schema(std::shared_ptr<Database> database) {
+    this->database = database;
     this->typeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
 }
 
@@ -14,61 +18,93 @@ QString Schema::quoteSimpleTableName(QString name) {
 }
 
 QString Schema::quoteTableName(QString name) {
-
+    if (name.indexOf("(") || name.indexOf("{{")) {
+        return name;
+    }
+    if (name.indexOf(".") == -1) {
+        return this->quoteSimpleTableName(name);
+    }
+    QStringList parts = name.split(".");
+    for (int i = 0; i < parts.size(); ++i) {
+        parts.replace(i, this->quoteSimpleTableName(parts.at(i)));
+    }
+    return parts.join(".");
 }
 
 QString Schema::quoteColumnName(QString name) {
-
+    if (name.indexOf("(") || name.indexOf("[[") || name.indexOf("{{")) {
+        return name;
+    }
+    int pos = name.indexOf(".");
+    QString prefix = "";
+    if (pos) {
+        prefix = this->quoteTableName(name.mid(0, pos)) + ".";
+        name = name.mid(pos + 1);
+    }
+    return prefix + this->quoteSimpleColumnName(name);
 }
 
 QString Schema::quoteSimpleColumnName(QString name) {
     return name.indexOf("`") || name == "*" ? name : "`" + name + "`";
 }
 
-QList<TableSchema> Schema::getTableSchemas(QString schema) {
-
+QHash<QString, QSharedPointer<TableSchema> > Schema::getTableSchemas(QString schema, bool refresh) {
+    QStringList names = this->getTableNames();
+    for (int i = 0; i < names.size(); ++i) {
+        QString name;
+        if (schema != "") {
+            name = schema + "." + names.at(i);
+        }
+        TableSchema *t = this->getTableSchema(name, refresh);
+        if (t) {
+            this->tables.insert(name, QSharedPointer<TableSchema>(t));
+        }
+    }
+    return this->tables;
 }
 
 QStringList Schema::getTableNames(QString schema) {
-    //7QStringList QSqlDriver::tables(QSql::TableType tableType) const
+    return this->database.get()->getDatabase().tables();
 }
 
-QStringList Schema::findUniqueIndexes(TableSchema schema) {
-
-}
-
-QString Schema::getLastInsertID(QString sequenceName) {
-
+QVariant Schema::getLastInsertID() {
+    QSqlQuery q(this->database.get()->getDatabase());
+    return q.lastInsertId();
 }
 
 void Schema::refresh() {
-
+    this->tables.clear();
 }
 
 QString Schema::getRawTable(QString name) {
-
-}
-
-QStringList Schema::findTableNames(QString schema) {
-
-}
-
-QStringList Schema::findUniqueIndexes(QString tableName) {
-
-}
-
-TableSchema Schema::findConstraints(TableSchema ts) {
-}
-
-QString Schema::getCreateTableSql(TableSchema ts) {
-
-}
-
-bool Schema::findColumns(TableSchema ts) {
-
-}
-
-TableSchema Schema::getTableSchema(QString name, bool refresh) {
-
+    if (name.indexOf("{{")) {
+        QRegularExpression re("/\\{\\{(.*?)\\}\\}/");
+        QRegularExpression re2("\1");
+        return name.replace(re, re2);
+    }
+    return name;
+}
+
+TableSchema *Schema::getTableSchema(QString name, bool refresh) {
+    if (refresh) {
+        this->refresh();
+    }
+    if (this->tables.contains(name)) {
+        return this->tables.value(name);
+    }
+    QString realName = this->getRawTable(name);
+    QSharedPointer<TableSchema> ts = this->loadTableSchema(realName);
+    if (ts.data()) {
+        this->tables.insert(name, ts);
+    }
+    return ts.data();
+
+}
+QHash<QString, QSharedPointer<TableSchema> > Schema::getTables() const {
+    return this->tables;
+}
+
+void Schema::setTables(const QHash<QString, QSharedPointer<TableSchema> > &value) {
+    tables = value;
 }
 
diff --git a/src/schema.h b/src/schema.h
index 5a96914..8fbc9ea 100644
--- a/src/schema.h
+++ b/src/schema.h
@@ -1,15 +1,18 @@
 #ifndef SCHEMA_H
 #define SCHEMA_H
-#include <QString>
 #include "tableschema.h"
+#include <QStringList>
 #include <QHash>
 #include <QSharedPointer>
+#include <QSqlDatabase>
+#include <memory>
+#include "database.h"
 
 namespace CuteEntityManager {
 
 class Schema {
   public:
-    Schema();
+    Schema(std::shared_ptr<Database> database);
     virtual ~Schema();
     const QString TYPE_PK = "pk";
     const QString TYPE_BIGPK = "bigpk";
@@ -48,27 +51,30 @@ class Schema {
     virtual QString quoteTableName(QString name);
     virtual QString quoteColumnName(QString name);
     virtual QString quoteSimpleColumnName(QString name);
-    virtual QList<TableSchema> getTableSchemas(QString schema = "");
+    virtual QHash<QString, QSharedPointer<TableSchema>> getTableSchemas(QString schema = "", bool refresh = false);
     virtual QStringList getTableNames(QString schema = "");
     //virtual QueryBuilder getQueryBuilder();
     //virtual QueryBuilder createQueryBuilder();
     virtual QStringList findUniqueIndexes(TableSchema schema);
-    virtual QString getLastInsertID(QString sequenceName = "");
+    virtual QVariant getLastInsertID();
     virtual void refresh();
     virtual QString getRawTable(QString name);
 
-
+    QHash<QString, QSharedPointer<TableSchema> > getTables() const;
+    void setTables(const QHash<QString, QSharedPointer<TableSchema> > &value);
 
   protected:
-    virtual QStringList findTableNames(QString schema = "");
-    virtual QStringList findUniqueIndexes(QString tableName);
-    virtual TableSchema findConstraints(TableSchema ts);
-    virtual QString getCreateTableSql(TableSchema ts);
-    virtual bool findColumns(TableSchema ts);
+    virtual QStringList findTableNames(QString schema = "") = 0;
+    virtual QStringList findUniqueIndexes(QString tableName) = 0;
+    virtual QSharedPointer<TableSchema> findConstraints(TableSchema ts) = 0;
+    virtual QString getCreateTableSql(TableSchema ts) = 0;
+    virtual bool findColumns(TableSchema ts) = 0;
     QSharedPointer<QHash<QString, QString>> typeMap;
-    virtual TableSchema loadTableSchema(QString name)  = 0;
-    virtual TableSchema getTableSchema(QString name, bool refresh = false);
-    virtual QStringList findTableNames(QString schema = "");
+    virtual QSharedPointer<TableSchema> *loadTableSchema(QString name)  = 0;
+    virtual TableSchema *getTableSchema(QString name, bool refresh = false);
+    std::shared_ptr<Database> database;
+    QHash<QString, QSharedPointer<TableSchema>> tables;
+
 
 };
 }
diff --git a/src/schema/mysqlschema.cpp b/src/schema/mysqlschema.cpp
index bd2a4cc..603b18d 100644
--- a/src/schema/mysqlschema.cpp
+++ b/src/schema/mysqlschema.cpp
@@ -1,7 +1,8 @@
 #include "mysqlschema.h"
+#include <QSqlQuery>
 using namespace CuteEntityManager;
 
-MysqlSchema::MysqlSchema() : Schema() {
+MysqlSchema::MysqlSchema(std::shared_ptr<Database> database) : Schema(database) {
 
 }
 
@@ -9,8 +10,8 @@ MysqlSchema::~MysqlSchema() {
 
 }
 
-QHash<QString, QString>* MysqlSchema::getTypeMap() {
-    if(this->typeMap.data()->empty()) {
+QHash<QString, QString> *MysqlSchema::getTypeMap() {
+    if (this->typeMap.data()->empty()) {
 //        this->typeMap->data()->insert(TYPE_SMALLINT, 'tinyint');
 //        this->typeMap->data()->insert(TYPE_SMALLINT, 'bit');
 //        this->typeMap->data()->insert(TYPE_BOOLEAN, 'boolean');
diff --git a/src/schema/mysqlschema.h b/src/schema/mysqlschema.h
index 901b2e4..f0c66c4 100644
--- a/src/schema/mysqlschema.h
+++ b/src/schema/mysqlschema.h
@@ -1,10 +1,12 @@
 #ifndef MYSQLSCHEMA_H
 #define MYSQLSCHEMA_H
+#include <memory>
+#include "../database.h"
 #include "../schema.h"
 namespace CuteEntityManager {
 class MysqlSchema : public Schema {
   public:
-    MysqlSchema();
+    MysqlSchema(std::shared_ptr<Database> database);
     ~MysqlSchema();
     QHash<QString, QString> *getTypeMap();
 };
diff --git a/src/schema/pgsqlschema.cpp b/src/schema/pgsqlschema.cpp
index 7abf8a3..c87da29 100644
--- a/src/schema/pgsqlschema.cpp
+++ b/src/schema/pgsqlschema.cpp
@@ -1,7 +1,7 @@
 #include "pgsqlschema.h"
 using namespace CuteEntityManager;
 
-PgSqlSchema::PgSqlSchema() : Schema() {
+PgSqlSchema::PgSqlSchema(std::shared_ptr<Database> database) : Schema(database) {
 
 }
 
@@ -9,8 +9,8 @@ PgSqlSchema::~PgSqlSchema() {
 
 }
 
-QHash<QString, QString>* PgSqlSchema::getTypeMap() {
-    if(this->typeMap.data()->empty()) {
+QHash<QString, QString> *PgSqlSchema::getTypeMap() {
+    if (this->typeMap.data()->empty()) {
 //        this->typeMap->data()->insert(TYPE_SMALLINT, 'tinyint');
 //        this->typeMap->data()->insert(TYPE_SMALLINT, 'bit');
 //        this->typeMap->data()->insert(TYPE_BOOLEAN, 'boolean');
diff --git a/src/schema/pgsqlschema.h b/src/schema/pgsqlschema.h
index 6c0300a..1cb943d 100644
--- a/src/schema/pgsqlschema.h
+++ b/src/schema/pgsqlschema.h
@@ -1,10 +1,12 @@
 #ifndef PGSQLSCHEMA_H
 #define PGSQLSCHEMA_H
+#include <memory>
+#include "../database.h"
 #include "../schema.h"
 namespace CuteEntityManager {
 class PgSqlSchema : public Schema {
   public:
-    PgSqlSchema();
+    PgSqlSchema(std::shared_ptr<Database>database);
     ~PgSqlSchema();
     QHash<QString, QString> *getTypeMap();
 };
diff --git a/src/schema/sqliteschema.cpp b/src/schema/sqliteschema.cpp
index 4a93399..473a436 100644
--- a/src/schema/sqliteschema.cpp
+++ b/src/schema/sqliteschema.cpp
@@ -1,7 +1,7 @@
 #include "sqliteschema.h"
 using namespace CuteEntityManager;
 
-SqliteSchema::SqliteSchema() : Schema() {
+SqliteSchema::SqliteSchema(std::shared_ptr<Database> database) : Schema(database) {
 
 }
 
diff --git a/src/schema/sqliteschema.h b/src/schema/sqliteschema.h
index 11fddbb..3c54213 100644
--- a/src/schema/sqliteschema.h
+++ b/src/schema/sqliteschema.h
@@ -1,11 +1,12 @@
 #ifndef SQLITESCHEMA_H
 #define SQLITESCHEMA_H
-
+#include <memory>
+#include "../database.h"
 #include "../schema.h"
 namespace CuteEntityManager {
 class SqliteSchema : public Schema {
   public:
-    SqliteSchema();
+    SqliteSchema(std::shared_ptr<Database> database);
     ~SqliteSchema();
     QHash<QString, QString> *getTypeMap();
 };