/*!    Returns the primary key for the current table, or an empty    QSqlIndex if the table is not set or has no primary key.    \sa setTable(), setPrimaryKey(), QSqlDatabase::primaryIndex()*/QSqlIndex QSqlTableModel::primaryKey() const{    Q_D(const QSqlTableModel);    return d->primaryIndex;}/*!    Protected method that allows subclasses to set the primary key to    \a key.    Normally, the primary index is set automatically whenever you    call setTable().    \sa primaryKey(), QSqlDatabase::primaryIndex()*/void QSqlTableModel::setPrimaryKey(const QSqlIndex &key){    Q_D(QSqlTableModel);    d->primaryIndex = key;}/*!    Returns a pointer to the used QSqlDatabase or 0 if no database was set.*/QSqlDatabase QSqlTableModel::database() const{    Q_D(const QSqlTableModel);     return d->db;}/*!    Sorts the data by \a column with the sort order \a order.    This will immediately select data, use setSort()    to set a sort order without populating the model with data.    \sa setSort(), select(), orderByClause()*/void QSqlTableModel::sort(int column, Qt::SortOrder order){    setSort(column, order);    select();}/*!    Sets the sort oder for \a column to \a order. This does not    affect the current data, to refresh the data using the new    sort order, call select().    \sa select(), orderByClause()*/void QSqlTableModel::setSort(int column, Qt::SortOrder order){    Q_D(QSqlTableModel);    d->sortColumn = column;    d->sortOrder = order;}/*!    Returns an SQL \c{ORDER BY} clause based on the currently set    sort order.    \sa setSort(), selectStatement()*/QString QSqlTableModel::orderByClause() const{    Q_D(const QSqlTableModel);    QString s;    QSqlField f = d->rec.field(d->sortColumn);    if (!f.isValid())        return s;    s.append(QLatin1String("ORDER BY ")).append(d->tableName).append(QLatin1Char('.')).append(f.name());    s += d->sortOrder == Qt::AscendingOrder ? QLatin1String(" ASC") : QLatin1String(" DESC");    return s;}/*!    Returns the index of the field \a fieldName.*/int QSqlTableModel::fieldIndex(const QString &fieldName) const{    Q_D(const QSqlTableModel);    return d->rec.indexOf(fieldName);}/*!    Returns the SQL \c SELECT statement used internally to populate    the model. The statement includes the filter and the \c{ORDER BY}    clause.    \sa filter(), orderByClause()*/QString QSqlTableModel::selectStatement() const{    Q_D(const QSqlTableModel);    QString query;    if (d->tableName.isEmpty()) {        d->error = QSqlError(QLatin1String("No table name given"), QString(),                             QSqlError::StatementError);        return query;    }    if (d->rec.isEmpty()) {        d->error = QSqlError(QLatin1String("Unable to find table ") + d->tableName, QString(),                             QSqlError::StatementError);        return query;    }    query = d->db.driver()->sqlStatement(QSqlDriver::SelectStatement, d->tableName,                                          d->rec, false);    if (query.isEmpty()) {        d->error = QSqlError(QLatin1String("Unable to select fields from table ") + d->tableName,                             QString(), QSqlError::StatementError);        return query;    }    if (!d->filter.isEmpty())        query.append(QLatin1String(" WHERE ")).append(d->filter);    QString orderBy(orderByClause());    if (!orderBy.isEmpty())        query.append(QLatin1Char(' ')).append(orderBy);    return query;}/*!    Removes \a count columns from the \a parent model, starting at    index \a column.    Returns if the columns were successfully removed; otherwise    returns false.    \sa removeRows()*/bool QSqlTableModel::removeColumns(int column, int count, const QModelIndex &parent){    Q_D(QSqlTableModel);    if (parent.isValid() || column < 0 || column + count > d->rec.count())        return false;    for (int i = 0; i < count; ++i)        d->rec.remove(column);    if (d->query.isActive())        return select();    return true;}/*!    Removes \a count rows starting at \a row. Since this model    does not support hierarchical structures, \a parent must be    an invalid model index.    Emits the beforeDelete() signal before a row is deleted.    Returns true if all rows could be removed; otherwise returns    false. Detailed error information can be retrieved using    lastError().    \sa removeColumns(), insertRows()*/bool QSqlTableModel::removeRows(int row, int count, const QModelIndex &parent){    Q_D(QSqlTableModel);    if (parent.isValid() || row < 0 || count <= 0)        return false;    int i;    switch (d->strategy) {    case OnFieldChange:    case OnRowChange:        for (i = 0; i < count; ++i) {            if (row + i == d->insertIndex)                d->revertInsertedRow();            else if (!deleteRowFromTable(row + i))                return false;        }        select();        break;    case OnManualSubmit:        for (i = 0; i < count; ++i) {            int idx = row + i;            if (idx >= rowCount())                return false;            if (d->cache.value(idx).op == QSqlTableModelPrivate::Insert)                revertRow(idx);            else                d->cache[idx].op = QSqlTableModelPrivate::Delete;        }        break;    }    return true;}/*!    Inserts \a count empty rows at position \a row. Note that \a    parent must be invalid, since this model does not support    parent-child relations.    Only one row at a time can be inserted when using the    OnFieldChange or OnRowChange update strategies.    The primeInsert() signal will be emitted for each new row.    Connect to it if you want to initialize the new row with default    values.    Returns false if the parameters are out of bounds; otherwise    returns true.    \sa primeInsert(), insertRecord()*/bool QSqlTableModel::insertRows(int row, int count, const QModelIndex &parent){    Q_D(QSqlTableModel);    if (row < 0 || count <= 0 || row > rowCount() || parent.isValid())        return false;    switch (d->strategy) {    case OnFieldChange:    case OnRowChange:        if (count != 1)            return false;        beginInsertRows(parent, row, row);        d->insertIndex = row;        // ### apply dangling changes...        d->clearEditBuffer();        emit primeInsert(row, d->editBuffer);        break;    case OnManualSubmit:        beginInsertRows(parent, row, row + count - 1);        if (!d->cache.isEmpty()) {            QMap<int, QSqlTableModelPrivate::ModifiedRow>::Iterator it = d->cache.end();            while (it != d->cache.begin() && (--it).key() >= row) {                int oldKey = it.key();                const QSqlTableModelPrivate::ModifiedRow oldValue = it.value();                d->cache.erase(it);                it = d->cache.insert(oldKey + count, oldValue);            }        }        for (int i = 0; i < count; ++i) {            d->cache[row + i] = QSqlTableModelPrivate::ModifiedRow(QSqlTableModelPrivate::Insert,                                                                   d->rec);            emit primeInsert(row + i, d->cache[row + i].rec);        }        break;    }    endInsertRows();    return true;}/*!    Inserts the \a record after \a row. If \a row is negative, the    record will be appended to the end. Calls insertRows() and    setRecord() internally.    Returns true if the row could be inserted, otherwise false.    \sa insertRows(), removeRows()*/bool QSqlTableModel::insertRecord(int row, const QSqlRecord &record){    Q_D(QSqlTableModel);    if (row < 0)        row = rowCount();    if (!insertRow(row, QModelIndex()))        return false;    if (!setRecord(row, record))        return false;    if (d->strategy == OnFieldChange || d->strategy == OnRowChange)        return submit();    return true;}/*! \reimp*/int QSqlTableModel::rowCount(const QModelIndex &parent) const{    Q_D(const QSqlTableModel);    if (parent.isValid())        return 0;    int rc = QSqlQueryModel::rowCount();    if (d->strategy == OnManualSubmit) {        for (QSqlTableModelPrivate::CacheMap::ConstIterator it = d->cache.constBegin();             it != d->cache.constEnd(); ++it) {             if (it.value().op == QSqlTableModelPrivate::Insert)                 ++rc;        }    } else if (d->insertIndex >= 0) {        ++rc;    }    return rc;}/*!    Returns the index of the value in the database result set for the    given \a item in the model.    The return value is identical to \a item if no columns or rows    have been inserted, removed, or moved around.    Returns an invalid model index if \a item is out of bounds or if    \a item does not point to a value in the result set.    \sa QSqlQueryModel::indexInQuery()*/QModelIndex QSqlTableModel::indexInQuery(const QModelIndex &item) const{    Q_D(const QSqlTableModel);    const QModelIndex it = QSqlQueryModel::indexInQuery(item);    if (d->strategy == OnManualSubmit) {        int rowOffset = 0;        QSqlTableModelPrivate::CacheMap::ConstIterator i = d->cache.constBegin();        while (i != d->cache.constEnd() && i.key() <= it.row()) {            if (i.value().op == QSqlTableModelPrivate::Insert)                ++rowOffset;            ++i;        }        return createIndex(it.row() - rowOffset, it.column(), it.internalPointer());    } else {        if (d->insertIndex >= 0 && it.row() >= d->insertIndex)            return createIndex(it.row() - 1, it.column(), it.internalPointer());    }    return it;}/*!    Returns the currently set filter.    \sa setFilter(), select()*/QString QSqlTableModel::filter() const{    Q_D(const QSqlTableModel);    return d->filter;}/*!    Sets the current filter to \a filter.    The filter is a SQL \c WHERE clause without the keyword \c WHERE    (for example, \c{name='Josephine')}.    If the model is already populated with data from a database,    the model re-selects it with the new filter. Otherwise, the filter    will be applied the next time select() is called.    \sa filter(), select(), selectStatement(), orderByClause()*/void QSqlTableModel::setFilter(const QString &filter){    Q_D(QSqlTableModel);    d->filter = filter;    if (d->query.isActive())        select();}/*! \reimp*/void QSqlTableModel::clear(){    Q_D(QSqlTableModel);    d->clear();    QSqlQueryModel::clear();}/*! \reimp*/Qt::ItemFlags QSqlTableModel::flags(const QModelIndex &index) const{    Q_D(const QSqlTableModel);    if (index.internalPointer() || index.column() < 0 || index.column() >= d->rec.count()        || index.row() < 0)        return 0;    if (d->rec.field(index.column()).isReadOnly())        return Qt::ItemIsSelectable | Qt::ItemIsEnabled;    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;}/*!    Sets the values at the specified \a row to the values of \a    record. Returns true if all the values could be set; otherwise    returns false.    \sa record()*/bool QSqlTableModel::setRecord(int row, const QSqlRecord &record){    Q_D(QSqlTableModel);    if (row >= rowCount())        return false;    bool isOk = true;    switch (d->strategy) {    case OnFieldChange:    case OnRowChange:        return d->setRecord(row, record);    case OnManualSubmit: {        QSqlTableModelPrivate::ModifiedRow &mrow = d->cache[row];        if (mrow.op == QSqlTableModelPrivate::None) {            mrow.op = QSqlTableModelPrivate::Update;            mrow.rec = d->rec;        }        for (int i = 0; i < record.count(); ++i) {            int idx = mrow.rec.indexOf(record.fieldName(i));            if (idx == -1)                isOk = false;            else                mrow.rec.setValue(idx, record.value(i));        }        return isOk; }    }    return false;}