Fix issue RedisInsight#3402

- Add rows cache class
- Fix issue in key models with partial loading

Author: uglide

src/app/dialogs/connect.cpp

@@ -208,6 +208,7 @@ bool ConnectionWindow::isConnectionSettingsValid()
 bool ConnectionWindow::isAdvancedSettingsValid()
 {
     markFieldValid(ui.namespaceSeparator);
+    markFieldValid(ui.keysPattern);
 
     bool isValid = !ui.namespaceSeparator->text().isEmpty()
             || !ui.keysPattern->text().isEmpty();

src/app/models/key-models/abstractkey.h

@@ -69,7 +69,7 @@ template < typename T > class KeyModel : public ValueEditor::Model
 
     virtual bool isRowLoaded(int rowIndex) override
     {
-        return 0 <= rowIndex && rowIndex < m_rowsCache.size();
+        return m_rowsCache.isRowLoaded(rowIndex);
     }
 
     virtual unsigned long rowsCount() override

src/app/models/key-models/hashkey.cpp

@@ -131,11 +131,11 @@ void HashKeyModel::deleteHashRow(const QByteArray &hashKey)
 }
 
 void HashKeyModel::addLoadedRowsToCache(const QVariantList &rows, int rowStart)
-{
-    unsigned int rowIndex = rowStart;
+{    
+    QList<QPair<QByteArray, QByteArray>> result;
 
     for (QVariantList::const_iterator item = rows.begin();
-         item != rows.end(); ++item, rowIndex++) {
+         item != rows.end(); ++item) {
 
         QPair<QByteArray, QByteArray> value;
         value.first = item->toByteArray();
@@ -145,6 +145,9 @@ void HashKeyModel::addLoadedRowsToCache(const QVariantList &rows, int rowStart)
             throw Exception("Partial data loaded from server");
 
         value.second = item->toByteArray();
-        m_rowsCache.push_back(value);
+        result.push_back(value);
     }
+
+    m_rowsCache.addLoadedRange({rowStart, rowStart + result.size() - 1},
+                               result);
 }

src/app/models/key-models/listlikekey.cpp

@@ -44,7 +44,12 @@ QVariant ListLikeKeyModel::getData(int rowIndex, int dataRole)
 
 void ListLikeKeyModel::addLoadedRowsToCache(const QVariantList &rows, int rowStart)
 {
+    QList<QByteArray> result;
+
     foreach (QVariant row, rows) {
-        m_rowsCache.push_back(row.toByteArray());
+        result.push_back(row.toByteArray());
     }
+
+    m_rowsCache.addLoadedRange({rowStart, rowStart + result.size() - 1},
+                               result);
 }

src/app/models/key-models/rowcache.h

@@ -2,32 +2,57 @@
 #include <QPair>
 #include <QList>
 #include <QHash>
+#include <exception>
 
+typedef long int RowIndex;
 
-template < typename T > class MappedCache
+class CacheRange : public QPair<RowIndex, RowIndex>
 {
 public:
-    typedef unsigned long int RowIndex;
-    typedef QPair<RowIndex, RowIndex> CacheRange;
+    CacheRange(const RowIndex& f = -1, const RowIndex& s = -1)
+        : QPair<RowIndex, RowIndex>(f, s)
+    {
+    }
+
+    bool isEmpty() const
+    {
+        return first == -1 && second == -1;
+    }
+};
+
 
+template < typename T > class MappedCache
+{
 public:
 
-    MappedCache()
-        : m_size(0)
+    MappedCache()    
+        : m_lastCacheRange(),
+          m_size(0),
+          m_valid(false)
     {
+    }
 
+    bool isValid() const
+    {
+        return m_valid;
     }
 
     void addLoadedRange(const CacheRange& range, const QList<T>& dataForRange)
     {
+        if (!isValid())
+            clear();
+
         m_mapping[range] = dataForRange;
         m_size += dataForRange.size();
+
+        if (range.second > m_lastCacheRange.second)
+            m_lastCacheRange = range;
     }
 
     bool isRowLoaded(RowIndex index)
     {
         CacheRange i = findTargetRange(index);
-        return i != CacheRange({-1, -1});
+        return !i.isEmpty();
     }
 
     T getRow(RowIndex index)
@@ -36,23 +61,46 @@ template < typename T > class MappedCache
             return T();
 
         CacheRange i = findTargetRange(index);
-
-        RowIndex mappedIndex = i.first - index;
-
-        return m_mapping.value(i).at(mappedIndex);
+        qDebug() << "get row with index" << (index - i.first);
+        return m_mapping[i].at(index - i.first);
     }
 
     T operator [](RowIndex index) {
         return getRow(index);
     }
 
-    void replace(RowIndex i, T row) {
-        if (!isRowLoaded(i)) {
-            return std::
+    void replace(RowIndex index, T row) {
+        if (!isRowLoaded(index)) {
+            throw std::out_of_range("Invalid row");
+        }
+        CacheRange i = findTargetRange(index);
+        return m_mapping[i].replace(index - i.first, row);
+    }
+
+    void removeAt(RowIndex index) {
+        if (!isRowLoaded(index)) {
+            throw std::out_of_range("Invalid row");
         }
+        CacheRange i = findTargetRange(index);
 
+        m_mapping[i].removeAt(index - i.first);
+        CacheRange newKey{i.first, i.second - 1};
+        replaceRangeInMapping(newKey, i);
+        m_valid = false;
+        m_size -= 1;
+    }
 
+    void push_back(const T& row) {
+        CacheRange newKey{0, 1};
 
+        if (!m_lastCacheRange.isEmpty()) {
+            newKey.first += m_lastCacheRange.first;
+            newKey.second += m_lastCacheRange.second;
+        }
+
+        m_mapping[m_lastCacheRange].push_back(row);
+        replaceRangeInMapping(newKey);
+        m_size += 1;
     }
 
     unsigned long long size() const
@@ -64,6 +112,8 @@ template < typename T > class MappedCache
     {
         m_mapping.clear();
         m_size = 0;
+        m_lastCacheRange = CacheRange();
+        m_valid = true;
     }
 
 private:
@@ -76,11 +126,23 @@ template < typename T > class MappedCache
                 return i.key();
             }
         }
-        return {-1, -1};
+        return CacheRange();
+    }
+
+    void replaceRangeInMapping(const CacheRange& newRange, const CacheRange& current = CacheRange())
+    {
+        CacheRange replaceKey = current.isEmpty()? m_lastCacheRange : current;
+
+        m_mapping[newRange] = m_mapping[replaceKey];
+        m_mapping.remove(current);
+
+        if (current.isEmpty())
+            m_lastCacheRange = newRange;
     }
 
 private:
+    CacheRange m_lastCacheRange;
     QHash<CacheRange, QList<T>> m_mapping;
     unsigned long long m_size;
+    bool m_valid;
 };
-

src/app/models/key-models/setkey.cpp

@@ -21,13 +21,9 @@ void SetKeyModel::updateRow(int rowIndex, const QVariantMap &row)
     QByteArray cachedRow = m_rowsCache[rowIndex];
     QByteArray newRow(row["value"].toByteArray());
 
-    // delete old value
     deleteSetRow(cachedRow);
-    m_rowsCache.removeAt(rowIndex);
-
-    // add new value
     addSetRow(newRow);
-    m_rowsCache.insert(rowIndex, newRow);
+    m_rowsCache.replace(rowIndex, newRow);
 }
 
 void SetKeyModel::addRow(const QVariantMap &row)
@@ -44,7 +40,7 @@ void SetKeyModel::removeRow(int i)
     if (!isRowLoaded(i))
         return;
 
-    QByteArray value = m_rowsCache.value(i);   
+    QByteArray value = m_rowsCache[i];
     deleteSetRow(value);
 
     m_rowCount--;

src/app/models/key-models/sortedsetkey.cpp

@@ -79,7 +79,7 @@ void SortedSetKeyModel::addRow(const QVariantMap &row)
                 row["score"].toDouble());
 
     if (addSortedSetRow(cachedRow.first, cachedRow.second)) {
-        m_rowsCache.append(cachedRow);
+        m_rowsCache.push_back(cachedRow);
         m_rowCount++;
     }
 }
@@ -89,7 +89,7 @@ void SortedSetKeyModel::removeRow(int i)
     if (!isRowLoaded(i))
         return;
 
-    QByteArray value = m_rowsCache.value(i).first;
+    QByteArray value = m_rowsCache[i].first;
 
     using namespace RedisClient;
 
@@ -134,8 +134,10 @@ void SortedSetKeyModel::deleteSortedSetRow(const QByteArray &value)
     }
 }
 
-void SortedSetKeyModel::addLoadedRowsToCache(const QVariantList &rows, int)
+void SortedSetKeyModel::addLoadedRowsToCache(const QVariantList &rows, int rowStart)
 {
+    QList<QPair<QByteArray, double>> result;
+
     for (QVariantList::const_iterator item = rows.begin();
          item != rows.end(); ++item) {
 
@@ -147,6 +149,9 @@ void SortedSetKeyModel::addLoadedRowsToCache(const QVariantList &rows, int)
             throw Exception("Partial data loaded from server");
 
         value.second = item->toDouble();
-        m_rowsCache.push_back(value);
+        result.push_back(value);
     }
+
+    m_rowsCache.addLoadedRange({rowStart, rowStart + result.size() - 1},
+                               result);
 }

src/app/models/key-models/stringkey.cpp

@@ -62,9 +62,8 @@ void StringKeyModel::updateRow(int rowIndex, const QVariantMap &row)
         throw Exception("Connection error: " + QString(e.what()));
     }
 
-    if (result.isOkMessage()) {
-        m_rowsCache.clear();
-        m_rowsCache.append(value);
+    if (result.isOkMessage()) {        
+        m_rowsCache.replace(0, value);
         m_notifier->dataLoaded();
     }
 }
@@ -104,7 +103,7 @@ bool StringKeyModel::loadValue()
     }
 
     m_rowsCache.clear();
-    m_rowsCache.append(result.getValue().toByteArray());
+    m_rowsCache.push_back(result.getValue().toByteArray());
 
     m_notifier->dataLoaded();
 

src/resources/qml/ValueTabs.qml

@@ -183,9 +183,9 @@ Repeater {
                             anchors.verticalCenter: parent.verticalCenter
                             color: truncated ? 'red' : styleData.textColor
                             elide: styleData.elideMode
-                            text: styleData.value + (truncated ? '...' : '')
+                            text: styleData.value ? styleData.value + (truncated ? '...' : '') : (styleData.column == 1)? "[not loaded from server]" : "--"
                             wrapMode: Text.WordWrap
-                            maximumLineCount: 1
+                            maximumLineCount: 1                            
                         }
                     }