commit b0bf458ea9c799ed5425bc667242201e120bf61e
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Sun Apr 12 00:06:01 2015 +0200

    wip

diff --git a/EntityManager.pro b/EntityManager.pro
index 6c46d47..90d4827 100644
--- a/EntityManager.pro
+++ b/EntityManager.pro
@@ -23,8 +23,9 @@ src/entity.h \
     src/tableschema.h \
     src/schema/pgsqlschema.h \
     src/schema/mysqlschema.h \
+    src/databasemigration.h \
     src/querybuilder.h \
-    src/databasemigration.h
+    src/schema/sqlitequerybuilder.h
 
 SOURCES += \
 src/entity.cpp \
@@ -35,8 +36,9 @@ src/entity.cpp \
     src/tableschema.cpp \
     src/schema/pgsqlschema.cpp \
     src/schema/mysqlschema.cpp \
+    src/databasemigration.cpp \
     src/querybuilder.cpp \
-    src/databasemigration.cpp
+    src/schema/sqlitequerybuilder.cpp
 
 unix {
     target.path = /usr/lib
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index b641868..25aa866 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -16,8 +16,6 @@
 
 #include "entitymanager.h"
 #include "enums/databasetype.h"
-#include <QMetaObject>
-#include <QMetaProperty>
 using namespace CuteEntityManager;
 /**
  * Relationen fehlen noch
@@ -30,6 +28,7 @@ void EntityManager::init() {
     auto schema = CuteEntityManager::getSchema(CuteEntityManager::getDatabaseType(
                       this->db.data()->getDatabase().driverName()), this->db);
     this->schema = QSharedPointer<Schema>(schema);
+    this->schema.data()->setTables(this->schema.data()->getTableSchemas());
 }
 
 EntityManager::EntityManager(QSqlDatabase database) {
@@ -46,17 +45,16 @@ EntityManager::EntityManager(const QString &databaseType, QString databasename ,
     this->init();
 }
 
-//inline bool EntityManager::checkTable(Entity *entity) {
-//    bool rc = true;
-//    if (!this->db->containsTable(entity->getTablename())) {
-//        qDebug() << "Tabelle" <<  entity->getTablename() << "existiert noch nicht.";
-//        if (this->createTable(entity)) {
-//            this->db->refreshTableList();
-//            rc = this->db->containsTable(entity->getTablename());
-//        }
-//    }
-//    return rc;
-//}
+bool EntityManager::checkTable(const QSharedPointer<Entity> &entity) {
+    bool rc = true;
+    if (!this->schema.data()->containsTable(entity.data()->getTablename())) {
+        if (this->schema.data()->getQueryBuilder().data()->createTable(entity)) {
+            this->schema.data()->getTableSchema(entity.data()->getTablename(), true);
+            rc = this->schema.data()->getTables().contains(entity.data()->getTablename());
+        }
+    }
+    return rc;
+}
 
 QSharedPointer<Database> EntityManager::getDb() const {
     return db;
@@ -74,46 +72,6 @@ void EntityManager::setSchema(const QSharedPointer<Schema> &value) {
     schema = value;
 }
 
-QHash<QString, QVariant> EntityManager::getEntityAttributes(const QSharedPointer<Entity> &entity) {
-    Entity *e = entity.data();
-    auto map = QHash<QString, QVariant>();
-    auto metaObject = e->metaObject();
-    auto transientAttrs = e->getTransientAttributes();
-    for (int var = 0; var < metaObject->propertyCount(); ++var) {
-        auto p = metaObject->property(var);
-        QString name = QString(p.name());
-        if (p.isValid() && !transientAttrs.contains(name)) {
-            QVariant v = p.read(e);
-            //Relation
-            if (v.canConvert<Entity *>()) {
-                this->insertRelationId(qvariant_cast<Entity *>(v),map,name);
-            } else if (v.canConvert<QSharedPointer<Entity>>()) {
-                this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(),map,name);
-            } else if (QString(p.typeName()).contains("QList")) {
-                /**
-                  @TODO
-                  //List and/or ManyToManyRelation
-                  */
-                auto n = static_cast<QList<CuteEntityManager::Entity *>*>(v.data());
-                for (int var = 0; var < n->size(); ++var) {
-                    CuteEntityManager::Entity *entity = n->at(var);
-                    qDebug() << entity->toString();
-                }
-            } else {
-                map.insert(name, v);
-            }
-        }
-    }
-    return map;
-}
-
-void EntityManager::insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) {
-    if (e && e->getId() > -1) {
-        map.insert(relName + "_id", e->getId());
-    }
-}
-
-
 QString EntityManager::createConnection() {
     QStringList l = EntityManager::getConnectionNames();
     QString conName = "";
@@ -334,40 +292,6 @@ bool EntityManager::remove(QSharedPointer<Entity> &entity) {
     return rc;
 }
 
-//QString EntityManager::createTableQuery(QSharedPointer<Entity> entity) {
-//    QChar c = this->db->escapeChar();
-//    QHash<QString, QString> m = entity->getProperties(this->db->getDatabaseType());
-//    bool first = true;
-//    QString s = "CREATE TABLE IF NOT EXISTS ";
-//    s.append(c).append(entity->getTablename()).append(c).append("(");
-//    QHash<QString, QString>::const_iterator i = m.constBegin();
-//    while (i != m.constEnd()) {
-//        if (first) {
-//            first = false;
-//        } else {
-//            s.append(',');
-//        }
-//        s.append(c).append(i.key()).append(c).append(" " + i.value());
-//        ++i;
-//    }
-//    s.append(");");
-//    return s;
-//}
-
-//bool EntityManager::createTable(Entity *entity) {
-//    bool rc = false;
-//    this->db->containsTable(entity->getTablename()) ? rc = true : rc = false;
-//    if (!rc) {
-//        QSqlQuery q = this->db->getQuery(this->createTableQuery(entity));
-//        if (this->db->transaction(q)) {
-//            this->db->refreshTableList();
-//            rc = true;
-//        }
-//    }
-//    return rc;
-
-//}
-
 void EntityManager::setConnectionNames(QStringList list) {
     EntityManager::connectionNames = list;
 }
diff --git a/src/entitymanager.h b/src/entitymanager.h
index 4b28c67..bef9df1 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -49,7 +49,6 @@ class EntityManager {
     void init();
     QString where(const QSharedPointer<Entity> &entity, QString conjunction = ",", bool ignoreID = false);
     QString where(const QHash<QString, QVariant> &m, const QString &conjunction = ",", bool ignoreID = false);
-    void insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName);
 
   public:
     EntityManager(QSqlDatabase database);
@@ -75,7 +74,6 @@ class EntityManager {
     void setDb(const QSharedPointer<Database> &value);
     QSharedPointer<Schema> getSchema() const;
     void setSchema(const QSharedPointer<Schema> &value);
-    QHash<QString, QVariant> getEntityAttributes(const QSharedPointer<Entity> &entity);
 
 };
 }
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index 4cef13f..6baa919 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -1,21 +1,127 @@
 #include "querybuilder.h"
+#include "database.h"
+#include <QMetaObject>
+#include <QMetaProperty>
+#include "entity.h"
+using namespace CuteEntityManager;
 
-QueryBuilder::QueryBuilder() {
+//bool QueryBuilder::createTable(QString tablename, QHash<QString, QString> tableDefinition) {
+////    QHash<QString, QString> Artikel::getProperties(DatabaseType type) {
+////        QHash<QString, QString> h = QHash<QString, QString>();
+////        h.insert("id",this->idColumnSQL());
+////        h.insert("preis","DOUBLE");
+////        h.insert("name","TEXT");
+////        return h;
+////    }
+//}
 
+QueryBuilder::QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database) {
+    this->schema = schema;
+    this->database = database;
 }
 
-QueryBuilder::~QueryBuilder() {
+bool QueryBuilder::createTable(const QSharedPointer<Entity> &entity) const {
+    return this->createTable(entity.data()->getTablename(), this->generateTableDefinition(entity));
+}
+
+bool QueryBuilder::createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
+    bool rc = false;
+    this->schema.data()->containsTable(tableName) ? rc = true : rc = false;
+    if (!rc) {
+        QSqlQuery q = this->database.data()->getQuery(this->createTableQuery(tableName, tableDefinition));
+        if (this->database.data()->transaction(q)) {
+            this->schema.data()->getTableSchema(tableName);
+            rc = true;
+        }
+    }
+    return rc;
+}
+
+QString QueryBuilder::createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
+    bool first = true;
+    QString s = "CREATE TABLE ";
+    s.append(this->schema.data()->quoteTableName(tableName).append(" (\n"));
+    QHash<QString, QString>::const_iterator i = tableDefinition.constBegin();
+    while (i != tableDefinition.constEnd()) {
+        if (first) {
+            first = false;
+        } else {
+            s.append(',');
+        }
+        s.append(this->schema.data()->quoteColumnName(i.key())).append(" " + i.value());
+        ++i;
+    }
+    s.append("\n);");
+    return s;
+}
+
+QSharedPointer<Database> QueryBuilder::getDatabase() const {
+    return database;
+}
 
+void QueryBuilder::setDatabase(const QSharedPointer<Database> &value) {
+    database = value;
 }
 
-bool QueryBuilder::createTable(QString tablename, QHash<QString, QString> tableDefinition) {
-//    QHash<QString, QString> Artikel::getProperties(DatabaseType type) {
-//        QHash<QString, QString> h = QHash<QString, QString>();
-//        h.insert("id",this->idColumnSQL());
-//        h.insert("preis","DOUBLE");
-//        h.insert("name","TEXT");
-//        return h;
-//    }
+QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPointer<Entity> &entity) const {
+    auto map = QHash<QString, QString>();
+    auto o = entity.data()->metaObject();
+    for (int var = 0; var < o->propertyCount(); ++var) {
+        auto m = o->property(var);
+        if (m.isReadable() && !entity.data()->getTransientAttributes().contains(m.name())) {
+            m.typeName();
+            /**
+              @TODO
+              */
+        }
+    }
+    return map;
+}
+
+QHash<QString, QVariant> QueryBuilder::getEntityAttributes(const QSharedPointer<Entity> &entity) {
+    Entity *e = entity.data();
+    auto map = QHash<QString, QVariant>();
+    auto metaObject = e->metaObject();
+    auto transientAttrs = e->getTransientAttributes();
+    for (int var = 0; var < metaObject->propertyCount(); ++var) {
+        auto p = metaObject->property(var);
+        QString name = QString(p.name());
+        if (p.isValid() && !transientAttrs.contains(name)) {
+            QVariant v = p.read(e);
+            //Relation
+            if (v.canConvert<Entity *>()) {
+                this->insertRelationId(qvariant_cast<Entity *>(v), map, name);
+            } else if (v.canConvert<QSharedPointer<Entity>>()) {
+                this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(), map, name);
+            } else if (QString(p.typeName()).contains("QList")) {
+                /**
+                  @TODO
+                  //List and/or ManyToManyRelation
+                  */
+                auto n = static_cast<QList<CuteEntityManager::Entity *>*>(v.data());
+                for (int var = 0; var < n->size(); ++var) {
+                    CuteEntityManager::Entity *entity = n->at(var);
+                    qDebug() << entity->toString();
+                }
+            } else {
+                map.insert(name, v);
+            }
+        }
+    }
+    return map;
+}
+
+void QueryBuilder::insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) {
+    if (e && e->getId() > -1) {
+        map.insert(relName + "_id", e->getId());
+    }
+}
+
+QSharedPointer<Schema> QueryBuilder::getSchema() const {
+    return schema;
+}
 
+void QueryBuilder::setSchema(const QSharedPointer<Schema> &value) {
+    schema = value;
 }
 
diff --git a/src/querybuilder.h b/src/querybuilder.h
index 539b0f4..269c2ae 100644
--- a/src/querybuilder.h
+++ b/src/querybuilder.h
@@ -1,14 +1,50 @@
 #ifndef QUERYBUILDER_H
 #define QUERYBUILDER_H
-#include "schema.h"
+#include <QString>
+#include <QHash>
+#include <QSharedPointer>
+namespace CuteEntityManager {
+class Schema;
+class Entity;
+class Database;
+class QueryBuilder {
+  public:
+    QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
+    virtual ~QueryBuilder();
+    virtual bool createTable(const QSharedPointer<Entity> &entity) const;
+    virtual bool createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
+    virtual QString createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
+    virtual bool renameTable(QString tableName, QString newName) const;
+    virtual bool dropTable(QString tableName) const;
+    virtual bool truncateTable(QString tableName) const;
+    virtual bool addColumn(QString tableName, QString columnName, QString columnType) const;
+    virtual QString dropColumn(QString tableName, QString columName)const;
+    virtual QString renameColumn(QString tableName, QString oldName, QString newName);
+    virtual QString alterColumn(QString tableName, QString columnName, QString newType)const;
+    virtual QString addPrimaryKey(QString name, QString tableName, QStringList columns)const;
+    virtual QString dropPrimaryKey(QString name, QString tableName) const;
+    virtual QString addForeignKey(QString name, QString tableName, QStringList columns, QString refTableName,
+                                  QStringList refColumns, QString deleteConstraint, QString updateConstraint);
+    virtual QString dropForeignKey(QString name, QString tableName) const;
+    virtual QString createIndex(QString name, QString tableName, QStringList columns, bool unique)const;
+    virtual QString dropIndex(QString name, QString tableName)const;
+    QHash<QString, QVariant> getEntityAttributes(const QSharedPointer<Entity> &entity);
+    QSharedPointer<Schema> getSchema() const;
+    void setSchema(const QSharedPointer<Schema> &value);
 
-class QueryBuilder
-{
-public:
-    QueryBuilder();
-    ~QueryBuilder();
-    bool createTable(QString tablename, QHash<QString, QString> tableDefinition);
+    QSharedPointer<Database> getDatabase() const;
+    void setDatabase(const QSharedPointer<Database> &value);
 
+    QHash<QString, QString> generateTableDefinition(const QSharedPointer<Entity> &entity) const;
+
+
+  protected:
+    void insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName);
+
+
+    QSharedPointer<Schema> schema;
+    QSharedPointer<Database> database;
 };
+}
 
 #endif // QUERYBUILDER_H
diff --git a/src/schema.cpp b/src/schema.cpp
index 1786e7c..0118900 100644
--- a/src/schema.cpp
+++ b/src/schema.cpp
@@ -8,12 +8,44 @@ using namespace CuteEntityManager;
 Schema::Schema(QSharedPointer<Database> database) {
     this->database = database;
     this->typeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
+    this->queryBuilder = QSharedPointer<QueryBuilder>();
 }
 
 Schema::~Schema() {
 
 }
 
+QHash<QString, QString> Schema::getAbstractDatabaseTypes() {
+    auto typeMap = QHash<QString, QString>();
+    typeMap.insert("bool", TYPE_SMALLINT);
+    typeMap.insert("short", TYPE_SMALLINT);
+    typeMap.insert("int", TYPE_INTEGER);
+    typeMap.insert("long", TYPE_INTEGER);
+    typeMap.insert("long long", TYPE_INTEGER);
+    typeMap.insert("float", TYPE_FLOAT);
+    typeMap.insert("double", TYPE_FLOAT);
+    typeMap.insert("long double", TYPE_FLOAT);
+    typeMap.insert("qint", TYPE_INTEGER);
+    typeMap.insert("quint", TYPE_INTEGER);
+    typeMap.insert("quuid", TYPE_INTEGER);
+    typeMap.insert("qfloat", TYPE_FLOAT);
+    typeMap.insert("unsigned short", TYPE_SMALLINT);
+    typeMap.insert("unsigned int", TYPE_INTEGER);
+    typeMap.insert("unsigned long", TYPE_INTEGER);
+    typeMap.insert("unsigned long long", TYPE_INTEGER);
+    typeMap.insert("char",TYPE_CHAR);
+    typeMap.insert("std::string", TYPE_TEXT);
+    typeMap.insert("QString", TYPE_TEXT);
+    typeMap.insert("QVariant", TYPE_TEXT);
+    typeMap.insert("QUuid", TYPE_TEXT);
+    typeMap.insert("QDate", TYPE_DATE);
+    typeMap.insert("QTime", TYPE_TIME);
+    typeMap.insert("QDateTime", TYPE_DATETIME);
+    typeMap.insert("QByteArray", TYPE_BINARY);
+    typeMap.insert("QBitArray", TYPE_BINARY);
+    return typeMap;
+}
+
 QString Schema::quoteSimpleTableName(QString name) {
     return name.indexOf("`") ? name : "`" + name + "`";
 }
@@ -56,10 +88,7 @@ QHash<QString, QSharedPointer<TableSchema> > Schema::getTableSchemas(QString sch
         if (schema != "") {
             name = schema + "." + names.at(i);
         }
-        TableSchema *t = this->getTableSchema(name, refresh);
-        if (t) {
-            this->tables.insert(name, QSharedPointer<TableSchema>(t));
-        }
+        this->getTableSchema(name, refresh);
     }
     return this->tables;
 }
@@ -89,23 +118,19 @@ bool Schema::containsTable(QString tblname) {
     return this->tables.contains(tblname);
 }
 
-QString Schema::quoteValue(QString str) {
-
-}
-
-TableSchema *Schema::getTableSchema(QString name, bool refresh) {
+QSharedPointer<TableSchema> Schema::getTableSchema(QString name, bool refresh) {
     if (refresh) {
         this->refresh();
     }
     if (this->tables.contains(name)) {
-        return this->tables.value(name).data();
+        return this->tables.value(name);
     }
     QString realName = this->getRawTable(name);
     auto ts = this->loadTableSchema(realName);
     if (ts.data()) {
         this->tables.insert(name, ts);
     }
-    return ts.data();
+    return ts;
 }
 
 QSharedPointer<Database> Schema::getDatabase() const {
@@ -115,6 +140,9 @@ QSharedPointer<Database> Schema::getDatabase() const {
 void Schema::setDatabase(const QSharedPointer<Database> &value) {
     database = value;
 }
+QSharedPointer<QueryBuilder> Schema::getQueryBuilder() const {
+    return queryBuilder;
+}
 
 QHash<QString, QSharedPointer<TableSchema> > Schema::getTables() const {
     return this->tables;
diff --git a/src/schema.h b/src/schema.h
index 03466a8..f04b3bc 100644
--- a/src/schema.h
+++ b/src/schema.h
@@ -5,6 +5,7 @@
 #include <QHash>
 #include <QSharedPointer>
 #include <QSqlField>
+#include "querybuilder.h"
 namespace CuteEntityManager {
 class Database;
 class Schema {
@@ -45,19 +46,19 @@ class Schema {
 
 
     virtual QHash<QString, QString> *getTypeMap() = 0;
+    QHash<QString, QString> getAbstractDatabaseTypes();
     virtual QString quoteSimpleTableName(QString name);
     virtual QString quoteTableName(QString name);
     virtual QString quoteColumnName(QString name);
     virtual QString quoteSimpleColumnName(QString name);
     virtual QHash<QString, QSharedPointer<TableSchema>> getTableSchemas(QString schema = "", bool refresh = false);
+    virtual QSharedPointer<TableSchema> getTableSchema(QString name, bool refresh = false);
     virtual QStringList getTableNames(QString schema = "");
-    //virtual QueryBuilder getQueryBuilder();
-    //virtual QueryBuilder createQueryBuilder();
     virtual QVariant getLastInsertID();
     virtual void refresh();
     virtual QString getRawTable(QString name);
     virtual bool containsTable(QString tblname);
-    virtual QString quoteValue(QString str);
+    virtual void initQueryBuilder();
 
     QHash<QString, QSharedPointer<TableSchema> > getTables() const;
     void setTables(const QHash<QString, QSharedPointer<TableSchema> > &value);
@@ -65,16 +66,18 @@ class Schema {
     QSharedPointer<Database> getDatabase() const;
     void setDatabase(const QSharedPointer<Database> &value);
 
+    QSharedPointer<QueryBuilder> getQueryBuilder() const;
+
 protected:
     virtual QStringList findTableNames(QString schema = "") = 0;
     virtual QHash<QString, QStringList> findUniqueIndexes(const QSharedPointer<TableSchema> &table) = 0;
     virtual void findConstraints(const QSharedPointer<TableSchema> &ts) = 0;
     virtual bool findColumns(const QSharedPointer<TableSchema> &ts) = 0;
     virtual QSharedPointer<TableSchema> loadTableSchema(QString name)  = 0;
-    virtual TableSchema *getTableSchema(QString name, bool refresh = false);
     QSharedPointer<Database> database;
     QSharedPointer<QHash<QString, QString>> typeMap;
     QHash<QString, QSharedPointer<TableSchema>> tables;
+    QSharedPointer<QueryBuilder> queryBuilder;
 
 
 };
diff --git a/src/schema/sqlitequerybuilder.cpp b/src/schema/sqlitequerybuilder.cpp
new file mode 100644
index 0000000..6f814bb
--- /dev/null
+++ b/src/schema/sqlitequerybuilder.cpp
@@ -0,0 +1,11 @@
+#include "sqlitequerybuilder.h"
+
+
+CuteEntityManager::SqliteQueryBuilder::SqliteQueryBuilder(QSharedPointer<CuteEntityManager::Schema> schema,
+        QSharedPointer<CuteEntityManager::Database> database) : QueryBuilder(schema, database) {
+
+}
+
+CuteEntityManager::SqliteQueryBuilder::~SqliteQueryBuilder() {
+
+}
diff --git a/src/schema/sqlitequerybuilder.h b/src/schema/sqlitequerybuilder.h
new file mode 100644
index 0000000..ffe6c3b
--- /dev/null
+++ b/src/schema/sqlitequerybuilder.h
@@ -0,0 +1,13 @@
+#ifndef SQLITEQUERYBUILDER_H
+#define SQLITEQUERYBUILDER_H
+#include "../querybuilder.h"
+namespace CuteEntityManager {
+class SqliteQueryBuilder : public QueryBuilder
+{
+public:
+    SqliteQueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
+    ~SqliteQueryBuilder();
+};
+
+}
+#endif // SQLITEQUERYBUILDER_H
diff --git a/src/schema/sqliteschema.cpp b/src/schema/sqliteschema.cpp
index c9c3b64..2aa62fb 100644
--- a/src/schema/sqliteschema.cpp
+++ b/src/schema/sqliteschema.cpp
@@ -2,10 +2,11 @@
 #include "../database.h"
 #include <QSqlRecord>
 #include <QSqlResult>
+#include "sqlitequerybuilder.h"
 using namespace CuteEntityManager;
 
 SqliteSchema::SqliteSchema(QSharedPointer<Database> database) : Schema(database) {
-
+    this->queryBuilder = QSharedPointer<QueryBuilder>(new SqliteQueryBuilder(QSharedPointer<Schema>(this), database));
 }
 
 SqliteSchema::~SqliteSchema() {
@@ -13,29 +14,6 @@ SqliteSchema::~SqliteSchema() {
 }
 
 QHash<QString, QString> *SqliteSchema::getTypeMap() {
-    /**
-   this->typeMap.data()->insert("bool", "SMALLINT");
-   this->typeMap.data()->insert("short", "SMALLINT");
-   this->typeMap.data()->insert("int", "INTEGER");
-   this->typeMap.data()->insert("long", "INTEGER");
-   this->typeMap.data()->insert("long long", "INTEGER");
-   this->typeMap.data()->insert("float", "FLOAT");
-   this->typeMap.data()->insert("double", "FLOAT");
-   this->typeMap.data()->insert("long double", "FLOAT");
-   this->typeMap.data()->insert("unsigned short", "SMALLINT");
-   this->typeMap.data()->insert("unsigned int", "INTEGER");
-   this->typeMap.data()->insert("unsigned long", "INTEGER");
-   this->typeMap.data()->insert("unsigned long long", "INTEGER");
-   this->typeMap.data()->insert("std::string", "TEXT");
-   this->typeMap.data()->insert("std::wstring", "TEXT");
-   this->typeMap.data()->insert("QString", "TEXT");
-   this->typeMap.data()->insert("QVariant", "TEXT");
-   this->typeMap.data()->insert("QUuid", "TEXT");
-   this->typeMap.data()->insert("QDate", "DATE");
-   this->typeMap.data()->insert("QTime", "TIME");
-   this->typeMap.data()->insert("QDateTime", "TIMESTAMP");
-   this->typeMap.data()->insert("QByteArray", "BLOB");
-      */
     if (this->typeMap.data()->empty()) {
         this->typeMap.data()->insert(TYPE_SMALLINT, "tinyint");
         this->typeMap.data()->insert(TYPE_BOOLEAN, "boolean");
@@ -80,7 +58,7 @@ QHash<QString, QStringList> SqliteSchema::findUniqueIndexes(const QSharedPointer
         QSqlQuery q2 = this->database.data()->getQuery();
         q2.setForwardOnly(true);
         if (q.value("unique").toBool()) {
-            q2.exec("PRAGMA index_info(" + this->quoteValue(indexName) + ")");
+            q2.exec("PRAGMA index_info(" + this->quoteSimpleTableName(indexName) + ")");
             QStringList indexInfo = QStringList();
             while (q2.next()) {
                 indexInfo.append(q2.value("name").toString());