1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qsqlrelationaltablemodel.h"
5
6#include "qhash.h"
7#include "qstringlist.h"
8#include "qsqldatabase.h"
9#include "qsqldriver.h"
10#include "qsqlerror.h"
11#include "qsqlfield.h"
12#include "qsqlindex.h"
13#include "qsqlquery.h"
14#include "qsqlrecord.h"
15
16#include "qsqltablemodel_p.h"
17
18#include "qdebug.h"
19
20QT_BEGIN_NAMESPACE
21
22using namespace Qt::StringLiterals;
23
24class QSqlRelationalTableModelSql: public QSqlQueryModelSql
25{
26public:
27 inline const static QString relTablePrefix(int i) { return QString::number(i).prepend(s: "relTblAl_"_L1); }
28};
29
30using SqlrTm = QSqlRelationalTableModelSql;
31
32/*!
33 \class QSqlRelation
34 \inmodule QtSql
35 \brief The QSqlRelation class stores information about an SQL foreign key.
36
37 QSqlRelation is a helper class for QSqlRelationalTableModel. See
38 QSqlRelationalTableModel::setRelation() and
39 QSqlRelationalTableModel::relation() for details.
40
41 \sa QSqlRelationalTableModel, QSqlRelationalDelegate,
42 {Relational Table Model Example}
43*/
44
45/*!
46 \fn QSqlRelation::QSqlRelation()
47
48 Constructs an invalid QSqlRelation object.
49
50 For such an object, the tableName(), indexColumn(), and
51 displayColumn() functions return an empty string.
52
53 \sa isValid()
54*/
55
56/*!
57 \fn QSqlRelation::QSqlRelation(const QString &tableName, const QString &indexColumn,
58 const QString &displayColumn)
59
60 Constructs a QSqlRelation object, where \a tableName is the SQL
61 table name to which a foreign key refers, \a indexColumn is the
62 foreign key, and \a displayColumn is the field that should be
63 presented to the user.
64
65 \sa tableName(), indexColumn(), displayColumn()
66*/
67
68/*!
69 \fn void QSqlRelation::swap(QSqlRelation &other)
70
71 Swaps \c this with \a other.
72 */
73
74/*!
75 \fn QString QSqlRelation::tableName() const
76
77 Returns the name of the table to which a foreign key refers.
78*/
79
80/*!
81 \fn QString QSqlRelation::indexColumn() const
82
83 Returns the index column from table tableName() to which a
84 foreign key refers.
85*/
86
87/*!
88 \fn QString QSqlRelation::displayColumn() const
89
90 Returns the column from table tableName() that should be
91 presented to the user instead of a foreign key.
92*/
93
94/*!
95 \fn bool QSqlRelation::isValid() const
96
97 Returns \c true if the QSqlRelation object is valid; otherwise
98 returns \c false.
99*/
100
101class QRelatedTableModel;
102
103struct QRelation
104{
105 public:
106 Q_DISABLE_COPY(QRelation) // QRelatedTableModel stores a pointer to this class
107 QRelation() = default;
108 void init(QSqlRelationalTableModel *parent, const QSqlRelation &relation, int column);
109
110 void populateModel();
111
112 bool isDictionaryInitialized() const;
113 void populateDictionary();
114 void clearDictionary();
115
116 void clear();
117 bool isValid() const;
118
119 QSqlRelation rel;
120 QRelatedTableModel *model = nullptr;
121 QHash<QString, QVariant> dictionary;//maps keys to display values
122
123 private:
124 QSqlRelationalTableModel *m_parent = nullptr;
125 int col = -1;
126 bool m_dictInitialized = false;
127};
128
129class QRelatedTableModel : public QSqlTableModel
130{
131public:
132 QRelatedTableModel(QRelation *rel, QObject *parent, const QSqlDatabase &db);
133 bool select() override;
134private:
135 bool firstSelect;
136 QRelation *relation;
137};
138/*
139 A QRelation must be initialized before it is considered valid.
140 Note: population of the model and dictionary are kept separate
141 from initialization, and are populated on an as needed basis.
142*/
143void QRelation::init(QSqlRelationalTableModel *parent, const QSqlRelation &relation, int column)
144{
145 Q_ASSERT(parent != nullptr);
146 m_parent = parent;
147 rel = relation;
148 col = column;
149}
150
151void QRelation::populateModel()
152{
153 if (!isValid())
154 return;
155 Q_ASSERT(m_parent != nullptr);
156
157 if (!model) {
158 model = new QRelatedTableModel(this, m_parent, m_parent->database());
159 model->setTable(rel.tableName());
160 model->select();
161 QObject::connect(sender: model, signal: &QAbstractItemModel::dataChanged, context: model, slot: [&](const QModelIndex &tl, const QModelIndex &br)
162 {
163 if (tl.column() >= col && br.column() <= col)
164 clearDictionary();
165 });
166 QObject::connect(sender: model, signal: &QAbstractItemModel::rowsRemoved, context: model, slot: [&]()
167 {
168 clearDictionary();
169 });
170 QObject::connect(sender: model, signal: &QAbstractItemModel::rowsInserted, context: model, slot: [&]()
171 {
172 clearDictionary();
173 });
174 }
175}
176
177bool QRelation::isDictionaryInitialized() const
178{
179 return m_dictInitialized;
180}
181
182void QRelation::populateDictionary()
183{
184 if (!isValid())
185 return;
186
187 if (model == nullptr)
188 populateModel();
189
190 QSqlRecord record;
191 QString indexColumn;
192 QString displayColumn;
193 for (int i=0; i < model->rowCount(); ++i) {
194 record = model->record(row: i);
195
196 indexColumn = rel.indexColumn();
197 if (m_parent->database().driver()->isIdentifierEscaped(identifier: indexColumn, type: QSqlDriver::FieldName))
198 indexColumn = m_parent->database().driver()->stripDelimiters(identifier: indexColumn, type: QSqlDriver::FieldName);
199
200 displayColumn = rel.displayColumn();
201 if (m_parent->database().driver()->isIdentifierEscaped(identifier: displayColumn, type: QSqlDriver::FieldName))
202 displayColumn = m_parent->database().driver()->stripDelimiters(identifier: displayColumn, type: QSqlDriver::FieldName);
203
204 dictionary[record.field(name: indexColumn).value().toString()] =
205 record.field(name: displayColumn).value();
206 }
207 m_dictInitialized = true;
208}
209
210void QRelation::clearDictionary()
211{
212 dictionary.clear();
213 m_dictInitialized = false;
214}
215
216void QRelation::clear()
217{
218 delete model;
219 model = nullptr;
220 clearDictionary();
221}
222
223bool QRelation::isValid() const
224{
225 return (rel.isValid() && m_parent != nullptr);
226}
227
228
229
230QRelatedTableModel::QRelatedTableModel(QRelation *rel, QObject *parent, const QSqlDatabase &db) :
231 QSqlTableModel(parent, db), firstSelect(true), relation(rel)
232{
233}
234
235bool QRelatedTableModel::select()
236{
237 if (firstSelect) {
238 firstSelect = false;
239 return QSqlTableModel::select();
240 }
241 relation->clearDictionary();
242 bool res = QSqlTableModel::select();
243 if (res)
244 relation->populateDictionary();
245 return res;
246}
247
248
249class QSqlRelationalTableModelPrivate: public QSqlTableModelPrivate
250{
251 Q_DECLARE_PUBLIC(QSqlRelationalTableModel)
252public:
253 QSqlRelationalTableModelPrivate()
254 : QSqlTableModelPrivate(),
255 joinMode( QSqlRelationalTableModel::InnerJoin )
256 {}
257 QString fullyQualifiedFieldName(const QString &tableName, const QString &fieldName) const;
258
259 int nameToIndex(const QString &name) const override;
260 QList<QSharedPointer<QRelation>> relations;
261 QSqlRecord baseRec; // the record without relations
262 void clearChanges();
263 void clearCache() override;
264 void revertCachedRow(int row) override;
265
266 void translateFieldNames(QSqlRecord &values) const;
267 QSqlRelationalTableModel::JoinMode joinMode;
268};
269
270void QSqlRelationalTableModelPrivate::clearChanges()
271{
272 for (auto &rel : relations)
273 rel->clear();
274}
275
276void QSqlRelationalTableModelPrivate::revertCachedRow(int row)
277{
278 QSqlTableModelPrivate::revertCachedRow(row);
279}
280
281int QSqlRelationalTableModelPrivate::nameToIndex(const QString &name) const
282{
283 const QString fieldname = strippedFieldName(name);
284 int idx = baseRec.indexOf(name: fieldname);
285 if (idx == -1) {
286 // If the name is an alias we can find it here.
287 idx = QSqlTableModelPrivate::nameToIndex(name);
288 }
289 return idx;
290}
291
292void QSqlRelationalTableModelPrivate::clearCache()
293{
294 for (auto &rel : relations)
295 rel->clearDictionary();
296
297 QSqlTableModelPrivate::clearCache();
298}
299
300/*!
301 \class QSqlRelationalTableModel
302 \brief The QSqlRelationalTableModel class provides an editable
303 data model for a single database table, with foreign key support.
304
305 \ingroup database
306 \inmodule QtSql
307
308 QSqlRelationalTableModel acts like QSqlTableModel, but allows
309 columns to be set as foreign keys into other database tables.
310
311 \table
312 \row \li \inlineimage noforeignkeys.png
313 \li \inlineimage foreignkeys.png
314 \endtable
315
316 The screenshot on the left shows a plain QSqlTableModel in a
317 QTableView. Foreign keys (\c city and \c country) aren't resolved
318 to human-readable values. The screenshot on the right shows a
319 QSqlRelationalTableModel, with foreign keys resolved into
320 human-readable text strings.
321
322 The following code snippet shows how the QSqlRelationalTableModel
323 was set up:
324
325 \snippet relationaltablemodel/relationaltablemodel.cpp 0
326 \codeline
327 \snippet relationaltablemodel/relationaltablemodel.cpp 1
328 \snippet relationaltablemodel/relationaltablemodel.cpp 2
329
330 The setRelation() function calls establish a relationship between
331 two tables. The first call specifies that column 2 in table \c
332 employee is a foreign key that maps with field \c id of table \c
333 city, and that the view should present the \c{city}'s \c name
334 field to the user. The second call does something similar with
335 column 3.
336
337 If you use a read-write QSqlRelationalTableModel, you probably
338 want to use QSqlRelationalDelegate on the view. Unlike the default
339 delegate, QSqlRelationalDelegate provides a combobox for fields
340 that are foreign keys into other tables. To use the class, simply
341 call QAbstractItemView::setItemDelegate() on the view with an
342 instance of QSqlRelationalDelegate:
343
344 \snippet relationaltablemodel/relationaltablemodel.cpp 4
345
346 The \l{relationaltablemodel} example illustrates how to use
347 QSqlRelationalTableModel in conjunction with
348 QSqlRelationalDelegate to provide tables with foreign key
349 support.
350
351 \image relationaltable.png
352
353 Notes:
354
355 \list
356 \li The table must have a primary key declared.
357 \li The table's primary key may not contain a relation to
358 another table.
359 \li If a relational table contains keys that refer to non-existent
360 rows in the referenced table, the rows containing the invalid
361 keys will not be exposed through the model. The user or the
362 database is responsible for keeping referential integrity.
363 \li If a relation's display column name is also used as a column
364 name in the relational table, or if it is used as display column
365 name in more than one relation it will be aliased. The alias is
366 the relation's table name, display column name and a unique id
367 joined by an underscore (e.g. tablename_columnname_id).
368 QSqlRecord::fieldName() will return the aliased column name.
369 All occurrences of the duplicate display column name are aliased when
370 duplication is detected, but no aliasing is done to the column
371 names in the main table. The aliasing doesn't affect
372 QSqlRelation, so QSqlRelation::displayColumn() will return the
373 original display column name.
374 \li The reference table name is aliased. The alias is the word "relTblAl"
375 and the relationed column index joined by an underscore
376 (e.g. relTblAl_2). The alias can be used to filter the table
377 (For example, setFilter("relTblAl_2='Oslo' OR
378 relTblAl_3='USA'")).
379 \li When using setData() the role should always be Qt::EditRole,
380 and when using data() the role should always be Qt::DisplayRole.
381 \endlist
382
383 \sa QSqlRelation, QSqlRelationalDelegate,
384 {Relational Table Model Example}
385*/
386
387
388/*!
389 Creates an empty QSqlRelationalTableModel and sets the parent to \a parent
390 and the database connection to \a db. If \a db is not valid, the
391 default database connection will be used.
392*/
393QSqlRelationalTableModel::QSqlRelationalTableModel(QObject *parent, const QSqlDatabase &db)
394 : QSqlTableModel(*new QSqlRelationalTableModelPrivate, parent, db)
395{
396}
397
398/*!
399 Destroys the object and frees any allocated resources.
400*/
401QSqlRelationalTableModel::~QSqlRelationalTableModel()
402{
403}
404
405/*!
406 \reimp
407*/
408QVariant QSqlRelationalTableModel::data(const QModelIndex &index, int role) const
409{
410 Q_D(const QSqlRelationalTableModel);
411
412 if (role == Qt::DisplayRole && index.column() >= 0 && index.column() < d->relations.size() &&
413 d->relations.at(i: index.column())->isValid()) {
414 auto relation = d->relations.at(i: index.column());
415 if (!relation->isDictionaryInitialized())
416 relation->populateDictionary();
417
418 //only perform a dictionary lookup for the display value
419 //when the value at index has been changed or added.
420 //At an unmodified index, the underlying model will
421 //already have the correct display value.
422 if (d->strategy != OnFieldChange) {
423 const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(key: index.row());
424 if (row.op() != QSqlTableModelPrivate::None && row.rec().isGenerated(i: index.column())) {
425 if (d->strategy == OnManualSubmit || row.op() != QSqlTableModelPrivate::Delete) {
426 QVariant v = row.rec().value(i: index.column());
427 if (v.isValid())
428 return relation->dictionary[v.toString()];
429 }
430 }
431 }
432 }
433 return QSqlTableModel::data(idx: index, role);
434}
435
436/*!
437 Sets the data for the \a role in the item with the specified \a
438 index to the \a value given. Depending on the edit strategy, the
439 value might be applied to the database at once, or it may be
440 cached in the model.
441
442 Returns \c true if the value could be set, or false on error (for
443 example, if \a index is out of bounds).
444
445 For relational columns, \a value must be the index, not the
446 display value. The index must also exist in the referenced
447 table, otherwise the function returns \c false.
448
449 \sa editStrategy(), data(), submit(), revertRow()
450*/
451bool QSqlRelationalTableModel::setData(const QModelIndex &index, const QVariant &value,
452 int role)
453{
454 Q_D(QSqlRelationalTableModel);
455 if ( role == Qt::EditRole && index.column() > 0 && index.column() < d->relations.size()
456 && d->relations.at(i: index.column())->isValid()) {
457 auto relation = d->relations.at(i: index.column());
458 if (!relation->isDictionaryInitialized())
459 relation->populateDictionary();
460 if (!relation->dictionary.contains(key: value.toString()))
461 return false;
462 }
463 return QSqlTableModel::setData(index, value, role);
464}
465
466/*!
467 Lets the specified \a column be a foreign index specified by \a relation.
468
469 Example:
470
471 \snippet relationaltablemodel/relationaltablemodel.cpp 0
472 \codeline
473 \snippet relationaltablemodel/relationaltablemodel.cpp 1
474
475 The setRelation() call specifies that column 2 in table \c
476 employee is a foreign key that maps with field \c id of table \c
477 city, and that the view should present the \c{city}'s \c name
478 field to the user.
479
480 Note: The table's primary key may not contain a relation to another table.
481
482 \sa relation()
483*/
484void QSqlRelationalTableModel::setRelation(int column, const QSqlRelation &relation)
485{
486 Q_D(QSqlRelationalTableModel);
487 if (column < 0)
488 return;
489 if (d->relations.size() <= column) {
490 const auto oldSize = d->relations.size();
491 d->relations.resize(size: column + 1);
492 for (auto i = oldSize; i < d->relations.size(); ++i)
493 d->relations[i] = QSharedPointer<QRelation>::create();
494 }
495 d->relations.at(i: column)->init(parent: this, relation, column);
496}
497
498/*!
499 Returns the relation for the column \a column, or an invalid
500 relation if no relation is set.
501
502 \sa setRelation(), QSqlRelation::isValid()
503*/
504QSqlRelation QSqlRelationalTableModel::relation(int column) const
505{
506 Q_D(const QSqlRelationalTableModel);
507 return d->relations.value(i: column) ? d->relations.at(i: column)->rel : QSqlRelation();
508}
509
510QString QSqlRelationalTableModelPrivate::fullyQualifiedFieldName(const QString &tableName,
511 const QString &fieldName) const
512{
513 QString ret;
514 ret.reserve(asize: tableName.size() + fieldName.size() + 1);
515 ret.append(s: tableName).append(c: u'.').append(s: fieldName);
516
517 return ret;
518}
519
520/*!
521 \reimp
522*/
523QString QSqlRelationalTableModel::selectStatement() const
524{
525 Q_D(const QSqlRelationalTableModel);
526
527 if (tableName().isEmpty())
528 return QString();
529 if (d->relations.isEmpty())
530 return QSqlTableModel::selectStatement();
531
532 // Count how many times each field name occurs in the record
533 QHash<QString, int> fieldNames;
534 QStringList fieldList;
535 for (int i = 0; i < d->baseRec.count(); ++i) {
536 QSqlRelation relation = d->relations.value(i) ? d->relations.at(i)->rel : QSqlRelation();
537 QString name;
538 if (relation.isValid()) {
539 // Count the display column name, not the original foreign key
540 name = relation.displayColumn();
541 if (d->db.driver()->isIdentifierEscaped(identifier: name, type: QSqlDriver::FieldName))
542 name = d->db.driver()->stripDelimiters(identifier: name, type: QSqlDriver::FieldName);
543
544 const QSqlRecord rec = database().record(tablename: relation.tableName());
545 for (int i = 0; i < rec.count(); ++i) {
546 if (name.compare(s: rec.fieldName(i), cs: Qt::CaseInsensitive) == 0) {
547 name = rec.fieldName(i);
548 break;
549 }
550 }
551 }
552 else {
553 name = d->baseRec.fieldName(i);
554 }
555 fieldNames[name] = fieldNames.value(key: name, defaultValue: 0) + 1;
556 fieldList.append(t: name);
557 }
558
559 QString fList;
560 QString conditions;
561 QString from = SqlrTm::from(s: tableName());
562 for (int i = 0; i < d->baseRec.count(); ++i) {
563 QSqlRelation relation = d->relations.value(i) ? d->relations.at(i)->rel : QSqlRelation();
564 const QString tableField = d->fullyQualifiedFieldName(tableName: tableName(), fieldName: d->db.driver()->escapeIdentifier(identifier: d->baseRec.fieldName(i), type: QSqlDriver::FieldName));
565 if (relation.isValid()) {
566 const QString relTableAlias = SqlrTm::relTablePrefix(i);
567 QString displayTableField = d->fullyQualifiedFieldName(tableName: relTableAlias, fieldName: relation.displayColumn());
568
569 // Duplicate field names must be aliased
570 if (fieldNames.value(key: fieldList[i]) > 1) {
571 QString relTableName = relation.tableName().section(asep: QChar::fromLatin1(c: '.'), astart: -1, aend: -1);
572 if (d->db.driver()->isIdentifierEscaped(identifier: relTableName, type: QSqlDriver::TableName))
573 relTableName = d->db.driver()->stripDelimiters(identifier: relTableName, type: QSqlDriver::TableName);
574 QString displayColumn = relation.displayColumn();
575 if (d->db.driver()->isIdentifierEscaped(identifier: displayColumn, type: QSqlDriver::FieldName))
576 displayColumn = d->db.driver()->stripDelimiters(identifier: displayColumn, type: QSqlDriver::FieldName);
577 QString alias = QString::fromLatin1(ba: "%1_%2_%3")
578 .arg(args&: relTableName, args&: displayColumn, args: QString::number(fieldNames.value(key: fieldList[i])));
579 alias.truncate(pos: d->db.driver()->maximumIdentifierLength(type: QSqlDriver::FieldName));
580 alias = d->db.driver()->escapeIdentifier(identifier: alias, type: QSqlDriver::FieldName);
581 displayTableField = SqlrTm::as(a: displayTableField, b: alias);
582 --fieldNames[fieldList[i]];
583 }
584
585 fList = SqlrTm::comma(a: fList, b: displayTableField);
586
587 // Join related table
588 const QString tblexpr = SqlrTm::concat(a: relation.tableName(), b: relTableAlias);
589 const QString relTableField = d->fullyQualifiedFieldName(tableName: relTableAlias, fieldName: relation.indexColumn());
590 const QString cond = SqlrTm::eq(a: tableField, b: relTableField);
591 if (d->joinMode == QSqlRelationalTableModel::InnerJoin) {
592 // FIXME: InnerJoin code is known to be broken.
593 // Use LeftJoin mode if you want correct behavior.
594 from = SqlrTm::comma(a: from, b: tblexpr);
595 conditions = SqlrTm::et(a: conditions, b: cond);
596 } else {
597 from = SqlrTm::concat(a: from, b: SqlrTm::leftJoin(s: tblexpr));
598 from = SqlrTm::concat(a: from, b: SqlrTm::on(s: cond));
599 }
600 } else {
601 fList = SqlrTm::comma(a: fList, b: tableField);
602 }
603 }
604
605 if (fList.isEmpty())
606 return QString();
607
608 const QString stmt = SqlrTm::concat(a: SqlrTm::select(s: fList), b: from);
609 const QString where = SqlrTm::where(s: SqlrTm::et(a: SqlrTm::paren(s: conditions), b: SqlrTm::paren(s: filter())));
610 return SqlrTm::concat(a: SqlrTm::concat(a: stmt, b: where), b: orderByClause());
611}
612
613/*!
614 Returns a QSqlTableModel object for accessing the table for which
615 \a column is a foreign key, or \nullptr if there is no relation for
616 the given \a column.
617
618 The returned object is owned by the QSqlRelationalTableModel.
619
620 \sa setRelation(), relation()
621*/
622QSqlTableModel *QSqlRelationalTableModel::relationModel(int column) const
623{
624 Q_D(const QSqlRelationalTableModel);
625 if (column < 0 || column >= d->relations.size())
626 return nullptr;
627
628 auto relation = d->relations.at(i: column);
629 if (!relation || !relation->isValid())
630 return nullptr;
631
632 if (!relation->model)
633 relation->populateModel();
634 return relation->model;
635}
636
637/*!
638 \reimp
639*/
640void QSqlRelationalTableModel::revertRow(int row)
641{
642 QSqlTableModel::revertRow(row);
643}
644
645/*!
646 \reimp
647*/
648void QSqlRelationalTableModel::clear()
649{
650 Q_D(QSqlRelationalTableModel);
651 beginResetModel();
652 d->clearChanges();
653 d->relations.clear();
654 QSqlTableModel::clear();
655 endResetModel();
656}
657
658
659/*! \enum QSqlRelationalTableModel::JoinMode
660
661 \value InnerJoin - Inner join mode, return rows when there is at least one match in both tables.
662 \value LeftJoin - Left join mode, returns all rows from the left table (table_name1), even if there are no matches in the right table (table_name2).
663
664 \sa QSqlRelationalTableModel::setJoinMode()
665*/
666
667/*!
668 Sets the SQL \a joinMode to show or hide rows with NULL foreign keys.
669 In InnerJoin mode (the default) these rows will not be shown: use the
670 LeftJoin mode if you want to show them.
671
672 \sa QSqlRelationalTableModel::JoinMode
673*/
674void QSqlRelationalTableModel::setJoinMode( QSqlRelationalTableModel::JoinMode joinMode )
675{
676 Q_D(QSqlRelationalTableModel);
677 d->joinMode = joinMode;
678}
679/*!
680 \reimp
681*/
682bool QSqlRelationalTableModel::select()
683{
684 return QSqlTableModel::select();
685}
686
687/*!
688 \reimp
689*/
690void QSqlRelationalTableModel::setTable(const QString &table)
691{
692 Q_D(QSqlRelationalTableModel);
693
694 // memorize the table before applying the relations
695 d->baseRec = d->db.record(tablename: table);
696
697 QSqlTableModel::setTable(table);
698}
699
700/*! \internal
701 */
702void QSqlRelationalTableModelPrivate::translateFieldNames(QSqlRecord &values) const
703{
704 for (int i = 0; i < values.count(); ++i) {
705 if (relations.value(i) && relations.at(i)->isValid()) {
706 QVariant v = values.value(i);
707 bool gen = values.isGenerated(i);
708 values.replace(pos: i, field: baseRec.field(i));
709 values.setValue(i, val: v);
710 values.setGenerated(i, generated: gen);
711 }
712 }
713}
714
715/*!
716 \reimp
717*/
718bool QSqlRelationalTableModel::updateRowInTable(int row, const QSqlRecord &values)
719{
720 Q_D(QSqlRelationalTableModel);
721
722 QSqlRecord rec = values;
723 d->translateFieldNames(values&: rec);
724
725 return QSqlTableModel::updateRowInTable(row, values: rec);
726}
727
728/*!
729 \reimp
730*/
731bool QSqlRelationalTableModel::insertRowIntoTable(const QSqlRecord &values)
732{
733 Q_D(QSqlRelationalTableModel);
734
735 QSqlRecord rec = values;
736 d->translateFieldNames(values&: rec);
737
738 return QSqlTableModel::insertRowIntoTable(values: rec);
739}
740
741/*!
742 \reimp
743*/
744QString QSqlRelationalTableModel::orderByClause() const
745{
746 Q_D(const QSqlRelationalTableModel);
747
748 const QSqlRelation rel = d->relations.value(i: d->sortColumn) ? d->relations.at(i: d->sortColumn)->rel : QSqlRelation();
749 if (!rel.isValid())
750 return QSqlTableModel::orderByClause();
751
752 QString f = d->fullyQualifiedFieldName(tableName: SqlrTm::relTablePrefix(i: d->sortColumn), fieldName: rel.displayColumn());
753 f = d->sortOrder == Qt::AscendingOrder ? SqlrTm::asc(s: f) : SqlrTm::desc(s: f);
754 return SqlrTm::orderBy(s: f);
755}
756
757/*!
758 \reimp
759*/
760bool QSqlRelationalTableModel::removeColumns(int column, int count, const QModelIndex &parent)
761{
762 Q_D(QSqlRelationalTableModel);
763
764 if (parent.isValid() || column < 0 || column + count > d->rec.count())
765 return false;
766
767 for (int i = 0; i < count; ++i) {
768 d->baseRec.remove(pos: column);
769 if (d->relations.size() > column)
770 d->relations.remove(i: column);
771 }
772 return QSqlTableModel::removeColumns(column, count, parent);
773}
774
775QT_END_NAMESPACE
776
777#include "moc_qsqlrelationaltablemodel.cpp"
778

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of qtbase/src/sql/models/qsqlrelationaltablemodel.cpp