Changeset 20a6010

Timestamp:

12/30/09 14:50:23 (13 years ago)

Author:

komarma <komarma@…>

Branches:

master, qt5

Children:

489f262

Parents:

5a73d27

Message:

Adding database loading and data conversion to orm module

Location:

src

Files:

• model/event.cpp (modified) (1 diff)
• model/event.h (modified) (1 diff)
• orm/ormrecord.h (modified) (2 diffs)
• orm/sqlcondition.cpp (deleted)
• orm/sqlcondition.h (deleted)
• test/model/eventtest.cpp (modified) (2 diffs)
• test/model/eventtest.h (modified) (1 diff)

src/model/event.cpp

@@ -1 +1 @@
 #include "event.h"
 
-QStringList const Event::sColNames = QStringList()
-    << "id" << "xid_conference" << "start" << "duration" << "xid_activity" << "type" << "language";
+QSqlRecord const Event::sColumns = Event::toRecord(QList<QSqlField>()
+    << QSqlField("id", QVariant::Int)
+    << QSqlField("xid_conference", QVariant::Int)
+    << QSqlField("start", QVariant::DateTime)
+    << QSqlField("duration", QVariant::Int)
+    << QSqlField("xid_activity", QVariant::Int)
+    << QSqlField("type", QVariant::String)
+    << QSqlField("language", QVariant::String));
 
 QString const Event::sTableName = QString("event");
+
+Event Event::getById(int id, int conferenceId)
+{
+    QString query = selectQuery() + "WHERE id = :id AND xid_conference = :conf";
+
+    QSqlQuery q;
+    q.prepare(query);
+    q.bindValue(":id", id);
+    q.bindValue(":conf", conferenceId);
+    return loadOne(q);
+}

src/model/event.h

@@ -16 +16 @@
 };
 
-class Event : public OrmRecord <Event>
+class Event : public OrmRecord<Event>
 {
 public:
-    // column definition
-    enum Column
-    {
-        Id = 0,
-        Conference,
-        Start,
-        Duration,
-        Activity,
-        Type,
-        Language
-    };
-
-    static QStringList const sColNames;
-
+    static QSqlRecord const sColumns;
     static QString const sTableName;
 
 public:
-    static Event getById(int id, int conferenceId) { return Event(); } //EventTable::selectOne("id=1"); }
+    static Event getById(int id, int conferenceId);
 
 public:
-    int id() const { return value(Id).toInt(); }
-    int conferenceId() const { return value(Conference).toInt(); }
-    QDateTime start() const { return value(Start).toDateTime(); }
-    int duration() const { return value(Duration).toInt(); }
-    int activityId() const { return value(Activity).toInt(); }
-    int typeId() const { return value(Type).toInt(); }
-    int languageId() const { return value(Language).toInt(); }
+    int id() const { return value("id").toInt(); }
+    int conferenceId() const { return value("xid_conference").toInt(); }
+    QDateTime start() const { return value("start").toDateTime(); }
+    int duration() const { return value("duration").toInt(); }
+    int activityId() const { return value("xid_activity").toInt(); }
+    int typeId() const { return value("type").toInt(); }
+    int languageId() const { return value("language").toInt(); }
 
-    void setId(int id) { setValue(Id, id); }
-    void setConferenceId(int conferenceId) { setValue(Conference, conferenceId); }
-    void setStart(const QDateTime& start) { setValue(Start, start); }
-    void setDuration(int duration) { setValue(Duration, duration); }
-    void setActivityId(int activityId) { setValue(Activity, activityId); }
-    void setTypeId(int typeId) { setValue(Type, typeId); }
-    void setLanguageId(int languageId) { setValue(Language, languageId); }
+    void setId(int id) { setValue("id", id); }
+    void setConferenceId(int conferenceId) { setValue("xid_conference", conferenceId); }
+    void setStart(const QDateTime& start) { setValue("start", start); }
+    void setDuration(int duration) { setValue("duration", duration); }
+    void setActivityId(int activityId) { setValue("xid_activity", activityId); }
+    void setTypeId(int typeId) { setValue("type", typeId); }
+    void setLanguageId(int languageId) { setValue("language", languageId); }
+
+friend class EventTest;
 };
 

src/orm/ormrecord.h

@@ +1 @@
+#ifndef ORMRECORD_H
+#define ORMRECORD_H
+
+#include <QSqlQuery>
 #include <QSqlRecord>
 #include <QSqlField>
+#include <QSqlError>
+#include <QStringList>
+#include <QDateTime>
+#include <QDebug>
+
+class OrmException
+{
+};
+
+class OrmNoObjectException : OrmException
+{
+};
+
+class OrmSqlException : OrmException
+{
+public:
+    OrmSqlException(const QString& text) : mText(text) {}
+    QString text() const { return mText; }
+
+private:
+    QString mText;
+};
 
 template <typename T>
@@ -6 +32 @@
 {
 public:
-    static QString colName(int col);
+    OrmRecord();
+    static T hydrate(const QSqlRecord& record);
 
 protected:
-    QVariant value(int col) const;
-    void setValue(int col, QVariant value);
+    QVariant value(QString col) const;
+    void setValue(QString col, QVariant value);
+
+    static T loadOne(QSqlQuery query);
+    static QList<T> load(QSqlQuery query);
+
+    // auxiliary methods
+    static QString columnsForSelect(const QString& prefix = QString());
+    static QString selectQuery();
+    static QSqlRecord toRecord(const QList<QSqlField> & columnList);
+
+    static QVariant convertToC(QVariant value, QVariant::Type colType);
+    static QVariant convertToDb(QVariant value, QVariant::Type colType);
 };
 
 template <typename T>
-QString OrmRecord<T>::colName(int col)
+OrmRecord<T>::OrmRecord()
 {
-    return T::sColNames.at(col);
+    QSqlRecord::operator=(T::sColumns);
 }
 
 template <typename T>
-QVariant OrmRecord<T>::value(int col) const
+T OrmRecord<T>::hydrate(const QSqlRecord& record)
 {
-    Q_ASSERT(col >= 0 && col < T::sColNames.count());
-
-    return QSqlRecord::value(T::sColNames.at(col));
+    T object;
+    object.QSqlRecord::operator=(record);
+    return object;
 }
 
 template <typename T>
-void OrmRecord<T>::setValue(int col, QVariant value)
+QVariant OrmRecord<T>::value(QString col) const
 {
-    Q_ASSERT(col >= 0 && col < T::sColNames.count());
+    return convertToC(QSqlRecord::value(col), T::sColumns.field(col).type());
+}
 
-    QString fieldName = T::sColNames.at(col);
+template <typename T>
+void OrmRecord<T>::setValue(QString col, QVariant value)
+{
+    QSqlRecord::setValue(col, convertToDb(value, T::sColumns.field(col).type()));
+}
 
-    if (!contains(fieldName))
+template <typename T>
+T OrmRecord<T>::loadOne(QSqlQuery query)
+{
+    if (!query.isActive())
     {
-        append(QSqlField(fieldName, value.type()));
+        if (!query.exec())
+        {
+            throw new OrmSqlException(query.lastError().text());
+        }
     }
 
-    QSqlRecord::setValue(fieldName, value);
+    if (!query.next())
+    {
+        throw new OrmNoObjectException();
+    }
+
+    return hydrate(query.record());
 }
+
+template <typename T>
+QList<T> OrmRecord<T>::load(QSqlQuery query)
+{
+    if (!query.isActive())
+    {
+        if (!query.exec())
+        {
+            throw new OrmSqlException(query.lastError().text());
+        }
+    }
+
+    QList<T> objects;
+    while (query.next())
+    {
+        objects << hydrate(query.record());
+    }
+
+    return objects;
+}
+
+template <typename T>
+QString OrmRecord<T>::columnsForSelect(const QString& prefix)
+{
+    QStringList prefixedColumns;
+    for (int i=0; i<T::sColumns.count(); i++)
+    {
+        prefixedColumns.append(prefix.isEmpty() ?
+            T::sColumns.field(i).name() :
+            QString("%1.%2").arg(prefix, T::sColumns.field(i).name()));
+    }
+    return prefixedColumns.join(",");
+}
+
+template <typename T>
+QString OrmRecord<T>::selectQuery()
+{
+    return QString("SELECT %1 FROM %2 ").arg(columnsForSelect(), T::sTableName);
+}
+
+template <typename T>
+QSqlRecord OrmRecord<T>::toRecord(const QList<QSqlField> & columnList)
+{
+    QSqlRecord record;
+    foreach (const QSqlField & col, columnList)
+    {
+        record.append(col);
+    }
+    return record;
+}
+
+template <typename T>
+QVariant OrmRecord<T>::convertToC(QVariant value, QVariant::Type colType)
+{
+    if (colType == QVariant::DateTime &&
+        (value.type() == QVariant::UInt || value.type() == QVariant::Int))
+    {
+        QDateTime date;
+        date.setTime_t(value.toUInt());
+        return date;
+    }
+
+    return value;
+}
+
+template <typename T>
+QVariant OrmRecord<T>::convertToDb(QVariant value, QVariant::Type colType)
+{
+    if (colType == QVariant::DateTime && value.type() == QVariant::DateTime)
+    {
+        return value.toDateTime().toTime_t();
+    }
+
+    return value;
+}
+
+#endif // ORMRECORD_H

src/test/model/eventtest.cpp

@@ -12 +12 @@
     // Connect to the test database. Ask Mr. Pavelka to generate one for you :)
     QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
-    db.setDatabaseName("fostem-test.sqlite");
+    db.setDatabaseName("fosdem-test.sqlite");
     QVERIFY(db.open());
 }
@@ -28 +28 @@
 }
 
-void EventTest::colNames()
-{
-    QCOMPARE(Event::colName(Event::Id), QString("id"));
-    QCOMPARE(Event::colName(Event::Conference), QString("xid_conference"));
-    QCOMPARE(Event::colName(Event::Start), QString("start"));
-    QCOMPARE(Event::colName(Event::Duration), QString("duration"));
-    QCOMPARE(Event::colName(Event::Activity), QString("xid_activity"));
-    QCOMPARE(Event::colName(Event::Type), QString("type"));
-    QCOMPARE(Event::colName(Event::Language), QString("language"));
-}
-
 void EventTest::storingValues()
 {
     Event event;
-    QCOMPARE(event.id(), 0);
 
     event.setId(10);
+    event.setConferenceId(20);
+    event.setStart(QDateTime::fromString("Sat Feb 7 11:30:00 2009"));
+    event.setDuration(30);
+    event.setActivityId(40);
+    event.setTypeId(50);
+    event.setLanguageId(60);
+
     QCOMPARE(event.id(), 10);
-
-    event.setConferenceId(20);
     QCOMPARE(event.conferenceId(), 20);
-
-    event.setStart(QDateTime::fromString("Sat Feb 7 11:30:00 2009"));
     QCOMPARE(event.start(), QDateTime::fromString("Sat Feb 7 11:30:00 2009"));
-
-    event.setDuration(30);
     QCOMPARE(event.duration(), 30);
-
-    event.setActivityId(40);
     QCOMPARE(event.activityId(), 40);
-
-    event.setTypeId(50);
     QCOMPARE(event.typeId(), 50);
-
-    event.setLanguageId(60);
     QCOMPARE(event.languageId(), 60);
 }
+
+
+void EventTest::hydrate()
+{
+    QSqlRecord record;
+    record.append(QSqlField("duration", QVariant::Int));
+    record.append(QSqlField("id", QVariant::Int));
+    record.setValue(0, 10);
+    record.setValue(1, 20);
+
+    Event event = Event::hydrate(record);
+    QCOMPARE(event.id(), 20);
+    QCOMPARE(event.duration(), 10);
+}
+
+void EventTest::columnsForSelect()
+{
+    QCOMPARE(Event::columnsForSelect(), QString("id,xid_conference,start,duration,xid_activity,type,language"));
+    QCOMPARE(Event::columnsForSelect("t0"),
+             QString("t0.id,t0.xid_conference,t0.start,t0.duration,t0.xid_activity,t0.type,t0.language"));
+}
+
+void EventTest::selectQuery()
+{
+    QCOMPARE(Event::selectQuery(), QString("SELECT id,xid_conference,start,duration,xid_activity,type,language FROM event "));
+}

src/test/model/eventtest.h

@@ -12 +12 @@
 
     void getById();
-    void colNames();
     void storingValues();
+    void hydrate();
+    void columnsForSelect();
+    void selectQuery();
 };