qsqlquerymodel.cpp

上传用户:binglan008
上传日期:2007-01-28
资源大小:53508k
文件大小:17k
源码类别:Linux/Unix编程
开发平台:MultiPlatform
  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
  4. **
  5. ** This file is part of the QtSql module of the Qt Toolkit.
  6. **
  7. ** This file may be used under the terms of the GNU General Public
  8. ** License version 2.0 as published by the Free Software Foundation
  9. ** and appearing in the file LICENSE.GPL included in the packaging of
  10. ** this file.  Please review the following information to ensure GNU
  11. ** General Public Licensing requirements will be met:
  12. ** http://trolltech.com/products/qt/licenses/licensing/opensource/
  13. **
  14. ** If you are unsure which license is appropriate for your use, please
  15. ** review the following information:
  16. ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
  17. ** or contact the sales department at sales@trolltech.com.
  18. **
  19. ** In addition, as a special exception, Trolltech gives you certain
  20. ** additional rights. These rights are described in the Trolltech GPL
  21. ** Exception version 1.0, which can be found at
  22. ** http://www.trolltech.com/products/qt/gplexception/ and in the file
  23. ** GPL_EXCEPTION.txt in this package.
  24. **
  25. ** In addition, as a special exception, Trolltech, as the sole copyright
  26. ** holder for Qt Designer, grants users of the Qt/Eclipse Integration
  27. ** plug-in the right for the Qt/Eclipse Integration to link to
  28. ** functionality provided by Qt Designer and its related libraries.
  29. **
  30. ** Trolltech reserves all rights not expressly granted herein.
  31. **
  32. ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  33. ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  34. **
  35. ****************************************************************************/
  36. #include "qsqlquerymodel.h"
  37. #include <qdebug.h>
  38. #include <qsqldriver.h>
  39. #include <qsqlfield.h>
  40. #include "qsqlquerymodel_p.h"
  41. #define QSQL_PREFETCH 255
  42. void QSqlQueryModelPrivate::prefetch(int limit)
  43. {
  44.     Q_Q(QSqlQueryModel);
  45.     if (atEnd || limit <= bottom.row() || bottom.column() == -1)
  46.         return;
  47.     QModelIndex newBottom;
  48.     const int oldBottomRow = qMax(bottom.row(), 0);
  49.     // try to seek directly
  50.     if (query.seek(limit)) {
  51.         newBottom = q->createIndex(limit, bottom.column());
  52.     } else {
  53.         // have to seek back to our old position for MS Access
  54.         int i = oldBottomRow;
  55.         if (query.seek(i)) {
  56.             while (query.next())
  57.                 ++i;
  58.             newBottom = q->createIndex(i, bottom.column());
  59.         } else {
  60.             // empty or invalid query
  61.             newBottom = q->createIndex(-1, bottom.column());
  62.         }
  63.         atEnd = true; // this is the end.
  64.     }
  65.     if (newBottom.row() >= 0 && newBottom.row() > bottom.row()) {
  66.         q->beginInsertRows(QModelIndex(), bottom.row() + 1, newBottom.row());
  67.         bottom = newBottom;
  68.         q->endInsertRows();
  69.     } else {
  70.         bottom = newBottom;
  71.     }
  72. }
  73. QSqlQueryModelPrivate::~QSqlQueryModelPrivate()
  74. {
  75. }
  76. void QSqlQueryModelPrivate::initColOffsets(int size)
  77. {
  78.     colOffsets.resize(size);
  79.     memset(colOffsets.data(), 0, colOffsets.size() * sizeof(int));
  80. }
  81. /*!
  82.     class QSqlQueryModel
  83.     brief The QSqlQueryModel class provides a read-only data model for SQL
  84.     result sets.
  85.     ingroup database
  86.     module sql
  87.     QSqlQueryModel is a high-level interface for executing SQL
  88.     statements and traversing the result set. It is built on top of
  89.     the lower-level QSqlQuery and can be used to provide data to
  90.     view classes such as QTableView. For example:
  91.     quotefromfile snippets/sqldatabase/sqldatabase.cpp
  92.     skipto QSqlQueryModel_snippets
  93.     skipto QSqlQueryModel *model
  94.     printuntil show()
  95.     We set the model's query, then we set up the labels displayed in
  96.     the view header.
  97.     QSqlQueryModel can also be used to access a database
  98.     programmatically, without binding it to a view:
  99.     skipto QSqlQueryModel model;
  100.     printuntil int salary =
  101.     The code snippet above extracts the c salary field from record 4 in
  102.     the result set of the query c{SELECT * from employee}. Assuming
  103.     that c salary is column 2, we can rewrite the last line as follows:
  104.     skipto int salary =
  105.     printline int salary =
  106.     The model is read-only by default. To make it read-write, you
  107.     must subclass it and reimplement setData() and flags(). Another
  108.     option is to use QSqlTableModel, which provides a read-write
  109.     model based on a single database table.
  110.     The l{sql/querymodel} example illustrates how to use
  111.     QSqlQueryModel to display the result of a query. It also shows
  112.     how to subclass QSqlQueryModel to customize the contents of the
  113.     data before showing it to the user, and how to create a
  114.     read-write model based on QSqlQueryModel.
  115.     If the database doesn't return the amount of selected rows in
  116.     a query, the model will fetch rows incrementally.
  117.     See fetchMore() for more information.
  118.     sa QSqlTableModel, QSqlRelationalTableModel, QSqlQuery,
  119.         {Model/View Programming}, {Query Model Example}
  120. */
  121. /*!
  122.     Creates an empty QSqlQueryModel with the given a parent.
  123.  */
  124. QSqlQueryModel::QSqlQueryModel(QObject *parent)
  125.     : QAbstractTableModel(*new QSqlQueryModelPrivate, parent)
  126. {
  127. }
  128. /*! internal
  129.  */
  130. QSqlQueryModel::QSqlQueryModel(QSqlQueryModelPrivate &dd, QObject *parent)
  131.     : QAbstractTableModel(dd, parent)
  132. {
  133. }
  134. /*!
  135.     Destroys the object and frees any allocated resources.
  136.     sa clear()
  137. */
  138. QSqlQueryModel::~QSqlQueryModel()
  139. {
  140. }
  141. /*!
  142.     since 4.1
  143.     Fetches more rows from a database.
  144.     This only affects databases that don't report back the size of a query
  145.     (see QSqlDriver::hasFeature()).
  146.     To force fetching of the entire database, you can use the following:
  147.     code
  148.     while (myModel->canFetchMore())
  149.         myModel->fetchMore();
  150.     endcode
  151.     a parent should always be an invalid QModelIndex.
  152.     sa canFetchMore()
  153. */
  154. void QSqlQueryModel::fetchMore(const QModelIndex &parent)
  155. {
  156.     Q_D(QSqlQueryModel);
  157.     if (parent.isValid())
  158.         return;
  159.     d->prefetch(qMax(d->bottom.row(), 0) + QSQL_PREFETCH);
  160. }
  161. /*!
  162.     since 4.1
  163.     Returns true if it is possible to read more rows from the database.
  164.     This only affects databases that don't report back the size of a query
  165.     (see QSqlDriver::hasFeature()).
  166.     a parent should always be an invalid QModelIndex.
  167.     sa fetchMore()
  168.  */
  169. bool QSqlQueryModel::canFetchMore(const QModelIndex &parent) const
  170. {
  171.     Q_D(const QSqlQueryModel);
  172.     return (!parent.isValid() && !d->atEnd);
  173. }
  174. /*! fn int QSqlQueryModel::rowCount(const QModelIndex &parent) const
  175.     since 4.1
  176.     If the database supports returning the size of a query
  177.     (see QSqlDriver::hasFeature()), the amount of rows of the current
  178.     query is returned. Otherwise, returns the amount of rows
  179.     currently cached on the client.
  180.     a parent should always be an invalid QModelIndex.
  181.     sa canFetchMore(), QSqlDriver::hasFeature()
  182.  */
  183. int QSqlQueryModel::rowCount(const QModelIndex &index) const
  184. {
  185.     Q_D(const QSqlQueryModel);
  186.     return index.isValid() ? 0 : d->bottom.row() + 1;
  187. }
  188. /*! reimp
  189.  */
  190. int QSqlQueryModel::columnCount(const QModelIndex &index) const
  191. {
  192.     Q_D(const QSqlQueryModel);
  193.     return index.isValid() ? 0 : d->rec.count();
  194. }
  195. /*!
  196.     Returns the value for the specified a item and a role.
  197.     If a item is out of bounds or if an error occurred, an invalid
  198.     QVariant is returned.
  199.     sa lastError()
  200. */
  201. QVariant QSqlQueryModel::data(const QModelIndex &item, int role) const
  202. {
  203.     Q_D(const QSqlQueryModel);
  204.     if (!item.isValid())
  205.         return QVariant();
  206.     QVariant v;
  207.     if (role & ~(Qt::DisplayRole | Qt::EditRole))
  208.         return v;
  209.     if (!d->rec.isGenerated(item.column()))
  210.         return v;
  211.     QModelIndex dItem = indexInQuery(item);
  212.     if (dItem.row() > d->bottom.row())
  213.         const_cast<QSqlQueryModelPrivate *>(d)->prefetch(dItem.row());
  214.     if (!d->query.seek(dItem.row())) {
  215.         d->error = d->query.lastError();
  216.         return v;
  217.     }
  218.     return d->query.value(dItem.column());
  219. }
  220. /*!
  221.     Returns the header data for the given a role in the a section
  222.     of the header with the specified a orientation.
  223. */
  224. QVariant QSqlQueryModel::headerData(int section, Qt::Orientation orientation, int role) const
  225. {
  226.     Q_D(const QSqlQueryModel);
  227.     if (orientation == Qt::Horizontal) {
  228.         QVariant val = d->headers.value(section).value(role);
  229.         if (role == Qt::DisplayRole && !val.isValid())
  230.             val = d->headers.value(section).value(Qt::EditRole);
  231.         if (val.isValid())
  232.             return val;
  233.         if (role == Qt::DisplayRole && d->rec.count() > section)
  234.             return d->rec.fieldName(section);
  235.     }
  236.     return QAbstractItemModel::headerData(section, orientation, role);
  237. }
  238. /*!
  239.     This virtual function is called whenever the query changes. The
  240.     default implementation does nothing.
  241.     query() returns the new query.
  242.     sa query(), setQuery()
  243.  */
  244. void QSqlQueryModel::queryChange()
  245. {
  246.     // do nothing
  247. }
  248. /*!
  249.     Resets the model and sets the data provider to be the given a
  250.     query. Note that the query must be active and must not be
  251.     isForwardOnly().
  252.     lastError() can be used to retrieve verbose information if there
  253.     was an error setting the query.
  254.     sa query(), QSqlQuery::isActive(), QSqlQuery::setForwardOnly(), lastError()
  255. */
  256. void QSqlQueryModel::setQuery(const QSqlQuery &query)
  257. {
  258.     Q_D(QSqlQueryModel);
  259.     QSqlRecord newRec = query.record();
  260.     bool columnsChanged = (newRec != d->rec);
  261.     bool hasQuerySize = query.driver()->hasFeature(QSqlDriver::QuerySize);
  262.     if (d->colOffsets.size() != newRec.count() || columnsChanged)
  263.         d->initColOffsets(newRec.count());
  264.     bool mustClearModel = d->bottom.isValid();
  265.     if (mustClearModel) {
  266.         d->atEnd = true;
  267.         beginRemoveRows(QModelIndex(), 0, qMax(d->bottom.row(), 0));
  268.         d->bottom = QModelIndex();
  269.     }
  270.     d->error = QSqlError();
  271.     d->query = query;
  272.     d->rec = newRec;
  273.    
  274.     if (mustClearModel)
  275.         endRemoveRows();
  276.     
  277.     d->atEnd = false;    
  278.     if (columnsChanged)
  279.         reset();
  280.     if (!query.isActive() || query.isForwardOnly()) {
  281.         d->atEnd = true;
  282.         d->bottom = QModelIndex();
  283.         if (query.isForwardOnly())
  284.             d->error = QSqlError(QLatin1String("Forward-only queries "
  285.                                                "cannot be used in a data model"),
  286.                                  QString(), QSqlError::ConnectionError);
  287.         else
  288.             d->error = query.lastError();
  289.         return;
  290.     }
  291.     QModelIndex newBottom;
  292.     if (hasQuerySize && d->query.size() > 0) {
  293.         newBottom = createIndex(d->query.size() - 1, d->rec.count() - 1);
  294.         beginInsertRows(QModelIndex(), 0, qMax(0, newBottom.row()));
  295.         d->bottom = createIndex(d->query.size() - 1, columnsChanged ? 0 : d->rec.count() - 1);
  296.         d->atEnd = true;
  297.         endInsertRows();
  298.     } else {
  299.         newBottom = createIndex(-1, d->rec.count() - 1);
  300.     }
  301.     d->bottom = newBottom;
  302.     queryChange();
  303.     // fetchMore does the rowsInserted stuff for incremental models
  304.     fetchMore();
  305. }
  306. /*! overload
  307.     Executes the query a query for the given database connection a
  308.     db. If no database is specified, the default connection is used.
  309.     lastError() can be used to retrieve verbose information if there
  310.     was an error setting the query.
  311.     Example:
  312.     code
  313.     QSqlQueryModel model;
  314.     model.setQuery("select * from MyTable");
  315.     if (model.lastError().isValid())
  316.         qDebug() << model.lastError();
  317.     endcode
  318.     sa query(), queryChange(), lastError()
  319. */
  320. void QSqlQueryModel::setQuery(const QString &query, const QSqlDatabase &db)
  321. {
  322.     setQuery(QSqlQuery(query, db));
  323. }
  324. /*!
  325.     Clears the model and releases any acquired resource.
  326. */
  327. void QSqlQueryModel::clear()
  328. {
  329.     Q_D(QSqlQueryModel);
  330.     d->error = QSqlError();
  331.     d->atEnd = true;
  332.     d->query.clear();
  333.     d->rec.clear();
  334.     d->colOffsets.clear();
  335.     d->bottom = QModelIndex();
  336.     d->headers.clear();
  337. }
  338. /*!
  339.     Sets the caption for a horizontal header for the specified a role to
  340.     a value. This is useful if the model is used to
  341.     display data in a view (e.g., QTableView).
  342.     Returns true if a orientation is Qt::Horizontal and
  343.     the a section refers to a valid section; otherwise returns
  344.     false.
  345.     Note that this function cannot be used to modify values in the
  346.     database since the model is read-only.
  347.     sa data()
  348.  */
  349. bool QSqlQueryModel::setHeaderData(int section, Qt::Orientation orientation,
  350.                                    const QVariant &value, int role)
  351. {
  352.     Q_D(QSqlQueryModel);
  353.     if (orientation != Qt::Horizontal || section < 0)
  354.         return false;
  355.     if (d->headers.size() <= section)
  356.         d->headers.resize(qMax(section + 1, 16));
  357.     d->headers[section][role] = value;
  358.     emit headerDataChanged(orientation, section, section);
  359.     return true;
  360. }
  361. /*!
  362.     Returns the QSqlQuery associated with this model.
  363.     sa setQuery()
  364. */
  365. QSqlQuery QSqlQueryModel::query() const
  366. {
  367.     Q_D(const QSqlQueryModel);
  368.     return d->query;
  369. }
  370. /*!
  371.     Returns information about the last error that occurred on the
  372.     database.
  373. */
  374. QSqlError QSqlQueryModel::lastError() const
  375. {
  376.     Q_D(const QSqlQueryModel);
  377.     return d->error;
  378. }
  379. /*!
  380.    Protected function which allows derived classes to set the value of
  381.    the last error that occurred on the database to a error.
  382.    sa lastError()
  383. */
  384. void QSqlQueryModel::setLastError(const QSqlError &error)
  385. {
  386.     Q_D(QSqlQueryModel);
  387.     d->error = error;
  388. }
  389. /*!
  390.     Returns the record containing information about the fields of the
  391.     current query. If a row is the index of a valid row, the record
  392.     will be populated with values from that row.
  393.     If the model is not initialized, an empty record will be
  394.     returned.
  395.     sa QSqlRecord::isEmpty()
  396. */
  397. QSqlRecord QSqlQueryModel::record(int row) const
  398. {
  399.     Q_D(const QSqlQueryModel);
  400.     if (row < 0)
  401.         return d->rec;
  402.     QSqlRecord rec = d->rec;
  403.     for (int i = 0; i < rec.count(); ++i)
  404.         rec.setValue(i, data(createIndex(row, i), Qt::EditRole));
  405.     return rec;
  406. }
  407. /*! overload
  408.     Returns an empty record containing information about the fields
  409.     of the current query.
  410.     If the model is not initialized, an empty record will be
  411.     returned.
  412.     sa QSqlRecord::isEmpty()
  413.  */
  414. QSqlRecord QSqlQueryModel::record() const
  415. {
  416.     Q_D(const QSqlQueryModel);
  417.     return d->rec;
  418. }
  419. /*!
  420.     Inserts a count columns into the model at position a column. The
  421.     a parent parameter must always be an invalid QModelIndex, since
  422.     the model does not support parent-child relationships.
  423.     Returns true if a column is within bounds; otherwise returns false.
  424.     By default, inserted columns are empty. To fill them with data,
  425.     reimplement data() and handle any inserted column separately:
  426.     quotefromfile snippets/sqldatabase/sqldatabase.cpp
  427.     skipto QSqlQueryModel_snippets
  428.     skipto MyModel::data(
  429.     printuntil /^}/
  430.     sa removeColumns()
  431. */
  432. bool QSqlQueryModel::insertColumns(int column, int count, const QModelIndex &parent)
  433. {
  434.     Q_D(QSqlQueryModel);
  435.     if (count <= 0 || parent.isValid() || column < 0 || column > d->rec.count())
  436.         return false;
  437.     beginInsertColumns(parent, column, column + count - 1);
  438.     for (int c = 0; c < count; ++c) {
  439.         QSqlField field;
  440.         field.setReadOnly(true);
  441.         field.setGenerated(false);
  442.         d->rec.insert(column, field);
  443.         if (d->colOffsets.size() < d->rec.count()) {
  444.             int nVal = d->colOffsets.isEmpty() ? 0 : d->colOffsets[d->colOffsets.size() - 1];
  445.             d->colOffsets.append(nVal);
  446.             Q_ASSERT(d->colOffsets.size() >= d->rec.count());
  447.         }
  448.         for (int i = column + 1; i < d->colOffsets.count(); ++i)
  449.             ++d->colOffsets[i];
  450.     }
  451.     endInsertColumns();
  452.     return true;
  453. }
  454. /*!
  455.     Removes a count columns from the model starting from position a
  456.     column. The a parent parameter must always be an invalid
  457.     QModelIndex, since the model does not support parent-child
  458.     relationships.
  459.     Removing columns effectively hides them. It does not affect the
  460.     underlying QSqlQuery.
  461.     Returns true if the columns were removed; otherwise returns false.
  462.  */
  463. bool QSqlQueryModel::removeColumns(int column, int count, const QModelIndex &parent)
  464. {
  465.     Q_D(QSqlQueryModel);
  466.     if (count <= 0 || parent.isValid() || column < 0 || column >= d->rec.count())
  467.         return false;
  468.     beginRemoveColumns(parent, column, column + count - 1);
  469.     int i;
  470.     for (i = 0; i < count; ++i)
  471.         d->rec.remove(column);
  472.     for (i = column; i < d->colOffsets.count(); ++i)
  473.         d->colOffsets[i] -= count;
  474.     endRemoveColumns();
  475.     return true;
  476. }
  477. /*!
  478.     Returns the index of the value in the database result set for the
  479.     given a item in the model.
  480.     The return value is identical to a item if no columns or rows
  481.     have been inserted, removed, or moved around.
  482.     Returns an invalid model index if a item is out of bounds or if
  483.     a item does not point to a value in the result set.
  484.     sa QSqlTableModel::indexInQuery(), insertColumns(), removeColumns()
  485. */
  486. QModelIndex QSqlQueryModel::indexInQuery(const QModelIndex &item) const
  487. {
  488.     Q_D(const QSqlQueryModel);
  489.     if (item.column() < 0 || item.column() >= d->rec.count()
  490.         || !d->rec.isGenerated(item.column()))
  491.         return QModelIndex();
  492.     return createIndex(item.row(), item.column() - d->colOffsets[item.column()],
  493.                        item.internalPointer());
  494. }