alpha 1 development in progress.

storage cell under development.

diff --git a/Source/DNStorage.cpp b/Source/DNStorage.cpp
index 2d5cb47..3ca71dd 100644 (file)
--- a/Source/DNStorage.cpp
+++ b/Source/DNStorage.cpp
@@ -65,42 +65,42 @@ float  DNStorage::getValue(const char *path, const char *key)
     return r;
 }
 
-int  DNStorage::insertToDataSet(const char *path, const char *key, float v, float x, float y, float z)
+int  DNStorage::countXYZData(const char *path, const char *key)
 {
     int r = 0;
     if (impl)
     {
-        r = impl->insertToDataSet(path,key,v, x,y,z);
+        r = impl->countXYZData(path,key);
     }
     return r;
 }
 
-const DNStorageDataSet* DNStorage::queryDataSet(const char *path, const char *key, const DNStorageDataSetQuery *query) const
+int DNStorage::insertXYZData(const char *path, const char *key, float v, float x, float y, float z)
 {
-    const DNStorageDataSet *r = 0;
+    int r = 0;
     if (impl)
     {
-        r = impl->queryDataSet(path,key,query);
+        r = impl->insertXYZData(path,key,v,x,y,z);
     }
     return r;
 }
 
-bool DNStorage::updateDataSet(const char *path, const char *key, int index, float v, float x, float y, float z)
+const DNStorageXYZDataRecords* DNStorage::queryXYZData(const char *path, const char *key)
 {
-    bool r = false;
+    const DNStorageXYZDataRecords *r = 0;
     if (impl)
     {
-        r = impl->updateDataSet(path,key,index,v,x,y,z);
+        r = impl->queryXYZData(path,key);
     }
     return r;
 }
 
-bool DNStorage::deleteFromDataSet(const char *path, const char *key, int index)
+bool DNStorage::deleteXYZData(const char *path, const char *key)
 {
     bool r = false;
     if (impl)
     {
-        r = impl->deleteFromDataSet(path,key,index);
+        r = impl->deleteXYZData(path,key);
     }
     return r;
 }
@@ -122,3 +122,21 @@ bool DNStorage::isValid()
 
     return r;
 }
+
+bool DNStorage::startTransaction()
+{
+    bool r = false;
+    if (impl)
+        r = impl->startTransaction();
+
+    return r;
+}
+
+bool DNStorage::commitTransaction()
+{
+    bool r = false;
+    if (impl)
+        r = impl->commitTransaction();
+
+    return r;
+}

diff --git a/Source/DNStorage.h b/Source/DNStorage.h
index a18f656..4a07517 100644 (file)
--- a/Source/DNStorage.h
+++ b/Source/DNStorage.h
@@ -22,64 +22,21 @@
 class DNStorageImpl;
 
 
-class DNStorageDataSetData
+class DNStorageXYZData
 {
 public:
     int     index;
-    float   v1;
-    float   v2;
-    float   v3;
+    float   v;
+    float   x;
+    float   y;
+    float   z;
 };
 
-class DNStorageDataSetQuery
+class DNStorageXYZDataRecords
 {
 public:
-    enum SORT {
-        SORT_NONE,
-        SORT_ACENT_X,
-        SORT_ACENT_Y,
-        SORT_ACENT_Z,
-        SORT_DECENT_X,
-        SORT_DECENT_Y,
-        SORT_DECENT_Z
-    };
-
-    DNStorageDataSetQuery() : isSetXMin(false),isSetXMax(false),isSetYMin(false),isSetYMax(false),isSetZMin(false),isSetZMax(false) {}
-    virtual ~DNStorageDataSetQuery() {}
-    void setXMin(float min) { xMin = min;isSetXMin = true; }
-    void setXMax(float max) { xMax = max;isSetXMax = true; }
-    void setYMin(float min) { yMin = min;isSetYMin = true; }
-    void setYMax(float max) { yMax = max;isSetYMax = true; }
-    void setZMin(float min) { zMin = min;isSetZMin = true; }
-    void setZMax(float max) { zMax = max;isSetZMax = true; }
-    void setMaxDataCount(int count) { maxDataCount = count; }
-    void setSort(SORT s1 = SORT_NONE, SORT s2 = SORT_NONE, SORT s3 = SORT_NONE) { sort1 = s1; sort2 = s2; sort3 = s3; }
-
-    float   xMin;
-    bool    isSetXMin;
-    float   xMax;
-    bool    isSetXMax;
-    float   yMin;
-    bool    isSetYMin;
-    float   yMax;
-    bool    isSetYMax;
-    float   zMin;
-    bool    isSetZMin;
-    float   zMax;
-    bool    isSetZMax;
-    int     maxDataCount;
-    bool    isSetMaxDataCount;
-    SORT    sort1;
-    SORT    sort2;
-    SORT    sort3;
-};
-
-
-class DNStorageDataSet
-{
-public:
-    int                     count;
-    DNStorageDataSetData     *data;
+    int                 length;
+    DNStorageXYZData    *data;
 };
 
 class DNStorage
@@ -93,16 +50,20 @@ public:
     float                   getValue(const char *path, const char *key);
     int                     getCount(const char *path, const char *key);
 
-    //methods for dataset storage
-    int                     insertToDataSet(const char *path, const char *key, float v, float x, float y, float z);
-    const DNStorageDataSet   *queryDataSet(const char *path, const char *key, const DNStorageDataSetQuery *query) const;
-    bool                    updateDataSet(const char *path, const char *key, int index, float v, float x, float y, float z);
-    bool                    deleteFromDataSet(const char *path, const char *key, int index);
+    //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);
 
     bool                    flush();
 
     bool                    isValid();
 
+    bool                    startTransaction();
+    bool                    commitTransaction();
+
 private:
     DNStorageImpl           *impl;
 };

diff --git a/Source/DNStorageImpl.h b/Source/DNStorageImpl.h
index 0ff4fb5..8226a06 100644 (file)
--- a/Source/DNStorageImpl.h
+++ b/Source/DNStorageImpl.h
@@ -21,6 +21,7 @@
 
 class DNStorageDataSet;
 class DNStorageDataSetQuery;
+class DNStorageXYZDataRecords;
 
 class DNStorageImpl
 {
@@ -28,18 +29,22 @@ public:
     static DNStorageImpl* create(const char *storagePath);
 
     virtual ~DNStorageImpl() {}
-    virtual bool                    setValue(const char *path, const char *key, float value) = 0;
-    virtual float                   getValue(const char *path, const char *key) = 0;
-    virtual int                     getCount(const char *path, const char *key) = 0;
+    virtual bool    setValue(const char *path, const char *key, float value) = 0;
+    virtual float   getValue(const char *path, const char *key) = 0;
+    virtual int     getCount(const char *path, const char *key) = 0;
 
-    virtual int                     insertToDataSet(const char *path, const char *key, float v, float x, float y, float z) = 0;
-    virtual const DNStorageDataSet  *queryDataSet(const char *path, const char *key, const DNStorageDataSetQuery *query) const = 0;
-    virtual bool                    updateDataSet(const char *path, const char *key, int index, float v, float x, float y, float z) = 0;
-    virtual bool                    deleteFromDataSet(const char *path, const char *key, int index) = 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 bool                    isValid() = 0;
+    virtual bool    isValid() = 0;
 
-    virtual bool   flush() = 0;
+    virtual bool    flush() = 0;
+
+    virtual bool    startTransaction() = 0;
+    virtual bool    commitTransaction() = 0;
 };
 
 #endif // DNSOTRAGEIMPL_H

diff --git a/Source/QtScript/dnqsbasicstoragecell.cpp b/Source/QtScript/dnqsbasicstoragecell.cpp
index 9d9ed6f..82c09d2 100644 (file)
--- a/Source/QtScript/dnqsbasicstoragecell.cpp
+++ b/Source/QtScript/dnqsbasicstoragecell.cpp
@@ -26,91 +26,235 @@
 #include "DNUtils.h"
 #include "DNStorage.h"
 
-static QScriptValue scriptStorageSetValue(QScriptContext *context, QScriptEngine *engine)
-{
-    QScriptValue data = context->thisObject().data();
-    TKASSERT(data.isQObject());
-    DNQSBasicStorageCell::QObjectSelfWrapper *wrapper = (DNQSBasicStorageCell::QObjectSelfWrapper*) data.toQObject();
-    TKASSERT(wrapper);
-    if (wrapper && context->argumentCount() >= 2)
-    {
-        wrapper->setValue(context->argument(0).toString().toUtf8().constData(),context->argument(1).toNumber());
-    }
-    return engine->nullValue();
-}
-
-static QScriptValue scriptStorageGetValue(QScriptContext *context, QScriptEngine *engine)
-{
-    QScriptValue data = context->thisObject().data();
-    TKASSERT(data.isQObject());
-    DNQSBasicStorageCell::QObjectSelfWrapper *wrapper = (DNQSBasicStorageCell::QObjectSelfWrapper*) data.toQObject();
-    TKASSERT(wrapper);
-    if (wrapper && context->argumentCount() >= 1)
-    {
-        QByteArray qkey = context->argument(0).toString().toUtf8();
-        const char *key = qkey.constData();
-        if (wrapper->getCount(key) == 0)
-        {
-            return engine->undefinedValue();
-        }
-        else
-        {
-            return QScriptValue(wrapper->getValue(key));
-        }
-    }
-    return engine->nullValue();
-}
-
+QScriptString DNQSBasicStorageCell::mLengthQSString;
+QScriptString DNQSBasicStorageCell::mXQSString;
+QScriptString DNQSBasicStorageCell::mYQSString;
+QScriptString DNQSBasicStorageCell::mZQSString;
+QScriptString DNQSBasicStorageCell::mVQSString;
 
 DNQSBasicStorageCell::DNQSBasicStorageCell(DNQSContainer *container, std::string location, std::string name, bool canInterface) :
     DNQSBasicCell(container, location, name, canInterface)
 {
 
     mQSStorage = mEngine->newObject();
-    mQSStorage.setProperty("setValue",mEngine->newFunction(scriptStorageSetValue, 2));
-    mQSStorage.setProperty("getValue",mEngine->newFunction(scriptStorageGetValue, 1));
+    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.setData(mEngine->newQObject(this));
     mQSAPIInstance.setProperty("storage", mQSStorage,QScriptValue::ReadOnly|QScriptValue::Undeletable);
-    mQSelf = new QObjectSelfWrapper(this);
-    mQSStorage.setData(mEngine->newQObject(mQSelf));
-}
 
-DNQSBasicStorageCell::~DNQSBasicStorageCell()
-{
-    if (mQSelf)
+    if (!mLengthQSString.isValid())
     {
-        delete mQSelf;
-        mQSelf = NULL;
+        mLengthQSString = mEngine->toStringHandle("length");
+        mVQSString = mEngine->toStringHandle("v");
+        mXQSString = mEngine->toStringHandle("x");
+        mYQSString = mEngine->toStringHandle("y");
+        mZQSString = mEngine->toStringHandle("z");
     }
 }
 
-DNQSBasicStorageCell::QObjectSelfWrapper::QObjectSelfWrapper(DNQSBasicStorageCell *self) : mSelf(self)
+DNQSBasicStorageCell::~DNQSBasicStorageCell()
 {
-    mPath = getFQNString(self->mLocation.c_str(), self->mName.c_str());
 }
 
-int DNQSBasicStorageCell::QObjectSelfWrapper::getCount(const char* key)
+int DNQSBasicStorageCell::getCount_storage(const char* key)
 {
-    DNStorage *storage = mSelf->mContainer->getDataStore();
+    DNStorage *storage = mContainer->getDataStore();
     if (storage)
         return storage->getCount(mPath.c_str(),key);
     else
         return 0;
 }
 
-float DNQSBasicStorageCell::QObjectSelfWrapper::getValue(const char *key)
+float DNQSBasicStorageCell::getValue_storage(const char *key)
 {
-    DNStorage *storage = mSelf->mContainer->getDataStore();
+    DNStorage *storage = mContainer->getDataStore();
     if (storage)
         return storage->getValue(mPath.c_str(), key);
     else
         return 0.0;
 }
 
-bool DNQSBasicStorageCell::QObjectSelfWrapper::setValue(const char *key, float value)
+bool DNQSBasicStorageCell::setValue_storage(const char *key, float value)
 {
-    DNStorage *storage = mSelf->mContainer->getDataStore();
+    DNStorage *storage = mContainer->getDataStore();
     if (storage)
         return storage->setValue(mPath.c_str(), key, value);
     else
         return false;
 }
+
+int DNQSBasicStorageCell::getXYZArrayCount_storage(const char* key)
+{
+    DNStorage *storage = mContainer->getDataStore();
+    if (storage)
+    {
+        return storage->countXYZData(mPath.c_str(), key);
+    }
+    else
+        return 0;
+
+}
+
+const DNStorageXYZDataRecords* DNQSBasicStorageCell::getXYZArray_storage(const char *key)
+{
+    DNStorage *storage = mContainer->getDataStore();
+    if (storage)
+        return storage->queryXYZData(mPath.c_str(), key);
+    else
+        return NULL;
+
+}
+
+bool DNQSBasicStorageCell::setXYZArray_storage(const char *key, QScriptValue array)
+{
+    if (!array.isArray())
+        return false;
+
+    DNStorage *storage = mContainer->getDataStore();
+    if (storage == NULL)
+        return false;
+
+    int length = array.property(mLengthQSString).toInt32();
+    const char *path = mPath.c_str();
+
+    storage->startTransaction();
+
+    storage->deleteXYZData(path,key);
+
+    for (int i = 0; i < length; i++)
+    {
+        QScriptValue item = array.property(i);
+        float v = 0;
+        float x = 0;
+        float y = 0;
+        float z = 0;
+
+        QScriptValue sv =  item.property(mVQSString);
+        if (sv.isNumber())
+        {
+            v = sv.toNumber();
+        }
+        QScriptValue sx =  item.property(mXQSString);
+        if (sx.isNumber())
+        {
+            x = sx.toNumber();
+        }
+        QScriptValue sy =  item.property(mYQSString);
+        if (sy.isNumber())
+        {
+            y = sy.toNumber();
+        }
+        QScriptValue sz =  item.property(mZQSString);
+        if (sz.isNumber())
+        {
+            z = sz.toNumber();
+        }
+        storage->insertXYZData(path,key,v,x,y,z);
+    }
+
+    storage->commitTransaction();
+
+    return true;
+}
+
+//static
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_setValue(QScriptContext *context, QScriptEngine *engine)
+{
+    QScriptValue data = context->thisObject().data();
+    TKASSERT(data.isQObject());
+    DNQSBasicStorageCell *cell = (DNQSBasicStorageCell*) data.toQObject();
+    TKASSERT(cell);
+    if (cell && context->argumentCount() >= 2)
+    {
+        cell->setValue_storage(context->argument(0).toString().toUtf8().constData(),context->argument(1).toNumber());
+    }
+    return QScriptValue(engine, true);
+}
+
+//static
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getValue(QScriptContext *context, QScriptEngine *engine)
+{
+    QScriptValue data = context->thisObject().data();
+    TKASSERT(data.isQObject());
+    DNQSBasicStorageCell *cell = (DNQSBasicStorageCell*) data.toQObject();
+    TKASSERT(cell);
+    if (cell && context->argumentCount() >= 1)
+    {
+        QByteArray qkey = context->argument(0).toString().toUtf8();
+        const char *key = qkey.constData();
+        if (cell->getCount_storage(key) == 0)
+        {
+            return engine->undefinedValue();
+        }
+        else
+        {
+            return QScriptValue(cell->getValue_storage(key));
+        }
+    }
+    return engine->undefinedValue();
+}
+
+//static
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_setXYZArray(QScriptContext *context, QScriptEngine *engine)
+{
+    QScriptValue data = context->thisObject().data();
+    TKASSERT(data.isQObject());
+    DNQSBasicStorageCell *cell = (DNQSBasicStorageCell*) data.toQObject();
+    TKASSERT(cell);
+    bool r = false;
+    if (cell && context->argumentCount() >= 2)
+    {
+        QByteArray qkey = context->argument(0).toString().toUtf8();
+        const char *key = qkey.constData();
+        QScriptValue array = context->argument(1);
+        r = cell->setXYZArray_storage(key, array);
+    }
+    return QScriptValue(engine, r);
+}
+
+//static
+QScriptValue DNQSBasicStorageCell::scriptFunction_storage_getXYZArray(QScriptContext *context, QScriptEngine *engine)
+{
+    QScriptValue thisObj = context->thisObject();
+    QScriptValue data = thisObj.data();
+    TKASSERT(data.isQObject());
+    DNQSBasicStorageCell *cell = (DNQSBasicStorageCell*) data.toQObject();
+    TKASSERT(cell);
+    if (cell && context->argumentCount() >= 1)
+    {
+        QByteArray qkey = context->argument(0).toString().toUtf8();
+        const char *key = qkey.constData();
+
+        if (cell->getXYZArrayCount_storage(key) == 0)
+        {
+            return engine->undefinedValue();
+        }
+        else
+        {
+            QScriptValue result = engine->newArray();
+            const DNStorageXYZDataRecords *records = cell->getXYZArray_storage(key);
+            if (records)
+            {
+                QScriptValue pushScriptFunction = result.property("push");
+
+                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);
+                    QScriptValueList args;
+                    args << item;
+                    pushScriptFunction.call(thisObj, args);
+                }
+            }
+            return result;
+        }
+    }
+    return engine->undefinedValue();
+}
+

diff --git a/Source/QtScript/dnqsbasicstoragecell.h b/Source/QtScript/dnqsbasicstoragecell.h
index d4cb777..e018ac7 100644 (file)
--- a/Source/QtScript/dnqsbasicstoragecell.h
+++ b/Source/QtScript/dnqsbasicstoragecell.h
@@ -27,29 +27,39 @@
 
 #include <string>
 
-class DNQSBasicStorageCell : public DNQSBasicCell
+class DNStorageXYZDataRecords;
+
+class DNQSBasicStorageCell : public QObject, public DNQSBasicCell
 {
 public:
     DNQSBasicStorageCell(DNQSContainer *container, std::string location, std::string name, bool canInterface = false);
     virtual ~DNQSBasicStorageCell();
 
-    class QObjectSelfWrapper : public QObject
-    {
-    public:
-        QObjectSelfWrapper(DNQSBasicStorageCell *self);
+protected:
+    QScriptValue        mQSStorage;
+    std::string         mPath;
 
-        int     getCount(const char* key);
-        float   getValue(const char *key);
-        bool    setValue(const char *key, float value);
+private:
+    int     getCount_storage(const char* key);
+    float   getValue_storage(const char *key);
+    bool    setValue_storage(const char *key, float value);
 
-    private:
-        DNQSBasicStorageCell    *mSelf;
-        std::string             mPath;
-    };
+    int             getXYZArrayCount_storage(const char* key);
+    const DNStorageXYZDataRecords*
+                    getXYZArray_storage(const char *key);
+    bool            setXYZArray_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 QScriptString mLengthQSString;
+    static QScriptString mXQSString;
+    static QScriptString mYQSString;
+    static QScriptString mZQSString;
+    static QScriptString mVQSString;
 
-private:
-    QScriptValue        mQSStorage;
-    QObjectSelfWrapper  *mQSelf;
 };
 
 #endif // DNQSBASICSTORAGECELL_H

diff --git a/Source/platform/qt/qtdnstorageimpl.cpp b/Source/platform/qt/qtdnstorageimpl.cpp
index 8433035..29612d1 100644 (file)
--- a/Source/platform/qt/qtdnstorageimpl.cpp
+++ b/Source/platform/qt/qtdnstorageimpl.cpp
@@ -40,6 +40,7 @@ QtDNStorageImpl::~QtDNStorageImpl()
 
     if (mDatabase)
     {
+        mDatabase->database.rollback();
         QString connectionName = mDatabase->database.connectionName();
         if (mDatabase->database.isValid() && mDatabase->database.isOpen())
         {
@@ -158,7 +159,7 @@ int QtDNStorageImpl::getCount(const char *path, const char *key)
 }
 
 
-int QtDNStorageImpl::insertToDataSet(const char *path, const char *key, float v, float x, float y, float z)
+int QtDNStorageImpl::countXYZData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
         return 0;
@@ -166,7 +167,7 @@ int QtDNStorageImpl::insertToDataSet(const char *path, const char *key, float v,
     return 0;
 }
 
-const DNStorageDataSet* QtDNStorageImpl::queryDataSet(const char *path, const char *key, const DNStorageDataSetQuery *query) const
+int QtDNStorageImpl::insertXYZData(const char *path, const char *key, float v, float x, float y, float z)
 {
     if (mQueries == NULL || !mIsValid)
         return 0;
@@ -174,15 +175,15 @@ const DNStorageDataSet* QtDNStorageImpl::queryDataSet(const char *path, const ch
     return 0;
 }
 
-bool QtDNStorageImpl::updateDataSet(const char *path, const char *key, int index, float v, float x, float y, float z)
+const DNStorageXYZDataRecords* QtDNStorageImpl::queryXYZData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
-        return false;
+        return 0;
     //TODO
-    return false;
+    return 0;
 }
 
-bool QtDNStorageImpl::deleteFromDataSet(const char *path, const char *key, int index)
+bool QtDNStorageImpl::deleteXYZData(const char *path, const char *key)
 {
     if (mQueries == NULL || !mIsValid)
         return false;
@@ -190,14 +191,29 @@ bool QtDNStorageImpl::deleteFromDataSet(const char *path, const char *key, int i
     return false;
 }
 
+
 bool QtDNStorageImpl::flush()
 {
     if (mDatabase == NULL || !mIsValid)
         return false;
 
-    mDatabase->database.commit();
+    return mDatabase->database.commit();
+}
 
-    return true;
+bool QtDNStorageImpl::startTransaction()
+{
+    if (mDatabase == NULL || !mIsValid)
+        return false;
+
+    return mDatabase->database.transaction();
+}
+
+bool QtDNStorageImpl::commitTransaction()
+{
+    if (mDatabase == NULL || !mIsValid)
+        return false;
+
+    return mDatabase->database.commit();
 }
 
 bool QtDNStorageImpl::initDB()
@@ -244,11 +260,11 @@ bool QtDNStorageImpl::initDB()
         }
     }
 
-    if (!tables.contains("dataset"))
+    if (!tables.contains("xyzdata"))
     {
         QSqlQuery q;
 
-        if (!q.exec("CREATE TABLE dataset(cell TEXT, dskey TEXT, dsindex INTEGER, v REAL, x REAL, y REAL, z REAL, PRIMARY KEY (cell, dskey, dsindex))"));
+        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 (mDatabase->database.lastError().type() !=  QSqlError::NoError)
             {
@@ -273,9 +289,9 @@ 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->dataSetInsetToDataSetQuery.prepare("INSERT INTO dataset (?,?,?, ?,?,?,?)");
-    mQueries->dataSetUpdateDataSetQuery.prepare("UPDATE SET v=?, x=?, y=? z=? WHERE cell=? and dskey=? and dsindex=?");
-    mQueries->dataSetDeleteFromDataSetQuery.prepare("DELETE FROM dataset WHERE cell=? and key=? and index=?");
+    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=?");
 
     if (mDatabase->database.lastError().type() != QSqlError::NoError)
     {

diff --git a/Source/platform/qt/qtdnstorageimpl.h b/Source/platform/qt/qtdnstorageimpl.h
index d9aebe3..df38e03 100644 (file)
--- a/Source/platform/qt/qtdnstorageimpl.h
+++ b/Source/platform/qt/qtdnstorageimpl.h
@@ -38,9 +38,9 @@ public:
     QSqlQuery   propertiesUpdateQuery;
     QSqlQuery   propertiesGetQuery;
 
-    QSqlQuery   dataSetInsetToDataSetQuery;
-    QSqlQuery   dataSetUpdateDataSetQuery;
-    QSqlQuery   dataSetDeleteFromDataSetQuery;
+    QSqlQuery   xyzDataInsetQuery;
+    QSqlQuery   xyzDataRemoveQuery;
+    QSqlQuery   xyzDataCountQuery;
 };
 
 class QtDNStorageImpl : public DNStorageImpl
@@ -49,19 +49,23 @@ public:
     QtDNStorageImpl(const char *storagePath);
     virtual ~QtDNStorageImpl();
 
-    virtual bool                    setValue(const char *path, const char *key, float value);
-    virtual float                   getValue(const char *path, const char *key);
-    virtual int                     getCount(const char *path, const char *key);
+    virtual bool    setValue(const char *path, const char *key, float value);
+    virtual float   getValue(const char *path, const char *key);
+    virtual int     getCount(const char *path, const char *key);
 
-    virtual int                     insertToDataSet(const char *path, const char *key, float v, float x, float y, float z);
-    virtual const DNStorageDataSet  *queryDataSet(const char *path, const char *key, const DNStorageDataSetQuery *query) const;
-    virtual bool                    updateDataSet(const char *path, const char *key, int index, float v, float x, float y, float z);
-    virtual bool                    deleteFromDataSet(const char *path, const char *key, int index);
+    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 bool    flush();
 
     virtual bool    isValid() { return mIsValid; }
 
+    virtual bool    startTransaction();
+    virtual bool    commitTransaction();
+
 private:
     bool            initDB();
     bool            mIsValid;