alpha1 development in progress.

planned feature for storage cell has completed.
cell API setXYZVArray() and getXYZArray() is implemented.

diff --git a/Source/DNStorage.cpp b/Source/DNStorage.cpp
index 3ca71dd..5fbacc9 100644 (file)
--- a/Source/DNStorage.cpp
+++ b/Source/DNStorage.cpp
@@ -20,6 +20,20 @@
 
 #include "DNStorageImpl.h"
 
+DNStorageXYZVRecords::DNStorageXYZVRecords(int _length) : length(_length), data(0)
+{
+    data = new DNStorageXYZVData[length];
+}
+
+DNStorageXYZVRecords::~DNStorageXYZVRecords()
+{
+    if (data)
+    {
+        delete[] data;
+        data = 0;
+    }
+}
+
 DNStorage::DNStorage(const char *storagePath)
 {
     impl = DNStorageImpl::create(storagePath);
@@ -65,42 +79,42 @@ float  DNStorage::getValue(const char *path, const char *key)
     return r;
 }
 
-int  DNStorage::countXYZData(const char *path, const char *key)
+int  DNStorage::countXYZVData(const char *path, const char *key)
 {
     int r = 0;
     if (impl)
     {
-        r = impl->countXYZData(path,key);
+        r = impl->countXYZVData(path,key);
     }
     return r;
 }
 
-int DNStorage::insertXYZData(const char *path, const char *key, float v, float x, float y, float z)
+bool DNStorage::insertXYZVData(const char *path, const char *key, int index, float x, float y, float z, float v)
 {
-    int r = 0;
+    bool r = false;
     if (impl)
     {
-        r = impl->insertXYZData(path,key,v,x,y,z);
+        r = impl->insertXYZVData(path,key,index,x,y,z,v);
     }
     return r;
 }
 
-const DNStorageXYZDataRecords* DNStorage::queryXYZData(const char *path, const char *key)
+DNStorageXYZVRecords* DNStorage::queryXYZVData(const char *path, const char *key)
 {
-    const DNStorageXYZDataRecords *r = 0;
+    DNStorageXYZVRecords *r = 0;
     if (impl)
     {
-        r = impl->queryXYZData(path,key);
+        r = impl->queryXYZVData(path,key);
     }
     return r;
 }
 
-bool DNStorage::deleteXYZData(const char *path, const char *key)
+bool DNStorage::deleteXYZVData(const char *path, const char *key)
 {
     bool r = false;
     if (impl)
     {
-        r = impl->deleteXYZData(path,key);
+        r = impl->deleteXYZVData(path,key);
     }
     return r;
 }
@@ -140,3 +154,13 @@ bool DNStorage::commitTransaction()
 
     return r;
 }
+
+bool DNStorage::rollbackTransaction()
+{
+    bool r = false;
+    if (impl)
+        r = impl->rollbackTransaction();
+
+    return r;
+}
+

diff --git a/Source/DNStorage.h b/Source/DNStorage.h
index 4a07517..201fb0c 100644 (file)
--- a/Source/DNStorage.h
+++ b/Source/DNStorage.h
@@ -22,21 +22,26 @@
 class DNStorageImpl;
 
 
-class DNStorageXYZData
+class DNStorageXYZVData
 {
 public:
+    DNStorageXYZVData():index(0),x(0.0),y(0.0),z(0.0),v(0.0) {}
+
     int     index;
-    float   v;
     float   x;
     float   y;
     float   z;
+    float   v;
 };
 
-class DNStorageXYZDataRecords
+class DNStorageXYZVRecords
 {
 public:
+    DNStorageXYZVRecords(int length);
+    ~DNStorageXYZVRecords();
+
     int                 length;
-    DNStorageXYZData    *data;
+    DNStorageXYZVData   *data;
 };
 
 class DNStorage
@@ -51,11 +56,10 @@ public:
     int                     getCount(const char *path, const char *key);
 
     //methods for xyz dataset storage
-    int                     countXYZData(const char *path, const char *key);
-    int                     insertXYZData(const char *path, const char *key, float v, float x, float y, float z);
-    const DNStorageXYZDataRecords*
-                            queryXYZData(const char *path, const char *key);
-    bool                    deleteXYZData(const char *path, const char *key);
+    int                     countXYZVData(const char *path, const char *key);
+    bool                    insertXYZVData(const char *path, const char *key, int index, float x, float y, float z, float v);
+    DNStorageXYZVRecords*   queryXYZVData(const char *path, const char *key);
+    bool                    deleteXYZVData(const char *path, const char *key);
 
     bool                    flush();
 
@@ -63,6 +67,7 @@ public:
 
     bool                    startTransaction();
     bool                    commitTransaction();
+    bool                    rollbackTransaction();
 
 private:
     DNStorageImpl           *impl;

diff --git a/Source/DNStorageImpl.h b/Source/DNStorageImpl.h
index 8226a06..7d7a16f 100644 (file)
--- a/Source/DNStorageImpl.h
+++ b/Source/DNStorageImpl.h
@@ -21,7 +21,7 @@
 
 class DNStorageDataSet;
 class DNStorageDataSetQuery;
-class DNStorageXYZDataRecords;
+class DNStorageXYZVRecords;
 
 class DNStorageImpl
 {
@@ -33,11 +33,10 @@ public:
     virtual float   getValue(const char *path, const char *key) = 0;
     virtual int     getCount(const char *path, const char *key) = 0;
 
-    virtual int     countXYZData(const char *path, const char *key) = 0;
-    virtual int     insertXYZData(const char *path, const char *key, float v, float x, float y, float z) = 0;
-    virtual const DNStorageXYZDataRecords*
-                    queryXYZData(const char *path, const char *key) = 0;
-    virtual bool    deleteXYZData(const char *path, const char *key) = 0;
+    virtual int     countXYZVData(const char *path, const char *key) = 0;
+    virtual bool    insertXYZVData(const char *path, const char *key, int index, float x, float y, float z,float v) = 0;
+    virtual DNStorageXYZVRecords* queryXYZVData(const char *path, const char *key) = 0;
+    virtual bool    deleteXYZVData(const char *path, const char *key) = 0;
 
     virtual bool    isValid() = 0;
 
@@ -45,6 +44,7 @@ public:
 
     virtual bool    startTransaction() = 0;
     virtual bool    commitTransaction() = 0;
+    virtual bool    rollbackTransaction() = 0;
 };
 
 #endif // DNSOTRAGEIMPL_H

diff --git a/Source/QtScript/dnqsbasicstoragecell.cpp b/Source/QtScript/dnqsbasicstoragecell.cpp
index 82c09d2..1a61b66 100644 (file)
--- a/Source/QtScript/dnqsbasicstoragecell.cpp
+++ b/Source/QtScript/dnqsbasicstoragecell.cpp
@@ -31,6 +31,7 @@ QScriptString DNQSBasicStorageCell::mXQSString;
 QScriptString DNQSBasicStorageCell::mYQSString;
 QScriptString DNQSBasicStorageCell::mZQSString;
 QScriptString DNQSBasicStorageCell::mVQSString;
+QScriptString DNQSBasicStorageCell::mPushQSString;
 
 DNQSBasicStorageCell::DNQSBasicStorageCell(DNQSContainer *container, std::string location, std::string name, bool canInterface) :
     DNQSBasicCell(container, location, name, canInterface)
@@ -40,8 +41,8 @@ DNQSBasicStorageCell::DNQSBasicStorageCell(DNQSContainer *container, std::string
     mPath = getFQNString(mLocation.c_str(), mName.c_str());
     mQSStorage.setProperty("setValue",mEngine->newFunction(scriptFunction_storage_setValue, 2));
     mQSStorage.setProperty("getValue",mEngine->newFunction(scriptFunction_storage_getValue, 1));
-    mQSStorage.setProperty("setXYZArray",mEngine->newFunction(scriptFunction_storage_setXYZArray, 2));
-    mQSStorage.setProperty("getXYZArray",mEngine->newFunction(scriptFunction_storage_getXYZArray, 1));
+    mQSStorage.setProperty("setXYZVArray",mEngine->newFunction(scriptFunction_storage_setXYZVArray, 2));
+    mQSStorage.setProperty("getXYZVArray",mEngine->newFunction(scriptFunction_storage_getXYZVArray, 1));
     mQSStorage.setData(mEngine->newQObject(this));
     mQSAPIInstance.setProperty("storage", mQSStorage,QScriptValue::ReadOnly|QScriptValue::Undeletable);
 
@@ -52,6 +53,7 @@ DNQSBasicStorageCell::DNQSBasicStorageCell(DNQSContainer *container, std::string
         mXQSString = mEngine->toStringHandle("x");
         mYQSString = mEngine->toStringHandle("y");
         mZQSString = mEngine->toStringHandle("z");
+        mPushQSString = mEngine->toStringHandle("push");
     }
 }
 
@@ -86,29 +88,29 @@ bool DNQSBasicStorageCell::setValue_storage(const char *key, float value)
         return false;
 }
 
-int DNQSBasicStorageCell::getXYZArrayCount_storage(const char* key)
+int DNQSBasicStorageCell::getXYZVArrayCount_storage(const char* key)
 {
     DNStorage *storage = mContainer->getDataStore();
     if (storage)
     {
-        return storage->countXYZData(mPath.c_str(), key);
+        return storage->countXYZVData(mPath.c_str(), key);
     }
     else
         return 0;
 
 }
 
-const DNStorageXYZDataRecords* DNQSBasicStorageCell::getXYZArray_storage(const char *key)
+DNStorageXYZVRecords* DNQSBasicStorageCell::getXYZVArray_storage(const char *key)
 {
     DNStorage *storage = mContainer->getDataStore();
     if (storage)
-        return storage->queryXYZData(mPath.c_str(), key);
+        return storage->queryXYZVData(mPath.c_str(), key);
     else
         return NULL;
 
 }
 
-bool DNQSBasicStorageCell::setXYZArray_storage(const char *key, QScriptValue array)
+bool DNQSBasicStorageCell::setXYZVArray_storage(const char *key, QScriptValue array)
 {
     if (!array.isArray())
         return false;
@@ -122,21 +124,18 @@ bool DNQSBasicStorageCell::setXYZArray_storage(const char *key, QScriptValue arr
 
     storage->startTransaction();
 
-    storage->deleteXYZData(path,key);
+    storage->deleteXYZVData(path,key);
+
+    bool r = true;
 
     for (int i = 0; i < length; i++)
     {
         QScriptValue item = array.property(i);
-        float v = 0;
         float x = 0;
         float y = 0;
         float z = 0;
+        float v = 0;
 
-        QScriptValue sv =  item.property(mVQSString);
-        if (sv.isNumber())
-        {
-            v = sv.toNumber();
-        }
         QScriptValue sx =  item.property(mXQSString);
         if (sx.isNumber())
         {
@@ -152,12 +151,21 @@ bool DNQSBasicStorageCell::setXYZArray_storage(const char *key, QScriptValue arr
         {
             z = sz.toNumber();
         }
-        storage->insertXYZData(path,key,v,x,y,z);
+        QScriptValue sv =  item.property(mVQSString);
+        if (sv.isNumber())
+        {
+            v = sv.toNumber();
+        }
+        r = storage->insertXYZVData(path,key,i,x,y,z,v);
+        if (!r) break;
     }
 
-    storage->commitTransaction();
+    if (r)
+        storage->commitTransaction();
+    else
+        storage->rollbackTransaction();
 
-    return true;
+    return r;
 }
 
 //static
@@ -198,7 +206,7 @@ QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getValue(QScriptContex
 }
 
 //static
-QScriptValue DNQSBasicStorageCell::scriptFunction_storage_setXYZArray(QScriptContext *context, QScriptEngine *engine)
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_setXYZVArray(QScriptContext *context, QScriptEngine *engine)
 {
     QScriptValue data = context->thisObject().data();
     TKASSERT(data.isQObject());
@@ -210,13 +218,13 @@ QScriptValue DNQSBasicStorageCell::scriptFunction_storage_setXYZArray(QScriptCon
         QByteArray qkey = context->argument(0).toString().toUtf8();
         const char *key = qkey.constData();
         QScriptValue array = context->argument(1);
-        r = cell->setXYZArray_storage(key, array);
+        r = cell->setXYZVArray_storage(key, array);
     }
     return QScriptValue(engine, r);
 }
 
 //static
-QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getXYZArray(QScriptContext *context, QScriptEngine *engine)
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getXYZVArray(QScriptContext *context, QScriptEngine *engine)
 {
     QScriptValue thisObj = context->thisObject();
     QScriptValue data = thisObj.data();
@@ -228,31 +236,40 @@ QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getXYZArray(QScriptCon
         QByteArray qkey = context->argument(0).toString().toUtf8();
         const char *key = qkey.constData();
 
-        if (cell->getXYZArrayCount_storage(key) == 0)
+        if (cell->getXYZVArrayCount_storage(key) == 0)
         {
             return engine->undefinedValue();
         }
         else
         {
-            QScriptValue result = engine->newArray();
-            const DNStorageXYZDataRecords *records = cell->getXYZArray_storage(key);
+            DNStorageXYZVRecords *records = cell->getXYZVArray_storage(key);
             if (records)
             {
-                QScriptValue pushScriptFunction = result.property("push");
-
+                QScriptValue result = engine->newArray(0);
+                QScriptValue pushScriptFunction = result.property(mPushQSString);
                 for (int i = 0; i < records->length; i++)
                 {
                     QScriptValue item = engine->newObject();
-                    item.setProperty(mVQSString, records->data[i].v);
-                    item.setProperty(mXQSString, records->data[i].x);
-                    item.setProperty(mYQSString, records->data[i].y);
-                    item.setProperty(mZQSString, records->data[i].z);
+                    item.setProperty(mXQSString, QScriptValue(records->data[i].x));
+                    item.setProperty(mYQSString, QScriptValue(records->data[i].y));
+                    item.setProperty(mZQSString, QScriptValue(records->data[i].z));
+                    item.setProperty(mVQSString, QScriptValue(records->data[i].v));
                     QScriptValueList args;
                     args << item;
-                    pushScriptFunction.call(thisObj, args);
+                    pushScriptFunction.call(result, args);
+#ifdef DEBUG
+                    if (engine->hasUncaughtException())
+                    {
+                        QScriptValue error = engine->uncaughtException();
+                        QString errorString = error.toString();
+                        TKLog::printf("Script error at scriptFunction_storage_getXYZVArray.  Error Message: %s", errorString.toLocal8Bit().data());
+                        engine->clearExceptions();
+                    }
+#endif //DEBUG
                 }
+                delete records;
+                return result;
             }
-            return result;
         }
     }
     return engine->undefinedValue();

diff --git a/Source/QtScript/dnqsbasicstoragecell.h b/Source/QtScript/dnqsbasicstoragecell.h
index e018ac7..3e1e477 100644 (file)
--- a/Source/QtScript/dnqsbasicstoragecell.h
+++ b/Source/QtScript/dnqsbasicstoragecell.h
@@ -27,7 +27,7 @@
 
 #include <string>
 
-class DNStorageXYZDataRecords;
+class DNStorageXYZVRecords;
 
 class DNQSBasicStorageCell : public QObject, public DNQSBasicCell
 {
@@ -44,21 +44,22 @@ private:
     float   getValue_storage(const char *key);
     bool    setValue_storage(const char *key, float value);
 
-    int             getXYZArrayCount_storage(const char* key);
-    const DNStorageXYZDataRecords*
-                    getXYZArray_storage(const char *key);
-    bool            setXYZArray_storage(const char *key, QScriptValue array);
+    int             getXYZVArrayCount_storage(const char* key);
+    DNStorageXYZVRecords*
+                    getXYZVArray_storage(const char *key);
+    bool            setXYZVArray_storage(const char *key, QScriptValue array);
 
     static QScriptValue scriptFunction_storage_setValue(QScriptContext *context, QScriptEngine *engine);
     static QScriptValue scriptFunction_storage_getValue(QScriptContext *context, QScriptEngine *engine);
-    static QScriptValue scriptFunction_storage_setXYZArray(QScriptContext *context, QScriptEngine *engine);
-    static QScriptValue scriptFunction_storage_getXYZArray(QScriptContext *context, QScriptEngine *engine);
+    static QScriptValue scriptFunction_storage_setXYZVArray(QScriptContext *context, QScriptEngine *engine);
+    static QScriptValue scriptFunction_storage_getXYZVArray(QScriptContext *context, QScriptEngine *engine);
 
     static QScriptString mLengthQSString;
     static QScriptString mXQSString;
     static QScriptString mYQSString;
     static QScriptString mZQSString;
     static QScriptString mVQSString;
+    static QScriptString mPushQSString;
 
 };
 

diff --git a/Source/platform/qt/qtdnstorageimpl.cpp b/Source/platform/qt/qtdnstorageimpl.cpp
index 29612d1..517deda 100644 (file)
--- a/Source/platform/qt/qtdnstorageimpl.cpp
+++ b/Source/platform/qt/qtdnstorageimpl.cpp
@@ -18,6 +18,7 @@
 //
 #include "qtdnstorageimpl.h"
 
+#include "DNStorage.h"
 #include "DNStorageImpl.h"
 #include "TKLog.h"
 
@@ -72,6 +73,8 @@ bool QtDNStorageImpl::setValue(const char *path, const char *key, float value)
     {
         std::string message = "SQL error while processing cell ";
         message.append(path);
+        message.append(":");
+        message.append(key);
         message.append("\n");
         message.append(mQueries->propertiesCountQuery.lastError().text().toStdString());
         TKLog::printf("%s", message.c_str());
@@ -88,6 +91,8 @@ bool QtDNStorageImpl::setValue(const char *path, const char *key, float value)
         {
             std::string message = "SQL error while processing cell ";
             message.append(path);
+            message.append(":");
+            message.append(key);
             message.append("\n");
             message.append(mQueries->propertiesCountQuery.lastError().text().toStdString());
             TKLog::printf("%s", message.c_str());
@@ -103,6 +108,8 @@ bool QtDNStorageImpl::setValue(const char *path, const char *key, float value)
         {
             std::string message = "SQL error while processing cell ";
             message.append(path);
+            message.append(":");
+            message.append(key);
             message.append("\n");
             message.append(mQueries->propertiesCountQuery.lastError().text().toStdString());
             TKLog::printf("%s", message.c_str());
@@ -126,6 +133,8 @@ float QtDNStorageImpl::getValue(const char *path, const char *key)
     {
         std::string message = "SQL error while processing cell ";
         message.append(path);
+        message.append(":");
+        message.append(key);
         message.append("\n");
         message.append(mQueries->propertiesCountQuery.lastError().text().toStdString());
         TKLog::printf("%s", message.c_str());
@@ -138,7 +147,7 @@ float QtDNStorageImpl::getValue(const char *path, const char *key)
 int QtDNStorageImpl::getCount(const char *path, const char *key)
 {
     if (!mIsValid)
-        return false;
+        return 0;
 
     QString qPath(path);
     QString qKey(key);
@@ -148,10 +157,12 @@ int QtDNStorageImpl::getCount(const char *path, const char *key)
     {
         std::string message = "SQL error while processing cell ";
         message.append(path);
+        message.append(":");
+        message.append(key);
         message.append("\n");
         message.append(mQueries->propertiesCountQuery.lastError().text().toStdString());
         TKLog::printf("%s", message.c_str());
-        return false;
+        return 0;
     }
 
     mQueries->propertiesCountQuery.next();
@@ -159,36 +170,135 @@ int QtDNStorageImpl::getCount(const char *path, const char *key)
 }
 
 
-int QtDNStorageImpl::countXYZData(const char *path, const char *key)
+int QtDNStorageImpl::countXYZVData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
         return 0;
-    //TODO
-    return 0;
+    QString qPath(path);
+    QString qKey(key);
+    mQueries->xyzvDataCountQuery.addBindValue(qPath);
+    mQueries->xyzvDataCountQuery.addBindValue(qKey);
+    if (!mQueries->xyzvDataCountQuery.exec())
+    {
+        std::string message = "SQL error while processing cell ";
+        message.append(path);
+        message.append(":");
+        message.append(key);
+        message.append("\n");
+        message.append(mQueries->xyzvDataCountQuery.lastError().text().toStdString());
+        TKLog::printf("%s", message.c_str());
+        return 0;
+    }
+
+    mQueries->xyzvDataCountQuery.next();
+    return mQueries->xyzvDataCountQuery.value(0).toInt();
 }
 
-int QtDNStorageImpl::insertXYZData(const char *path, const char *key, float v, float x, float y, float z)
+bool QtDNStorageImpl::insertXYZVData(const char *path, const char *key, int index, float x, float y, float z, float v)
 {
     if (mQueries == NULL || !mIsValid)
         return 0;
-    //TODO
-    return 0;
+
+    QString qPath(path);
+    QString qKey(key);
+    mQueries->xyzvDataInsetQuery.addBindValue(qPath);
+    mQueries->xyzvDataInsetQuery.addBindValue(qKey);
+    mQueries->xyzvDataInsetQuery.addBindValue(index);
+
+    mQueries->xyzvDataInsetQuery.addBindValue(x);
+    mQueries->xyzvDataInsetQuery.addBindValue(y);
+    mQueries->xyzvDataInsetQuery.addBindValue(z);
+    mQueries->xyzvDataInsetQuery.addBindValue(v);
+    if (!mQueries->xyzvDataInsetQuery.exec())
+    {
+        std::string message = "SQL error while processing cell ";
+        message.append(path);
+        message.append(":");
+        message.append(key);
+        message.append("\n");
+        message.append(mQueries->xyzvDataInsetQuery.lastError().text().toStdString());
+        TKLog::printf("%s", message.c_str());
+        return false;
+    }
+
+    return true;
 }
 
-const DNStorageXYZDataRecords* QtDNStorageImpl::queryXYZData(const char *path, const char *key)
+DNStorageXYZVRecords* QtDNStorageImpl::queryXYZVData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
         return 0;
-    //TODO
-    return 0;
+
+    QString qPath(path);
+    QString qKey(key);
+    mQueries->xyzvDataCountQuery.addBindValue(qPath);
+    mQueries->xyzvDataCountQuery.addBindValue(qKey);
+    if (!mQueries->xyzvDataCountQuery.exec())
+    {
+        std::string message = "SQL error while processing cell ";
+        message.append(path);
+        message.append(":");
+        message.append(key);
+        message.append("\n");
+        message.append(mQueries->xyzvDataCountQuery.lastError().text().toStdString());
+        TKLog::printf("%s", message.c_str());
+        return 0;
+    }
+    mQueries->xyzvDataCountQuery.next();
+    int length = mQueries->xyzvDataCountQuery.value(0).toInt();
+    DNStorageXYZVRecords *records = new DNStorageXYZVRecords(length);
+    mQueries->xyzvDataGetQuery.addBindValue(qPath);
+    mQueries->xyzvDataGetQuery.addBindValue(qKey);
+    if (!mQueries->xyzvDataGetQuery.exec())
+    {
+        std::string message = "SQL error while processing cell ";
+        message.append(path);
+        message.append(":");
+        message.append(key);
+        message.append("\n");
+        message.append(mQueries->xyzvDataGetQuery.lastError().text().toStdString());
+        TKLog::printf("%s", message.c_str());
+        if (records)
+            delete records;
+        return 0;
+    }
+
+    int i = 0;
+    while(mQueries->xyzvDataGetQuery.next() && i < length)
+    {
+        records->data[i].index = mQueries->xyzvDataGetQuery.value(0).toInt();
+        records->data[i].x = mQueries->xyzvDataGetQuery.value(1).toFloat();
+        records->data[i].y = mQueries->xyzvDataGetQuery.value(2).toFloat();
+        records->data[i].z = mQueries->xyzvDataGetQuery.value(3).toFloat();
+        records->data[i].v = mQueries->xyzvDataGetQuery.value(4).toFloat();
+        i++;
+    }
+    records->length = i;
+
+    return records;
 }
 
-bool QtDNStorageImpl::deleteXYZData(const char *path, const char *key)
+bool QtDNStorageImpl::deleteXYZVData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
         return false;
-    //TODO
-    return false;
+
+    QString qPath(path);
+    QString qKey(key);
+    mQueries->xyzvDataRemoveQuery.addBindValue(qPath);
+    mQueries->xyzvDataRemoveQuery.addBindValue(qKey);
+    if (!mQueries->xyzvDataRemoveQuery.exec())
+    {
+        std::string message = "SQL error while processing cell ";
+        message.append(path);
+        message.append(":");
+        message.append(key);
+        message.append("\n");
+        message.append(mQueries->xyzvDataRemoveQuery.lastError().text().toStdString());
+        TKLog::printf("%s", message.c_str());
+        return false;
+    }
+    return true;
 }
 
 
@@ -216,6 +326,14 @@ bool QtDNStorageImpl::commitTransaction()
     return mDatabase->database.commit();
 }
 
+bool QtDNStorageImpl::rollbackTransaction()
+{
+    if (mDatabase == NULL || !mIsValid)
+        return false;
+
+    return mDatabase->database.rollback();
+}
+
 bool QtDNStorageImpl::initDB()
 {
     mDatabase = new QtDNDatabase;
@@ -260,11 +378,11 @@ bool QtDNStorageImpl::initDB()
         }
     }
 
-    if (!tables.contains("xyzdata"))
+    if (!tables.contains("xyzvdata"))
     {
         QSqlQuery q;
 
-        if (!q.exec("CREATE TABLE xyzdata(cell TEXT, dskey TEXT, dsindex INTEGER, v REAL, x REAL, y REAL, z REAL, PRIMARY KEY (cell, dskey, dsindex))"));
+        if (!q.exec("CREATE TABLE xyzvdata(cell TEXT, dskey TEXT, dsindex INTEGER, x REAL, y REAL, z REAL, v REAL, PRIMARY KEY (cell, dskey, dsindex))"));
         {
             if (mDatabase->database.lastError().type() !=  QSqlError::NoError)
             {
@@ -289,9 +407,10 @@ bool QtDNStorageImpl::initDB()
     mQueries->propertiesUpdateQuery.prepare("UPDATE properties SET value=? WHERE cell=? and prokey=?");
     mQueries->propertiesGetQuery.prepare("SELECT value FROM properties WHERE cell=? and prokey=?");
 
-    mQueries->xyzDataInsetQuery.prepare("INSERT INTO xyzdata VALUES (?,?,?, ?,?,?,?)");
-    mQueries->xyzDataCountQuery.prepare("SELECT count(*) FROM xyzdata WHERE cell=? and dskey=?");
-    mQueries->xyzDataRemoveQuery.prepare("DELETE FROM xyzdata WHERE cell=? and dskey=?");
+    mQueries->xyzvDataInsetQuery.prepare("INSERT INTO xyzvdata VALUES (?,?,?, ?,?,?,?)");
+    mQueries->xyzvDataCountQuery.prepare("SELECT count(*) FROM xyzvdata WHERE cell=? and dskey=?");
+    mQueries->xyzvDataGetQuery.prepare("SELECT dsindex, x, y, z, v FROM xyzvdata WHERE cell=? and dskey=?");
+    mQueries->xyzvDataRemoveQuery.prepare("DELETE FROM xyzvdata WHERE cell=? and dskey=?");
 
     if (mDatabase->database.lastError().type() != QSqlError::NoError)
     {

diff --git a/Source/platform/qt/qtdnstorageimpl.h b/Source/platform/qt/qtdnstorageimpl.h
index df38e03..0aee45a 100644 (file)
--- a/Source/platform/qt/qtdnstorageimpl.h
+++ b/Source/platform/qt/qtdnstorageimpl.h
@@ -38,9 +38,10 @@ public:
     QSqlQuery   propertiesUpdateQuery;
     QSqlQuery   propertiesGetQuery;
 
-    QSqlQuery   xyzDataInsetQuery;
-    QSqlQuery   xyzDataRemoveQuery;
-    QSqlQuery   xyzDataCountQuery;
+    QSqlQuery   xyzvDataInsetQuery;
+    QSqlQuery   xyzvDataRemoveQuery;
+    QSqlQuery   xyzvDataCountQuery;
+    QSqlQuery   xyzvDataGetQuery;
 };
 
 class QtDNStorageImpl : public DNStorageImpl
@@ -53,11 +54,10 @@ public:
     virtual float   getValue(const char *path, const char *key);
     virtual int     getCount(const char *path, const char *key);
 
-    virtual int     countXYZData(const char *path, const char *key);
-    virtual int     insertXYZData(const char *path, const char *key, float v, float x, float y, float z);
-    virtual const DNStorageXYZDataRecords*
-                    queryXYZData(const char *path, const char *key);
-    virtual bool    deleteXYZData(const char *path, const char *key);
+    virtual int     countXYZVData(const char *path, const char *key);
+    virtual bool    insertXYZVData(const char *path, const char *key, int index, float x, float y, float z, float v);
+    virtual DNStorageXYZVRecords* queryXYZVData(const char *path, const char *key);
+    virtual bool    deleteXYZVData(const char *path, const char *key);
 
     virtual bool    flush();
 
@@ -65,6 +65,7 @@ public:
 
     virtual bool    startTransaction();
     virtual bool    commitTransaction();
+    virtual bool    rollbackTransaction();
 
 private:
     bool            initDB();