commit 426974c6030a4b348d33f6481bf920a69d9f449a
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Wed Mar 25 21:28:38 2015 +0100

    ...

diff --git a/src/columnschema.h b/src/columnschema.h
index dfe326f..242d8d5 100644
--- a/src/columnschema.h
+++ b/src/columnschema.h
@@ -5,9 +5,8 @@
 
 namespace CuteEntityManager {
 
-class ColumnSchema
-{
-public:
+class ColumnSchema {
+  public:
     ColumnSchema();
     ~ColumnSchema();
     QString getName() const;
@@ -46,7 +45,7 @@ public:
     QString getComment() const;
     void setComment(const QString &value);
 
-private:
+  private:
     QString name;
     bool allowNull;
     QString dbType;
diff --git a/src/database.cpp b/src/database.cpp
index 584b02f..4fb66b3 100644
--- a/src/database.cpp
+++ b/src/database.cpp
@@ -25,14 +25,15 @@ Database::Database(QSqlDatabase database) {
 }
 
 Database::Database(QString databaseType, QString connectionName, QString databasename) {
-    this->database = QSqlDatabase::addDatabase(databaseType,connectionName);
+    this->database = QSqlDatabase::addDatabase(databaseType, connectionName);
     this->connectionName = connectionName;
     this->database.setDatabaseName(databasename);
     this->init();
 }
 
-Database::Database(QString databaseType, QString connectionName, QString hostname, QString databasename, QString username, QString password, qint64 port) {
-    this->database = QSqlDatabase::addDatabase(databaseType,connectionName);
+Database::Database(QString databaseType, QString connectionName, QString hostname, QString databasename,
+                   QString username, QString password, qint64 port) {
+    this->database = QSqlDatabase::addDatabase(databaseType, connectionName);
     this->connectionName = connectionName;
     this->database.setHostName(hostname);
     this->database.setDatabaseName(databasename);
@@ -57,13 +58,13 @@ DatabaseType Database::getDatabaseType() {
 }
 
 void Database::getTableListFromDatabase() {
-    if(this->database.open()) {
+    if (this->database.open()) {
         QString q = "";
-        if(this->databasetype == CuteEntityManager::SQLITE) {
+        if (this->databasetype == CuteEntityManager::SQLITE) {
             q = this->sqliteTableList();
-        } else if(this->databasetype == CuteEntityManager::MYSQL){
+        } else if (this->databasetype == CuteEntityManager::MYSQL) {
             q = this->mysqlTableList();
-        } else if(this->databasetype == CuteEntityManager::PGSQL) {
+        } else if (this->databasetype == CuteEntityManager::PGSQL) {
             q = this->pgsqlSeqTable();
         }
         QSqlQuery query = QSqlQuery(this->database);
@@ -74,7 +75,7 @@ void Database::getTableListFromDatabase() {
 }
 
 void Database::setTableList(QSqlQuery &q) {
-    while(q.next()) {
+    while (q.next()) {
         this->tableList->append(q.value(0).toString());
     }
 }
@@ -89,7 +90,7 @@ void Database::setTableList(QSqlQuery &q) {
 //}
 
 Database::~Database() {
-    if(this->database.isOpen()) {
+    if (this->database.isOpen()) {
         this->database.close();
     }
     QSqlDatabase::removeDatabase(this->connectionName);
@@ -122,9 +123,9 @@ QString Database::sqliteSeqTable() {
 
 QChar Database::escapeChar() {
     QChar c = QChar();
-    if(this->databasetype == CuteEntityManager::SQLITE) {
+    if (this->databasetype == CuteEntityManager::SQLITE) {
         c = '\'';
-    } else if(this->databasetype == CuteEntityManager::MYSQL) {
+    } else if (this->databasetype == CuteEntityManager::MYSQL) {
         c = '`';
     }
     return c;
@@ -133,11 +134,11 @@ QChar Database::escapeChar() {
 
 bool Database::transaction(const QString &query) {
     bool rc = false;
-    if(supportTransactions) {
+    if (supportTransactions) {
         this->database.transaction();
         QSqlQuery sqlquery = QSqlQuery(this->database);
         sqlquery.exec(query);
-        if(!this->database.commit()) {
+        if (!this->database.commit()) {
             this->database.rollback();
         }
     } else {
@@ -158,13 +159,13 @@ QSqlQuery Database::getQuery(const QString &prepare) {
 
 bool Database::transaction(const QStringList &queries) {
     bool ok = false;
-    if(this->supportTransactions) {
+    if (this->supportTransactions) {
         this->database.transaction();
         QSqlQuery sqlquery = QSqlQuery(this->database);
         for (int var = 0; var < queries.size(); ++var) {
             sqlquery.exec(queries.at(var));
         }
-        if(!this->database.commit()) {
+        if (!this->database.commit()) {
             this->database.rollback();
         } else {
             ok = true;
@@ -178,7 +179,7 @@ bool Database::transaction(const QStringList &queries) {
 bool Database::transaction(QSqlQuery &query) {
     this->database.transaction();
     query.exec();
-    if(!this->database.commit()) {
+    if (!this->database.commit()) {
         this->database.rollback();
         return false;
     }
@@ -192,7 +193,7 @@ bool Database::transaction(QList<QSqlQuery> &queries) {
         q = queries.at(var);
         q.exec();
     }
-    if(!this->database.commit()) {
+    if (!this->database.commit()) {
         this->database.rollback();
         return false;
     }
@@ -203,19 +204,19 @@ bool Database::exec(QString query) {
     this->database.transaction();
     QSqlQuery q = QSqlQuery(this->database);
     q.exec(query);
-    if(!this->database.commit()) {
+    if (!this->database.commit()) {
         this->database.rollback();
         return false;
     }
     return true;
 }
 
-bool Database::exec(QStringList queries){
+bool Database::exec(QStringList queries) {
     QSqlQuery q = QSqlQuery(this->database);
     bool ok = true;
     for (int var = 0; var < queries.size() && ok; ++var) {
         ok = q.exec(queries.at(var));
-        if(!ok) {
+        if (!ok) {
             break;
         }
     }
@@ -232,7 +233,7 @@ bool Database::exec(QList<QSqlQuery> queries) {
     for (int var = 0; var < queries.size() && ok; ++var) {
         q = queries.at(var);
         ok = q.exec();
-        if(!ok) {
+        if (!ok) {
             break;
         }
     }
@@ -264,19 +265,19 @@ bool Database::containsTable(QString tblname) {
 }
 
 void Database::createSequenceTable() {
-    if(this->database.open() && this->getLastId() == -1) {
+    if (this->database.open() && this->getLastId() == -1) {
         QString query = "";
         QStringList l = QStringList();
-        if(this->databasetype == CuteEntityManager::MYSQL) {
+        if (this->databasetype == CuteEntityManager::MYSQL) {
             query = this->mysqlSeqTable();
-        } else if(this->databasetype == CuteEntityManager::SQLITE) {
+        } else if (this->databasetype == CuteEntityManager::SQLITE) {
             query = this->sqliteSeqTable();
-        } else if(this->databasetype == CuteEntityManager::PGSQL) {
+        } else if (this->databasetype == CuteEntityManager::PGSQL) {
             query = this->pgsqlSeqTable();
         }
         l.append(query);
         l.append(this->querySequenceCounter());
-        if(this->transaction(l)) {
+        if (this->transaction(l)) {
             this->setSeqTable(true);
         } else {
             this->setSeqTable(false);
@@ -288,7 +289,7 @@ void Database::createSequenceTable() {
 
 bool Database::updateSequenceCounter(QSqlQuery &q) {
     QList<QSqlQuery> l = QList<QSqlQuery>();
-    l.append(QSqlQuery("UPDATE sequence SET SEQ_COUNT=(SEQ_COUNT+1);",this->database));
+    l.append(QSqlQuery("UPDATE sequence SET SEQ_COUNT=(SEQ_COUNT+1);", this->database));
     l.append(q);
     return this->transaction(l);
 }
@@ -296,7 +297,7 @@ bool Database::updateSequenceCounter(QSqlQuery &q) {
 qint64 Database::getLastId() {
     qint64 id = -1;
     QSqlQuery q = this->select("SELECT SEQ_COUNT FROM sequence WHERE SEQ_NAME=\'id_count\';");
-    if(q.next()) {
+    if (q.next()) {
         id = q.value(0).toInt();
     }
     return id;
diff --git a/src/database.h b/src/database.h
index fbf7b48..6bebf2e 100644
--- a/src/database.h
+++ b/src/database.h
@@ -28,9 +28,8 @@
 #include "enums/databasetype.h"
 namespace CuteEntityManager {
 
-class Database
-{
-private:
+class Database {
+  private:
     QSqlDatabase database;
     QString connectionName;
     bool seqTable;
@@ -42,7 +41,7 @@ private:
     QString querySequenceCounter();
     QStringList *tableList;
 
-protected:
+  protected:
     inline QString pgsqlSeqTable();
     inline QString mysqlSeqTable();
     inline QString sqliteSeqTable();
@@ -50,12 +49,13 @@ protected:
     inline QString mysqlTableList();
     inline QString pgsqlTableList();
 
-public:
+  public:
     Database(QSqlDatabase database);
     ~Database();
     Database(QString databaseType, QString databasename);
     Database(QString databaseType, QString connectionName, QString databasename);
-    Database(QString databaseType, QString connectionName= "", QString hostname="",QString databasename = "" , QString username ="", QString password="", qint64 port=0);
+    Database(QString databaseType, QString connectionName = "", QString hostname = "", QString databasename = "" ,
+             QString username = "", QString password = "", qint64 port = 0);
     QSqlDatabase getDatabase();
     QString getConnectionName();
     QSqlQuery getQuery();
diff --git a/src/entity.cpp b/src/entity.cpp
index 82ea0e7..ce6da8b 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -18,7 +18,7 @@
 
 namespace CuteEntityManager {
 
-Entity::Entity() : QObject(){
+Entity::Entity() : QObject() {
     this->id = -1;
 }
 
diff --git a/src/entity.h b/src/entity.h
index ba29b38..047493b 100644
--- a/src/entity.h
+++ b/src/entity.h
@@ -25,13 +25,13 @@ namespace CuteEntityManager {
 
 class Entity : public QObject {
     Q_OBJECT
-public:
+  public:
     virtual qint64 getId();
     virtual void setId(qint64 id);
     virtual ~Entity();
     virtual QString getTablename() = 0;
     //  virtual QMap<QString, QString> getManyToManyRelations() = 0;   //Key = Table, Value = joined Table Column
-protected:
+  protected:
     Entity();
     qint64 id;
 };
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index 9ccf5d3..21d2cda 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -27,15 +27,17 @@ EntityManager::EntityManager(QSqlDatabase database) {
     this->db = new Database(database);
 }
 
-EntityManager::EntityManager(const QString &databaseType,QString databasename , QString hostname,QString username, QString password, QString port) {
-    this->db = new Database(databaseType,this->createConnection(),hostname,databasename,username,password,port.toInt());
+EntityManager::EntityManager(const QString &databaseType, QString databasename , QString hostname, QString username,
+                             QString password, QString port) {
+    this->db = new Database(databaseType, this->createConnection(), hostname, databasename, username, password,
+                            port.toInt());
 }
 
 inline bool EntityManager::checkTable(Entity *entity) {
     bool rc = true;
-    if(!this->db->containsTable(entity->getTablename())) {
+    if (!this->db->containsTable(entity->getTablename())) {
         qDebug() << "Tabelle" <<  entity->getTablename() << "existiert noch nicht.";
-        if(this->createTable(entity)) {
+        if (this->createTable(entity)) {
             this->db->refreshTableList();
             rc = this->db->containsTable(entity->getTablename());
         }
@@ -48,13 +50,13 @@ QString EntityManager::createConnection() {
     QString conName = "";
     bool ok = false;
     qint16 i = 0;
-    while(!ok) {
-        if(l.contains("con"+QString::number(i))) {
+    while (!ok) {
+        if (l.contains("con" + QString::number(i))) {
             ++i;
         } else {
-            l.append("con"+QString::number(i));
+            l.append("con" + QString::number(i));
             ok = true;
-            conName = "con"+QString::number(i);
+            conName = "con" + QString::number(i);
             EntityManager::setConnectionNames(l);
         }
     }
@@ -80,9 +82,9 @@ void EntityManager::setConnectionNames(QStringList list) {
 
 void EntityManager::bindValues(const QHash<QString, QVariant> *h, QSqlQuery &q, bool ignoreID) {
     QHash<QString, QVariant>::const_iterator i = h->constBegin();
-    while(i != h->constEnd()) {
-        if(!ignoreID || (ignoreID && !(i.key() == "id"))) {
-            q.bindValue(":"+i.key(),i.value());
+    while (i != h->constEnd()) {
+        if (!ignoreID || (ignoreID && !(i.key() == "id"))) {
+            q.bindValue(":" + i.key(), i.value());
         }
         ++i;
     }
diff --git a/src/entitymanager.h b/src/entitymanager.h
index a980065..6160488 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -28,42 +28,44 @@
 
 namespace CuteEntityManager {
 
-class EntityManager
-{
-private:
+class EntityManager {
+  private:
     static QStringList connectionNames;
     static void setConnectionNames(QStringList list);
     Database *db;
     QString createConnection();
     QString createTableQuery(Entity *entity);
-    QString attributes(QHash<QString, QVariant> *m, QString conjunction=",", bool ignoreID = false);
+    QString attributes(QHash<QString, QVariant> *m, QString conjunction = ",", bool ignoreID = false);
     QList<QHash<QString, QVariant> > convertQueryResult(QSqlQuery &q);
     bool checkTable(Entity *entity);
-    QString buildCreateQuery(QHash<QString,QVariant>::const_iterator i, QHash<QString,QVariant>::const_iterator end,QString &p1, QString &p2);
+    QString buildCreateQuery(QHash<QString, QVariant>::const_iterator i, QHash<QString, QVariant>::const_iterator end,
+                             QString &p1, QString &p2);
     void bindValues(const QHash<QString, QVariant> *h, QSqlQuery &q, bool ignoreID = false);
 
-protected:
-    QString where(Entity *entity,QString conjunction=",",bool ignoreID = false);
-    QString where(QHash<QString, QVariant> *m,QString conjunction=",", bool ignoreID = false);
+  protected:
+    QString where(Entity *entity, QString conjunction = ",", bool ignoreID = false);
+    QString where(QHash<QString, QVariant> *m, QString conjunction = ",", bool ignoreID = false);
 
-public:
+  public:
     EntityManager(QSqlDatabase database);
-    EntityManager(const QString &databaseType, QString databasename = "" , QString hostname="", QString username ="", QString password="", QString port="");
+    EntityManager(const QString &databaseType, QString databasename = "" , QString hostname = "", QString username = "",
+                  QString password = "", QString port = "");
     ~EntityManager();
     static QStringList getConnectionNames();
     static void removeConnectionName(const QString &name);
     bool create(Entity *entity);
     bool save(Entity *entity);
     qint64 findId(Entity *entity);
-    QList<QHash<QString,QVariant> > findAll(QString tblname);
-    QHash<QString,QVariant> find(qint64 id, QString tblname);
-    QList<QHash<QString, QVariant> > findByAttributes(Entity *entity,bool ignoreID = false);
-    QList<QHash<QString, QVariant> > findByAttributes(QHash<QString, QVariant> *m, const QString &tblname, bool ignoreID = false);
+    QList<QHash<QString, QVariant> > findAll(QString tblname);
+    QHash<QString, QVariant> find(qint64 id, QString tblname);
+    QList<QHash<QString, QVariant> > findByAttributes(Entity *entity, bool ignoreID = false);
+    QList<QHash<QString, QVariant> > findByAttributes(QHash<QString, QVariant> *m, const QString &tblname,
+            bool ignoreID = false);
     bool merge(Entity *entity);
     bool remove(Entity *&entity);
     bool removeAll(QString tblname);
     bool createTable(Entity *entity);
-    qint8 count(Entity* entity, bool ignoreID= true);
+    qint8 count(Entity *entity, bool ignoreID = true);
 };
 }
 #endif // ENTITYMANAGER_H
diff --git a/src/enums/databasetype.h b/src/enums/databasetype.h
index 3ca383c..c690e96 100644
--- a/src/enums/databasetype.h
+++ b/src/enums/databasetype.h
@@ -25,15 +25,15 @@
 
 namespace CuteEntityManager {
 enum DatabaseType {
-    SQLITE=0,
-    PGSQL=1,
-    MYSQL=2
+    SQLITE = 0,
+    PGSQL = 1,
+    MYSQL = 2
 };
 
 static const DatabaseType getDatabaseType(QString s) {
-    if(s == "qmysql") {
+    if (s == "qmysql") {
         return CuteEntityManager::MYSQL;
-    } else if(s == "qpgsql") {
+    } else if (s == "qpgsql") {
         return CuteEntityManager::PGSQL;
     } else {
         return CuteEntityManager::SQLITE;
diff --git a/src/schema.cpp b/src/schema.cpp
index 2ac10cc..17f8e1a 100644
--- a/src/schema.cpp
+++ b/src/schema.cpp
@@ -1,8 +1,8 @@
-#include "schema.h"
+#include "schema.h"
 using namespace CuteEntityManager;
 
 Schema::Schema() {
-    this->typeMap = QSharedPointer<QHash<QString,QString>>(new QHash<QString,QString>());
+    this->typeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
 }
 
 Schema::~Schema() {
@@ -13,8 +13,66 @@ QString Schema::quoteSimpleTableName(QString name) {
     //    return strpos($name, "`") !== false ? $name : "`" . $name . "`";
 }
 
-QString Schema::quoteSimpleColumnName(QString name)
-{
-//return strpos($name, '`') !== false || $name === '*' ? $name : '`' . $name . '`';
+QString Schema::quoteTableName(QString name) {
+
+}
+
+QString Schema::quoteColumnName(QString name) {
+
+}
+
+QString Schema::quoteSimpleColumnName(QString name) {
+    //return strpos($name, '`') !== false || $name === '*' ? $name : '`' . $name . '`';
+}
+
+QList<TableSchema> Schema::getTableSchemas(QString schema) {
+
+}
+
+QList<QString> Schema::getTableNames(QString schema) {
+
+}
+
+QList<QString> Schema::findUniqueIndexes(TableSchema schema) {
+
+}
+
+QString Schema::getLastInsertID(QString sequenceName) {
+
+}
+
+void Schema::refresh() {
+
+}
+
+void Schema::quoteValue(QString str) {
+
+}
+
+QString Schema::getRawTable(QString name) {
+
+}
+
+QList<QString> Schema::findTableNames(QString schema) {
+
+}
+
+QList<QString> 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) {
+
 }
 
diff --git a/src/schema.h b/src/schema.h
index 71f2753..5343cba 100644
--- a/src/schema.h
+++ b/src/schema.h
@@ -8,7 +8,7 @@
 namespace CuteEntityManager {
 
 class Schema {
-public:
+  public:
     Schema();
     virtual ~Schema();
     const QString TYPE_PK = "pk";
@@ -45,16 +45,22 @@ public:
 
     virtual QHash<QString, QString> *getTypeMap() = 0;
     virtual QString quoteSimpleTableName(QString name);
+    virtual QString quoteTableName(QString name);
+    virtual QString quoteColumnName(QString name);
     virtual QString quoteSimpleColumnName(QString name);
-    virtual QList<TableSchema> getTableSchemas(QString schema = "", bool refresh = false);
-    virtual QList<QString> getTableNames(QString schema = "", $refresh = false);
+    virtual QList<TableSchema> getTableSchemas(QString schema = "");
+    virtual QList<QString> getTableNames(QString schema = "");
     //virtual QueryBuilder getQueryBuilder();
     //virtual QueryBuilder createQueryBuilder();
     virtual QList<QString> findUniqueIndexes(TableSchema schema);
     virtual QString getLastInsertID(QString sequenceName = "");
     virtual void refresh();
+    virtual void quoteValue(QString str);
+    virtual QString getRawTable(QString name);
 
-protected:
+
+
+  protected:
     virtual QList<QString> findTableNames(QString schema = "");
     virtual QList<QString> findUniqueIndexes(QString tableName);
     virtual TableSchema findConstraints(TableSchema ts);
diff --git a/src/schema/mysqlschema.h b/src/schema/mysqlschema.h
index 7c3157d..901b2e4 100644
--- a/src/schema/mysqlschema.h
+++ b/src/schema/mysqlschema.h
@@ -3,7 +3,7 @@
 #include "../schema.h"
 namespace CuteEntityManager {
 class MysqlSchema : public Schema {
-public:
+  public:
     MysqlSchema();
     ~MysqlSchema();
     QHash<QString, QString> *getTypeMap();
diff --git a/src/schema/pgsqlschema.h b/src/schema/pgsqlschema.h
index 9ed20a7..6c0300a 100644
--- a/src/schema/pgsqlschema.h
+++ b/src/schema/pgsqlschema.h
@@ -3,7 +3,7 @@
 #include "../schema.h"
 namespace CuteEntityManager {
 class PgSqlSchema : public Schema {
-public:
+  public:
     PgSqlSchema();
     ~PgSqlSchema();
     QHash<QString, QString> *getTypeMap();
diff --git a/src/schema/sqliteschema.h b/src/schema/sqliteschema.h
index 7a8d669..11fddbb 100644
--- a/src/schema/sqliteschema.h
+++ b/src/schema/sqliteschema.h
@@ -4,7 +4,7 @@
 #include "../schema.h"
 namespace CuteEntityManager {
 class SqliteSchema : public Schema {
-public:
+  public:
     SqliteSchema();
     ~SqliteSchema();
     QHash<QString, QString> *getTypeMap();
diff --git a/src/tableschema.cpp b/src/tableschema.cpp
index 4721525..55fc752 100644
--- a/src/tableschema.cpp
+++ b/src/tableschema.cpp
@@ -1,13 +1,75 @@
 #include "tableschema.h"
 using namespace CuteEntityManager;
 
-TableSchema::TableSchema()
-{
+TableSchema::TableSchema() {
 
 }
 
-TableSchema::~TableSchema()
-{
+TableSchema::~TableSchema() {
 
 }
 
+const ColumnSchema TableSchema::getColumn(QString name) const {
+
+}
+
+const QList<QString> TableSchema::getColumnNames() {
+
+}
+QString TableSchema::getSchemaName() const {
+    return schemaName;
+}
+
+void TableSchema::setSchemaName(const QString &value) {
+    schemaName = value;
+}
+QString TableSchema::getName() const {
+    return name;
+}
+
+void TableSchema::setName(const QString &value) {
+    name = value;
+}
+QString TableSchema::getFullName() const {
+    return fullName;
+}
+
+void TableSchema::setFullName(const QString &value) {
+    fullName = value;
+}
+QList<QString> TableSchema::getPrimaryKeys() const {
+    return primaryKeys;
+}
+
+void TableSchema::setPrimaryKeys(const QList<QString> &value) {
+    primaryKeys = value;
+}
+QString TableSchema::getSequenceName() const {
+    return sequenceName;
+}
+
+void TableSchema::setSequenceName(const QString &value) {
+    sequenceName = value;
+}
+QHash<QString, QString> TableSchema::getForeignKeys() const {
+    return foreignKeys;
+}
+
+void TableSchema::setForeignKeys(const QHash<QString, QString> &value) {
+    foreignKeys = value;
+}
+QList<ColumnSchema> TableSchema::getColumns() const {
+    return columns;
+}
+
+void TableSchema::setColumns(const QList<ColumnSchema> &value) {
+    columns = value;
+}
+
+
+
+
+
+
+
+
diff --git a/src/tableschema.h b/src/tableschema.h
index c3f59a0..9bccdc9 100644
--- a/src/tableschema.h
+++ b/src/tableschema.h
@@ -1,13 +1,48 @@
 #ifndef TABLESCHEMA_H
 #define TABLESCHEMA_H
+#include <QString>
+#include <QList>
+#include <QHash>
+#include "columnschema.h"
 
 namespace CuteEntityManager {
 
 class TableSchema {
-public:
+  public:
     TableSchema();
     ~TableSchema();
+    virtual ColumnSchema const getColumn(QString name) const;
+    virtual QList<QString> const getColumnNames();
 
+    QString getSchemaName() const;
+    void setSchemaName(const QString &value);
+
+    QString getName() const;
+    void setName(const QString &value);
+
+    QString getFullName() const;
+    void setFullName(const QString &value);
+
+    QList<QString> getPrimaryKeys() const;
+    void setPrimaryKeys(const QList<QString> &value);
+
+    QString getSequenceName() const;
+    void setSequenceName(const QString &value);
+
+    QHash<QString, QString> getForeignKeys() const;
+    void setForeignKeys(const QHash<QString, QString> &value);
+
+    QList<ColumnSchema> getColumns() const;
+    void setColumns(const QList<ColumnSchema> &value);
+
+  private:
+    QString schemaName;
+    QString name;
+    QString fullName;
+    QList<QString> primaryKeys;
+    QString sequenceName;
+    QHash<QString, QString> foreignKeys;
+    QList<ColumnSchema> columns;
 
 
 };