src/sql/kernel/qsqlcachedresult.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtSql module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "private/qsqlcachedresult_p.h"
  43
  44 #include <qvariant.h>
  45 #include <qdatetime.h>
  46 #include <qvector.h>
  47
  48 QT_BEGIN_NAMESPACE
  49
  50 /*
  51    QSqlCachedResult is a convenience class for databases that only allow
  52    forward only fetching. It will cache all the results so we can iterate
  53    backwards over the results again.
  54
  55    All you need to do is to inherit from QSqlCachedResult and reimplement
  56    gotoNext(). gotoNext() will have a reference to the internal cache and
  57    will give you an index where you can start filling in your data. Special
  58    case: If the user actually wants a forward-only query, idx will be -1
  59    to indicate that we are not interested in the actual values.
  60 */
  61
  62 static const uint initial_cache_size = 128;
  63
  64 class QSqlCachedResultPrivate
  65 {
  66 public:
  67     QSqlCachedResultPrivate();
  68     bool canSeek(int i) const;
  69     inline int cacheCount() const;
  70     void init(int count, bool fo);
  71     void cleanup();
  72     int nextIndex();
  73     void revertLast();
  74
  75     QSqlCachedResult::ValueCache cache;
  76     int rowCacheEnd;
  77     int colCount;
  78     bool forwardOnly;
  79     bool atEnd;
  80 };
  81
  82 QSqlCachedResultPrivate::QSqlCachedResultPrivate():
  83     rowCacheEnd(0), colCount(0), forwardOnly(false), atEnd(false)
  84 {
  85 }
  86
  87 void QSqlCachedResultPrivate::cleanup()
  88 {
  89     cache.clear();
  90     forwardOnly = false;
  91     atEnd = false;
  92     colCount = 0;
  93     rowCacheEnd = 0;
  94 }
  95
  96 void QSqlCachedResultPrivate::init(int count, bool fo)
  97 {
  98     Q_ASSERT(count);
  99     cleanup();
 100     forwardOnly = fo;
 101     colCount = count;
 102     if (fo) {
 103         cache.resize(count);
 104         rowCacheEnd = count;
 105     } else {
 106         cache.resize(initial_cache_size * count);
 107     }
 108 }
 109
 110 int QSqlCachedResultPrivate::nextIndex()
 111 {
 112     if (forwardOnly)
 113         return 0;
 114     int newIdx = rowCacheEnd;
 115     if (newIdx + colCount > cache.size())
 116         cache.resize(qMin(cache.size() * 2, cache.size() + 10000));
 117     rowCacheEnd += colCount;
 118
 119     return newIdx;
 120 }
 121
 122 bool QSqlCachedResultPrivate::canSeek(int i) const
 123 {
 124     if (forwardOnly || i < 0)
 125         return false;
 126     return rowCacheEnd >= (i + 1) * colCount;
 127 }
 128
 129 void QSqlCachedResultPrivate::revertLast()
 130 {
 131     if (forwardOnly)
 132         return;
 133     rowCacheEnd -= colCount;
 134 }
 135
 136 inline int QSqlCachedResultPrivate::cacheCount() const
 137 {
 138     Q_ASSERT(!forwardOnly);
 139     Q_ASSERT(colCount);
 140     return rowCacheEnd / colCount;
 141 }
 142
 143 //////////////
 144
 145 QSqlCachedResult::QSqlCachedResult(const QSqlDriver * db): QSqlResult (db)
 146 {
 147     d = new QSqlCachedResultPrivate();
 148 }
 149
 150 QSqlCachedResult::~QSqlCachedResult()
 151 {
 152     delete d;
 153 }
 154
 155 void QSqlCachedResult::init(int colCount)
 156 {
 157     d->init(colCount, isForwardOnly());
 158 }
 159
 160 bool QSqlCachedResult::fetch(int i)
 161 {
 162     if ((!isActive()) || (i < 0))
 163         return false;
 164     if (at() == i)
 165         return true;
 166     if (d->forwardOnly) {
 167         // speed hack - do not copy values if not needed
 168         if (at() > i || at() == QSql::AfterLastRow)
 169             return false;
 170         while(at() < i - 1) {
 171             if (!gotoNext(d->cache, -1))
 172                 return false;
 173             setAt(at() + 1);
 174         }
 175         if (!gotoNext(d->cache, 0))
 176             return false;
 177         setAt(at() + 1);
 178         return true;
 179     }
 180     if (d->canSeek(i)) {
 181         setAt(i);
 182         return true;
 183     }
 184     if (d->rowCacheEnd > 0)
 185         setAt(d->cacheCount());
 186     while (at() < i + 1) {
 187         if (!cacheNext()) {
 188             if (d->canSeek(i))
 189                 break;
 190             return false;
 191         }
 192     }
 193     setAt(i);
 194
 195     return true;
 196 }
 197
 198 bool QSqlCachedResult::fetchNext()
 199 {
 200     if (d->canSeek(at() + 1)) {
 201         setAt(at() + 1);
 202         return true;
 203     }
 204     return cacheNext();
 205 }
 206
 207 bool QSqlCachedResult::fetchPrevious()
 208 {
 209     return fetch(at() - 1);
 210 }
 211
 212 bool QSqlCachedResult::fetchFirst()
 213 {
 214     if (d->forwardOnly && at() != QSql::BeforeFirstRow) {
 215         return false;
 216     }
 217     if (d->canSeek(0)) {
 218         setAt(0);
 219         return true;
 220     }
 221     return cacheNext();
 222 }
 223
 224 bool QSqlCachedResult::fetchLast()
 225 {
 226     if (d->atEnd) {
 227         if (d->forwardOnly)
 228             return false;
 229         else
 230             return fetch(d->cacheCount() - 1);
 231     }
 232
 233     int i = at();
 234     while (fetchNext())
 235         ++i; /* brute force */
 236     if (d->forwardOnly && at() == QSql::AfterLastRow) {
 237         setAt(i);
 238         return true;
 239     } else {
 240         return fetch(i);
 241     }
 242 }
 243
 244 QVariant QSqlCachedResult::data(int i)
 245 {
 246     int idx = d->forwardOnly ? i : at() * d->colCount + i;
 247     if (i >= d->colCount || i < 0 || at() < 0 || idx >= d->rowCacheEnd)
 248         return QVariant();
 249
 250     return d->cache.at(idx);
 251 }
 252
 253 bool QSqlCachedResult::isNull(int i)
 254 {
 255     int idx = d->forwardOnly ? i : at() * d->colCount + i;
 256     if (i > d->colCount || i < 0 || at() < 0 || idx >= d->rowCacheEnd)
 257         return true;
 258
 259     return d->cache.at(idx).isNull();
 260 }
 261
 262 void QSqlCachedResult::cleanup()
 263 {
 264     setAt(QSql::BeforeFirstRow);
 265     setActive(false);
 266     d->cleanup();
 267 }
 268
 269 void QSqlCachedResult::clearValues()
 270 {
 271     setAt(QSql::BeforeFirstRow);
 272     d->rowCacheEnd = 0;
 273     d->atEnd = false;
 274 }
 275
 276 bool QSqlCachedResult::cacheNext()
 277 {
 278     if (d->atEnd)
 279         return false;
 280
 281     if (!gotoNext(d->cache, d->nextIndex())) {
 282         d->revertLast();
 283         d->atEnd = true;
 284         return false;
 285     }
 286     setAt(at() + 1);
 287     return true;
 288 }
 289
 290 int QSqlCachedResult::colCount() const
 291 {
 292     return d->colCount;
 293 }
 294
 295 QSqlCachedResult::ValueCache &QSqlCachedResult::cache()
 296 {
 297     return d->cache;
 298 }
 299
 300 void QSqlCachedResult::virtual_hook(int id, void *data)
 301 {
 302     switch (id) {
 303     case QSqlResult::DetachFromResultSet:
 304     case QSqlResult::SetNumericalPrecision:
 305         cleanup();
 306         break;
 307     default:
 308         QSqlResult::virtual_hook(id, data);
 309     }
 310 }
 311
 312
 313 QT_END_NAMESPACE