if (orientation == Qt::Vertical && role == Qt::DisplayRole) {        switch (d->strategy) {        case OnFieldChange:        case OnRowChange:            if (d->insertIndex == section)                return QLatin1String("*");            break;        case OnManualSubmit:            QSqlTableModelPrivate::Op op = d->cache.value(section).op;            if (op == QSqlTableModelPrivate::Insert)                return QLatin1String("*");            else if (op == QSqlTableModelPrivate::Delete)                return QLatin1String("!");            break;        }    }    return QSqlQueryModel::headerData(section, orientation, role);}/*!    Returns true if the value at the index \a index is dirty, otherwise false.    Dirty values are values that were modified in the model    but not yet written into the database.    If \a index is invalid or points to a non-existing row, false is returned.*/bool QSqlTableModel::isDirty(const QModelIndex &index) const{    Q_D(const QSqlTableModel);    if (!index.isValid())        return false;    switch (d->strategy) {        case OnFieldChange:            return false;        case OnRowChange:            return index.row() == d->editIndex && d->editBuffer.value(index.column()).isValid();        case OnManualSubmit: {            const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(index.row());            return row.op == QSqlTableModelPrivate::Insert                   || row.op == QSqlTableModelPrivate::Delete                   || (row.op == QSqlTableModelPrivate::Update                       && row.rec.value(index.column()).isValid());        }    }    return false;}/*!    Sets the data for the item \a index for the role \a role to \a    value. Depending on the edit strategy, the value might be applied    to the database at once or cached in the model.    Returns true if the value could be set or false on error, for    example if \a index is out of bounds.    \sa editStrategy(), data(), submit(), submitAll(), revertRow()*/bool QSqlTableModel::setData(const QModelIndex &index, const QVariant &value, int role){    Q_D(QSqlTableModel);    if (role != Qt::EditRole)        return QSqlQueryModel::setData(index, value, role);    if (!index.isValid() || index.column() >= d->rec.count() || index.row() >= rowCount())        return false;    bool isOk = true;    switch (d->strategy) {    case OnFieldChange: {        if (index.row() == d->insertIndex) {            d->editBuffer.setValue(index.column(), value);            return true;        }        d->clearEditBuffer();        d->editBuffer.setValue(index.column(), value);        isOk = updateRowInTable(index.row(), d->editBuffer);        if (isOk)            select();        break; }    case OnRowChange:        if (index.row() == d->insertIndex) {            d->editBuffer.setValue(index.column(), value);            return true;        }        if (d->editIndex != index.row()) {            if (d->editIndex != -1)                submit();            d->clearEditBuffer();        }        d->editBuffer.setValue(index.column(), value);        d->editIndex = index.row();        emit dataChanged(index, index);        break;    case OnManualSubmit: {        QSqlTableModelPrivate::ModifiedRow &row = d->cache[index.row()];        if (row.op == QSqlTableModelPrivate::None) {            row.op = QSqlTableModelPrivate::Update;            row.rec = d->rec;        }        row.rec.setValue(index.column(), value);        emit dataChanged(index, index);        break; }    }    return isOk;}/*!    This function simply calls QSqlQueryModel::setQuery(\a query).    You should normally not call it on a QSqlTableModel. Instead, use    setTable(), setSort(), setFilter(), etc., to set up the query.    \sa selectStatement()*/void QSqlTableModel::setQuery(const QSqlQuery &query){    QSqlQueryModel::setQuery(query);}/*!    Updates the given \a row in the currently active database table    with the specified \a values. Returns true if successful; otherwise    returns false.    This is a low-level method that operates directly on the database    and should not be called directly. Use setData() to update values.    The model will decide depending on its edit strategy when to modify    the database.    Note that only values that have the generated-flag set are updated.    The generated-flag can be set with QSqlRecord::setGenerated() and    tested with QSqlRecord::isGenerated().    \sa QSqlRecord::isGenerated(), setData()*/bool QSqlTableModel::updateRowInTable(int row, const QSqlRecord &values){    Q_D(QSqlTableModel);    QSqlRecord rec(values);    emit beforeUpdate(row, rec);    const QSqlRecord whereValues = d->primaryValues(row);    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::UpdateStatement, d->tableName,                                                rec, prepStatement);    QString where = d->db.driver()->sqlStatement(QSqlDriver::WhereStatement, d->tableName,                                                 whereValues, prepStatement);    if (stmt.isEmpty() || where.isEmpty() || row < 0 || row >= rowCount()) {        d->error = QSqlError(QLatin1String("No Fields to update"), QString(),                                 QSqlError::StatementError);        return false;    }    stmt.append(QLatin1Char(' ')).append(where);    return d->exec(stmt, prepStatement, rec, whereValues);}/*!    Inserts the values \a values into the currently active database table.    This is a low-level method that operates directly on the database    and should not be called directly. Use insertRow() and setData()    to insert values. The model will decide depending on its edit strategy    when to modify the database.    Returns true if the values could be inserted, otherwise false.    Error information can be retrieved with \l lastError().    \sa lastError(), insertRow(), insertRows()*/bool QSqlTableModel::insertRowIntoTable(const QSqlRecord &values){    Q_D(QSqlTableModel);    QSqlRecord rec = values;    emit beforeInsert(rec);    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::InsertStatement, d->tableName,                                                rec, prepStatement);    return d->exec(stmt, prepStatement, rec);}/*!    Deletes the given \a row from the currently active database table.    This is a low-level method that operates directly on the database    and should not be called directly. Use removeRow() or removeRows()    to delete values. The model will decide depending on its edit strategy    when to modify the database.    Returns true if the row was deleted; otherwise returns false.    \sa removeRow(), removeRows()*/bool QSqlTableModel::deleteRowFromTable(int row){    Q_D(QSqlTableModel);    emit beforeDelete(row);    QSqlRecord rec = d->primaryValues(row);    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::DeleteStatement, d->tableName,                                                QSqlRecord(), prepStatement);    QString where = d->db.driver()->sqlStatement(QSqlDriver::WhereStatement, d->tableName,                                                rec, prepStatement);    if (stmt.isEmpty() || where.isEmpty()) {        d->error = QSqlError(QLatin1String("Unable to delete row"), QString(),                             QSqlError::StatementError);        return false;    }    stmt.append(QLatin1Char(' ')).append(where);    return d->exec(stmt, prepStatement, rec);}/*!    Submits all pending changes and returns true on success.    Returns false on error, detailed error information can be    obtained with lastError().    Note: In OnManualSubmit mode, already submitted changes won't    be cleared from the cache when submitAll() fails. This allows    transactions to be rolled back and resubmitted again without    losing data.    \sa revertAll(), lastError()*/bool QSqlTableModel::submitAll(){    Q_D(QSqlTableModel);    switch (d->strategy) {    case OnFieldChange:        if (d->insertIndex == -1)            return true;        // else fall through    case OnRowChange:        if (d->editBuffer.isEmpty())            return true;        if (d->insertIndex != -1) {            if (!insertRowIntoTable(d->editBuffer))                return false;        } else {            if (!updateRowInTable(d->editIndex, d->editBuffer))                return false;        }        d->clearEditBuffer();        d->editIndex = -1;        d->insertIndex = -1;        return select();    case OnManualSubmit:        for (QSqlTableModelPrivate::CacheMap::ConstIterator it = d->cache.constBegin();             it != d->cache.constEnd(); ++it) {            switch (it.value().op) {            case QSqlTableModelPrivate::Insert:                if (!insertRowIntoTable(it.value().rec))                    return false;                break;            case QSqlTableModelPrivate::Update:                if (!updateRowInTable(it.key(), it.value().rec))                    return false;                break;            case QSqlTableModelPrivate::Delete:                if (!deleteRowFromTable(it.key()))                    return false;                break;            case QSqlTableModelPrivate::None:                Q_ASSERT_X(false, "QSqlTableModel::submitAll()", "Invalid cache operation");                break;            }        }        d->cache.clear();        return select();    }    return false;}/*!    This reimplemented slot is called by the item delegates when the    user stopped editing the current row.    Submits the currently edited row if the model's strategy is set    to OnRowChange or OnFieldChange. Does nothing for the OnManualSubmit    strategy.    Use submitAll() to submit all pending changes for the    OnManualSubmit strategy.    Returns true on success; otherwise returns false. Use lastError()    to query detailed error information.    \sa revert(), revertRow(), submitAll(), revertAll(), lastError()*/bool QSqlTableModel::submit(){    Q_D(QSqlTableModel);    if (d->strategy == OnRowChange || d->strategy == OnFieldChange)        return submitAll();    return true;}/*!    This reimplemented slot is called by the item delegates when the    user canceled editing the current row.    Reverts the changes if the model's strategy is set to    OnRowChange. Does nothing for the other edit strategies.    Use revertAll() to revert all pending changes for the    OnManualSubmit strategy or revertRow() to revert a specific row.    \sa submit(), submitAll(), revertRow(), revertAll()*/void QSqlTableModel::revert(){    Q_D(QSqlTableModel);    if (d->strategy == OnRowChange)        revertAll();}/*!    \enum QSqlTableModel::EditStrategy    This enum type describes which strategy to choose when editing values in the database.    \value OnFieldChange  All changes to the model will be applied immediately to the database.    \value OnRowChange  Changes to a row will be applied when the user selects a different row.    \value OnManualSubmit  All changes will be cached in the model until either submitAll()                           or revertAll() is called.    Note: To prevent inserting only partly initialized rows into the database,    \c OnFieldChange will behave like \c OnRowChange for newly inserted rows.    \sa setEditStrategy()*//*!    Sets the strategy for editing values in the database to \a    strategy.    This will revert any pending changes.    \sa editStrategy(), revertAll()*/void QSqlTableModel::setEditStrategy(EditStrategy strategy){    Q_D(QSqlTableModel);    revertAll();    d->strategy = strategy;}/*!    Returns the current edit strategy.    \sa setEditStrategy()*/QSqlTableModel::EditStrategy QSqlTableModel::editStrategy() const{    Q_D(const QSqlTableModel);    return d->strategy;}/*!    Reverts all pending changes.    \sa revert(), revertRow(), submitAll()*/void QSqlTableModel::revertAll(){    Q_D(QSqlTableModel);    switch (d->strategy) {    case OnFieldChange:        break;    case OnRowChange:        if (d->editIndex != -1)            revertRow(d->editIndex);        else if (d->insertIndex != -1)            revertRow(d->insertIndex);        break;    case OnManualSubmit:        while (!d->cache.isEmpty())            revertRow(d->cache.constBegin().key());        break;    }}/*!    Reverts all changes for the specified \a row.    \sa revert(), revertAll(), submit(), submitAll()*/void QSqlTableModel::revertRow(int row){    if (row < 0)        return;    Q_D(QSqlTableModel);    switch (d->strategy) {    case OnFieldChange:        break;    case OnRowChange: {        if (d->editIndex == row) {            d->editBuffer.clear();            int oldIndex = d->editIndex;            d->editIndex = -1;            emit dataChanged(createIndex(oldIndex, 0), createIndex(oldIndex, columnCount()));        } else if (d->insertIndex == row) {            d->revertInsertedRow();        }        break; }    case OnManualSubmit:        d->revertCachedRow(row);        break;    }}