How to Use a QSqlQueryModel in QML: Difference between revisions

From Qt Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
Line 1: Line 1:
[[Category:Snippets]]<br />[[Category:HowTo]]<br />[[Category:Developing_with_Qt::Qt Quick]]<br />[[Category:Developing_with_Qt::Qt Quick::QML]]<br />[[Category:Developing_with_Qt::Qt-Quick::Tutorial]]
[[Category:Snippets]]
[[Category:HowTo]]
[[Category:Developing_with_Qt::Qt Quick]]
[[Category:Developing_with_Qt::Qt Quick::QML]]
[[Category:Developing_with_Qt::Qt-Quick::Tutorial]]


'''English''' [[How_to_use_a_QSqlQueryModel_in_QML_Spanish|Spanish]] [[HowToUseAQSqlQueryModelInQML_Italian|Italian]]
'''English''' [[How_to_use_a_QSqlQueryModel_in_QML_Spanish|Spanish]] [[HowToUseAQSqlQueryModelInQML_Italian|Italian]]


[toc depth=&quot;3&amp;quot; align_right=&quot;no&amp;quot;]
[toc depth="3" align_right="no"]


= How to use a QSqlQueryModel in QML =
= How to use a QSqlQueryModel in QML =
Line 11: Line 15:
=== Introduction ===
=== Introduction ===


The software I develop, Photo Parata, is a client server application that uses a sql backend. Most of the time the data Photo Parata displays requires some joins. Because of this, most of the time the models are derived from QSqlQueryModel, not QSqlTableModel.<br />For QSqlRelationalTableModel, you can find an working but unexplained example at http://wiki.qt.io/QML_and_QSqlTableModel
The software I develop, Photo Parata, is a client server application that uses a sql backend. Most of the time the data Photo Parata displays requires some joins. Because of this, most of the time the models are derived from QSqlQueryModel, not QSqlTableModel.
For QSqlRelationalTableModel, you can find an working but unexplained example at http://wiki.qt.io/QML_and_QSqlTableModel


In this how to, I will walk you through the steps of setting up a custom model for QML, derived from QSqlQueryModel.
In this how to, I will walk you through the steps of setting up a custom model for QML, derived from QSqlQueryModel.


I would like to thank &quot;Christophe Dumez&amp;quot;:http://cdumez.blogspot.com/ for his blog &quot;How to use C++ list model in QML&amp;quot;:http://cdumez.blogspot.com/2010/11/how-to-use-c-list-model-in-qml.html. It was this blog that allowed me to piece the following together.
I would like to thank "Christophe Dumez":http://cdumez.blogspot.com/ for his blog "How to use C++ list model in QML":http://cdumez.blogspot.com/2010/11/how-to-use-c-list-model-in-qml.html. It was this blog that allowed me to piece the following together.


Other useful sources were : &quot;Using_QStandardItemModel_in_QML (wiki page)&quot;:http://www.developer.nokia.com/Community/Wiki/Using_QStandardItemModel_in_QML and &quot;QSqlTableModel in QML (forum thread)&quot;:http://forum.qt.io/viewthread/12188
Other useful sources were : "Using_QStandardItemModel_in_QML (wiki page)":http://www.developer.nokia.com/Community/Wiki/Using_QStandardItemModel_in_QML and "QSqlTableModel in QML (forum thread)":http://forum.qt.io/viewthread/12188


The data source for this example was lifted from one of the Sql examples that ships with Qt, &quot;examples\sql\masterdetail&amp;quot;:http://doc.qt.nokia.com/stable/sql-masterdetail-database-h.html
The data source for this example was lifted from one of the Sql examples that ships with Qt, "examples\sql\masterdetail":http://doc.qt.nokia.com/stable/sql-masterdetail-database-h.html


=== Step 1: Create a C++ class that derives from QSqlQueryModel: ===
=== Step 1: Create a C++ class that derives from QSqlQueryModel: ===
Line 25: Line 30:
All the magic happens in the constructor and in the overloaded data() method.
All the magic happens in the constructor and in the overloaded data() method.


<code><br />class ArtistsSqlModel : public QSqlQueryModel<br />{<br /> Q_OBJECT<br />public:<br /> explicit ArtistsSqlModel(QObject '''parent);<br /> void refresh();<br /> QVariant data(const QModelIndex &amp;index, int role) const;<br />signals:<br />public slots:<br />private:<br /> const static char''' COLUMN_NAMES[];<br /> const static char* SQL_SELECT;<br />};<br /></code>
<code>
class ArtistsSqlModel : public QSqlQueryModel
{
Q_OBJECT
public:
explicit ArtistsSqlModel(QObject '''parent);
void refresh();
QVariant data(const QModelIndex &amp;index, int role) const;
signals:
public slots:
private:
const static char''' COLUMN_NAMES[];
const static char* SQL_SELECT;
};
</code>


=== Step 2: Implement two static constants ===
=== Step 2: Implement two static constants ===
Line 31: Line 50:
I always have two constant static variables in each of my models that derive from QSqlQueryModel, COLUMN_NAMES and SQL_SELECT. The order of the column names in COLUMN_NAMES must match the order they are listed in the SELECT statement
I always have two constant static variables in each of my models that derive from QSqlQueryModel, COLUMN_NAMES and SQL_SELECT. The order of the column names in COLUMN_NAMES must match the order they are listed in the SELECT statement


<code>const char* ArtistsSqlModel::COLUMN_NAMES[] = {<br /> &quot;artist&amp;quot;,<br /> &quot;title&amp;quot;,<br /> &quot;year&amp;quot;,<br /> NULL<br />};<br />const char* ArtistsSqlModel::SQL_SELECT =<br />&quot;SELECT artists.artist, albums.title, albums.year&amp;quot;<br />&quot; FROM albums&amp;quot;<br />&quot; JOIN artists ON albums.artistid = artists.id&amp;quot;;<br /></code>
<code>const char* ArtistsSqlModel::COLUMN_NAMES[] = {
"artist",
"title",
"year",
NULL
};
const char* ArtistsSqlModel::SQL_SELECT =
"SELECT artists.artist, albums.title, albums.year"
" FROM albums"
" JOIN artists ON albums.artistid = artists.id";
</code>


=== Step 3: Set the roleNames in the constructor ===
=== Step 3: Set the roleNames in the constructor ===
Line 37: Line 66:
This is where all the magic really happens. The QML will reference the different columns by the role names set on the model.
This is where all the magic really happens. The QML will reference the different columns by the role names set on the model.


<code>ArtistsSqlModel::ArtistsSqlModel(QObject *parent) :<br /> QSqlQueryModel(parent)<br />{<br /> int idx = 0;<br /> QHash&amp;lt;int, QByteArray&amp;gt; roleNames;<br /> while( COLUMN_NAMES[idx]) {<br /> roleNames[Qt::UserRole + idx + 1] = COLUMN_NAMES[idx];<br /> idx++;<br /> }<br /> setRoleNames(roleNames);<br /> refresh();<br />}</code>
<code>ArtistsSqlModel::ArtistsSqlModel(QObject *parent) :
QSqlQueryModel(parent)
{
int idx = 0;
QHash<int, QByteArray> roleNames;
while( COLUMN_NAMES[idx]) {
roleNames[Qt::UserRole + idx + 1] = COLUMN_NAMES[idx];
idx++;
}
setRoleNames(roleNames);
refresh();
}</code>


=== Step 4: implement the data() method and the refresh() method: ===
=== Step 4: implement the data() method and the refresh() method: ===
Line 43: Line 83:
As long as the role that is requested is not a user role, return the default. But if the role is a user role, return the correct column:
As long as the role that is requested is not a user role, return the default. But if the role is a user role, return the correct column:


<code>QVariant ArtistsSqlModel::data(const QModelIndex &amp;index, int role) const<br />{<br /> QVariant value = QSqlQueryModel::data(index, role);<br /> if(role &lt; Qt::UserRole)<br /> {<br /> value = QSqlQueryModel::data(index, role);<br /> }<br /> else<br /> {<br /> int columnIdx = role - Qt::UserRole - 1;<br /> QModelIndex modelIndex = this-&gt;index(index.row(), columnIdx);<br /> value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);<br /> }<br /> return value;<br />} </code>
<code>QVariant ArtistsSqlModel::data(const QModelIndex &amp;index, int role) const
{
QVariant value = QSqlQueryModel::data(index, role);
if(role < Qt::UserRole)
{
value = QSqlQueryModel::data(index, role);
}
else
{
int columnIdx = role - Qt::UserRole - 1;
QModelIndex modelIndex = this->index(index.row(), columnIdx);
value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);
}
return value;
} </code>


The refresh() method is the most important, without it, the model won't show anything at all. The best is to stick to the setQuery method from QSqlQueryModel.<br /><code>void ArtistsSqlModel::refresh()<br />{<br /> this-&gt;setQuery(SQL_SELECT);<br />}<br /></code>
The refresh() method is the most important, without it, the model won't show anything at all. The best is to stick to the setQuery method from QSqlQueryModel.
<code>void ArtistsSqlModel::refresh()
{
this->setQuery(SQL_SELECT);
}
</code>


=== Step 5: Allow QML to see the model: ===
=== Step 5: Allow QML to see the model: ===
Line 51: Line 110:
Create an instance of the model (make note that the constructor of the model did query the DB the first time). Then set it as a property on the viewer’s context, in this case I called it artistModel:
Create an instance of the model (make note that the constructor of the model did query the DB the first time). Then set it as a property on the viewer’s context, in this case I called it artistModel:


<code><br /> ArtistsSqlModel *artistsSqlModel = new ArtistsSqlModel( qApp);<br /> QmlApplicationViewer viewer;<br /> viewer.rootContext()<s>&gt;setContextProperty(&quot;artistsModel&amp;quot;, artistsSqlModel);<br /> viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto);<br /> viewer.setMainQmlFile&amp;amp;#40;QLatin1String(&quot;qml/SQLListView/main.qml&amp;quot;&amp;#41;);<br /> viewer.showExpanded();
<code>
<br /></code>
ArtistsSqlModel *artistsSqlModel = new ArtistsSqlModel( qApp);
<br />h3. Step 6: Create the QML list
QmlApplicationViewer viewer;
<br />Since the model was exposed in step 5, the model exists and is ready to be used in QML. Simply set the model of the ListView to the name give in step 5.
viewer.rootContext()->setContextProperty("artistsModel", artistsSqlModel);
<br /><code>import QtQuick 1.1
viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
<br />Rectangle {<br /> width: 500<br /> height: 500<br /> MouseArea {<br /> anchors.fill: parent
viewer.setMainQmlFile(QLatin1String("qml/SQLListView/main.qml"));
<br /> Text {<br /> id: text1<br /> anchors.verticalCenterOffset: 20<br /> anchors.horizontalCenter: parent.horizontalCenter<br /> text: qsTr(&quot;Testing&amp;quot;)<br /> font.pixelSize: 12<br /> }
viewer.showExpanded();
<br /> ListView {<br /> id: list_view1<br /> x: 125<br /> y: 100<br /> width: 110<br /> height: 160<br /> delegate: ArtistItemDelegate {}<br /> model: artistsModel<br /> }<br /> }<br />}
<br /></code>
<br />h3. Step 7: Create the QML delegate used by the list
<br />And finally implementation of the delegate. Notice here how the names set in the roleModel are used as the values to bind to the text property of the Text objects:
<br />'''ArtistItemDelegate.qml'''<br /><code>import QtQuick 1.1
<br />Item {<br /> id: delegate<br /> width: delegate.ListView.view.width;<br /> height: 30<br /> clip: true<br /> anchors.margins: 4
<br /> Row {<br /> anchors.margins: 4<br /> anchors.fill: parent<br /> spacing: 4;
<br /> Text {<br /> text: artist<br /> width: 150<br /> }
<br /> Text {<br /> text: title<br /> width: 300;<br /> }
<br /> Text {<br /> text: year<br /> width: 50;<br /> }<br /> }<br />}</code>


<br />Source code is no longer available on my website, so feel free to contact me for the complete source code, I will be happy to share!
</code>


<br />h2. A more generic approach
h3. Step 6: Create the QML list
<br />Based on the initial wiki article I came up with a more generic approach that allow to use the same class for all your models instead of creating a derived class for each model.
<br />Here it is :
<br />'''sqlquerymodel.h'''<br /><code><br />#include &lt;QSqlQueryModel&amp;gt;
<br />class SqlQueryModel : public QSqlQueryModel<br />{<br /> Q_OBJECT
<br /> void generateRoleNames();
<br />public:<br /> explicit SqlQueryModel(QObject *parent = 0);
<br /> void setQuery(const QString &amp;query, const QSqlDatabase &amp;db = QSqlDatabase());<br /> void setQuery(const QSqlQuery &amp;query);<br /> QVariant data(const QModelIndex &amp;index, int role) const;
<br />signals:
<br />public slots:
<br />};<br /></code>
<br />'''sqlquerymodel.cpp'''<br /><code><br />#include &quot;sqlquerymodel.h&amp;quot;<br />#include &lt;QSqlRecord&amp;gt;<br />#include &lt;QSqlField&amp;gt;<br />#include &lt;QDebug&amp;gt;
<br />SqlQueryModel::SqlQueryModel(QObject *parent) :<br /> QSqlQueryModel(parent)<br />{
<br />}
<br />void SqlQueryModel::setQuery(const QString &amp;query, const QSqlDatabase &amp;db)<br />{<br /> QSqlQueryModel::setQuery(query,db);<br /> generateRoleNames();<br />}
<br />void SqlQueryModel::setQuery(const QSqlQuery &amp; query)<br />{<br /> QSqlQueryModel::setQuery(query);<br /> generateRoleNames();<br />}
<br />void SqlQueryModel::generateRoleNames()<br />{<br /> QHash&amp;lt;int, QByteArray&amp;gt; roleNames;<br /> for( int i = 0; i &lt; record().count(); i+'') {<br /> roleNames[Qt::UserRole'' i + 1] = record().fieldName(i).toAscii();<br /> }<br /> setRoleNames(roleNames);<br />}
<br />QVariant SqlQueryModel::data(const QModelIndex &amp;index, int role) const<br />{<br /> QVariant value = QSqlQueryModel::data(index, role);<br /> if(role &lt; Qt::UserRole)<br /> {<br /> value = QSqlQueryModel::data(index, role);<br /> }<br /> else<br /> {<br /> int columnIdx = role</s> Qt::UserRole - 1;<br /> QModelIndex modelIndex = this-&gt;index(index.row(), columnIdx);<br /> value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);<br /> }<br /> return value;<br />}<br /></code>


And use it like this :<br /><code><br /> SqlQueryModel '''model1 = new SqlQueryModel(0);<br /> model1-&gt;setQuery(&quot;SELECT''' FROM table WHERE column='value'&quot;);<br /> SqlQueryModel '''model2 = new SqlQueryModel(0);<br /> model2-&gt;setQuery(&quot;SELECT''' FROM anothertable WHERE anothercolumn='value'&quot;);<br /> QmlApplicationViewer viewer;<br /> viewer.rootContext()<s>&gt;setContextProperty(&quot;myFirstModel&amp;quot;, model1);<br /> viewer.rootContext()</s>&gt;setContextProperty(&quot;mySecondModel&amp;quot;, model2);
Since the model was exposed in step 5, the model exists and is ready to be used in QML. Simply set the model of the ListView to the name give in step 5.
 
<code>import QtQuick 1.1
 
Rectangle {
width: 500
height: 500
MouseArea {
anchors.fill: parent
 
Text {
id: text1
anchors.verticalCenterOffset: 20
anchors.horizontalCenter: parent.horizontalCenter
text: qsTr("Testing")
font.pixelSize: 12
}
 
ListView {
id: list_view1
x: 125
y: 100
width: 110
height: 160
delegate: ArtistItemDelegate {}
model: artistsModel
}
}
}
 
</code>
 
h3. Step 7: Create the QML delegate used by the list
 
And finally implementation of the delegate. Notice here how the names set in the roleModel are used as the values to bind to the text property of the Text objects:
 
'''ArtistItemDelegate.qml'''
<code>import QtQuick 1.1
 
Item {
id: delegate
width: delegate.ListView.view.width;
height: 30
clip: true
anchors.margins: 4
 
Row {
anchors.margins: 4
anchors.fill: parent
spacing: 4;
 
Text {
text: artist
width: 150
}
 
Text {
text: title
width: 300;
}
 
Text {
text: year
width: 50;
}
}
}</code>
 
 
Source code is no longer available on my website, so feel free to contact me for the complete source code, I will be happy to share!
 
 
h2. A more generic approach
 
Based on the initial wiki article I came up with a more generic approach that allow to use the same class for all your models instead of creating a derived class for each model.
 
Here it is :
 
'''sqlquerymodel.h'''
<code>
#include <QSqlQueryModel>
 
class SqlQueryModel : public QSqlQueryModel
{
Q_OBJECT
 
void generateRoleNames();
 
public:
explicit SqlQueryModel(QObject *parent = 0);
 
void setQuery(const QString &amp;query, const QSqlDatabase &amp;db = QSqlDatabase());
void setQuery(const QSqlQuery &amp;query);
QVariant data(const QModelIndex &amp;index, int role) const;
 
signals:
 
public slots:
 
};
</code>
 
'''sqlquerymodel.cpp'''
<code>
#include "sqlquerymodel.h"
#include <QSqlRecord>
#include <QSqlField>
#include <QDebug>
 
SqlQueryModel::SqlQueryModel(QObject *parent) :
QSqlQueryModel(parent)
{
 
}
 
void SqlQueryModel::setQuery(const QString &amp;query, const QSqlDatabase &amp;db)
{
QSqlQueryModel::setQuery(query,db);
generateRoleNames();
}
 
void SqlQueryModel::setQuery(const QSqlQuery &amp; query)
{
QSqlQueryModel::setQuery(query);
generateRoleNames();
}
 
void SqlQueryModel::generateRoleNames()
{
QHash<int, QByteArray> roleNames;
for( int i = 0; i < record().count(); i+'') {
roleNames[Qt::UserRole'' i + 1] = record().fieldName(i).toAscii();
}
setRoleNames(roleNames);
}
 
QVariant SqlQueryModel::data(const QModelIndex &amp;index, int role) const
{
QVariant value = QSqlQueryModel::data(index, role);
if(role < Qt::UserRole)
{
value = QSqlQueryModel::data(index, role);
}
else
{
int columnIdx = role- Qt::UserRole - 1;
QModelIndex modelIndex = this->index(index.row(), columnIdx);
value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);
}
return value;
}
</code>
 
And use it like this :
<code>
SqlQueryModel '''model1 = new SqlQueryModel(0);
model1->setQuery("SELECT''' FROM table WHERE column='value'");
SqlQueryModel '''model2 = new SqlQueryModel(0);
model2->setQuery("SELECT''' FROM anothertable WHERE anothercolumn='value'");
QmlApplicationViewer viewer;
viewer.rootContext()->setContextProperty("myFirstModel", model1);
viewer.rootContext()->setContextProperty("mySecondModel", model2);

Revision as of 08:51, 25 February 2015


English Spanish Italian

[toc depth="3" align_right="no"]

How to use a QSqlQueryModel in QML

Initial fully detailed approach

Introduction

The software I develop, Photo Parata, is a client server application that uses a sql backend. Most of the time the data Photo Parata displays requires some joins. Because of this, most of the time the models are derived from QSqlQueryModel, not QSqlTableModel. For QSqlRelationalTableModel, you can find an working but unexplained example at http://wiki.qt.io/QML_and_QSqlTableModel

In this how to, I will walk you through the steps of setting up a custom model for QML, derived from QSqlQueryModel.

I would like to thank "Christophe Dumez":http://cdumez.blogspot.com/ for his blog "How to use C++ list model in QML":http://cdumez.blogspot.com/2010/11/how-to-use-c-list-model-in-qml.html. It was this blog that allowed me to piece the following together.

Other useful sources were : "Using_QStandardItemModel_in_QML (wiki page)":http://www.developer.nokia.com/Community/Wiki/Using_QStandardItemModel_in_QML and "QSqlTableModel in QML (forum thread)":http://forum.qt.io/viewthread/12188

The data source for this example was lifted from one of the Sql examples that ships with Qt, "examples\sql\masterdetail":http://doc.qt.nokia.com/stable/sql-masterdetail-database-h.html

Step 1: Create a C++ class that derives from QSqlQueryModel:

All the magic happens in the constructor and in the overloaded data() method.

class ArtistsSqlModel : public QSqlQueryModel
{
 Q_OBJECT
public:
 explicit ArtistsSqlModel(QObject '''parent);
 void refresh();
 QVariant data(const QModelIndex &amp;index, int role) const;
signals:
public slots:
private:
 const static char''' COLUMN_NAMES[];
 const static char* SQL_SELECT;
};

Step 2: Implement two static constants

I always have two constant static variables in each of my models that derive from QSqlQueryModel, COLUMN_NAMES and SQL_SELECT. The order of the column names in COLUMN_NAMES must match the order they are listed in the SELECT statement

const char* ArtistsSqlModel::COLUMN_NAMES[] = {
 "artist",
 "title",
 "year",
 NULL
};
const char* ArtistsSqlModel::SQL_SELECT =
"SELECT artists.artist, albums.title, albums.year"
" FROM albums"
" JOIN artists ON albums.artistid = artists.id";

Step 3: Set the roleNames in the constructor

This is where all the magic really happens. The QML will reference the different columns by the role names set on the model.

ArtistsSqlModel::ArtistsSqlModel(QObject *parent) :
 QSqlQueryModel(parent)
{
 int idx = 0;
 QHash<int, QByteArray> roleNames;
 while( COLUMN_NAMES[idx]) {
 roleNames[Qt::UserRole + idx + 1] = COLUMN_NAMES[idx];
 idx++;
 }
 setRoleNames(roleNames);
 refresh();
}

Step 4: implement the data() method and the refresh() method:

As long as the role that is requested is not a user role, return the default. But if the role is a user role, return the correct column:

QVariant ArtistsSqlModel::data(const QModelIndex &amp;index, int role) const
{
 QVariant value = QSqlQueryModel::data(index, role);
 if(role < Qt::UserRole)
 {
 value = QSqlQueryModel::data(index, role);
 }
 else
 {
 int columnIdx = role - Qt::UserRole - 1;
 QModelIndex modelIndex = this->index(index.row(), columnIdx);
 value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);
 }
 return value;
}

The refresh() method is the most important, without it, the model won't show anything at all. The best is to stick to the setQuery method from QSqlQueryModel.

void ArtistsSqlModel::refresh()
{
 this->setQuery(SQL_SELECT);
}

Step 5: Allow QML to see the model:

Create an instance of the model (make note that the constructor of the model did query the DB the first time). Then set it as a property on the viewer’s context, in this case I called it artistModel:

 ArtistsSqlModel *artistsSqlModel = new ArtistsSqlModel( qApp);
 QmlApplicationViewer viewer;
 viewer.rootContext()->setContextProperty("artistsModel", artistsSqlModel);
 viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
 viewer.setMainQmlFile(QLatin1String("qml/SQLListView/main.qml"));
 viewer.showExpanded();

h3. Step 6: Create the QML list

Since the model was exposed in step 5, the model exists and is ready to be used in QML. Simply set the model of the ListView to the name give in step 5.

import QtQuick 1.1

Rectangle {
 width: 500
 height: 500
 MouseArea {
 anchors.fill: parent

 Text {
 id: text1
 anchors.verticalCenterOffset: 20
 anchors.horizontalCenter: parent.horizontalCenter
 text: qsTr("Testing")
 font.pixelSize: 12
 }

 ListView {
 id: list_view1
 x: 125
 y: 100
 width: 110
 height: 160
 delegate: ArtistItemDelegate {}
 model: artistsModel
 }
 }
}

h3. Step 7: Create the QML delegate used by the list

And finally implementation of the delegate. Notice here how the names set in the roleModel are used as the values to bind to the text property of the Text objects:

ArtistItemDelegate.qml

import QtQuick 1.1

Item {
 id: delegate
 width: delegate.ListView.view.width;
 height: 30
 clip: true
 anchors.margins: 4

 Row {
 anchors.margins: 4
 anchors.fill: parent
 spacing: 4;

 Text {
 text: artist
 width: 150
 }

 Text {
 text: title
 width: 300;
 }

 Text {
 text: year
 width: 50;
 }
 }
}


Source code is no longer available on my website, so feel free to contact me for the complete source code, I will be happy to share!


h2. A more generic approach

Based on the initial wiki article I came up with a more generic approach that allow to use the same class for all your models instead of creating a derived class for each model.

Here it is :

sqlquerymodel.h

#include <QSqlQueryModel>

class SqlQueryModel : public QSqlQueryModel
{
 Q_OBJECT

 void generateRoleNames();

public:
 explicit SqlQueryModel(QObject *parent = 0);

 void setQuery(const QString &amp;query, const QSqlDatabase &amp;db = QSqlDatabase());
 void setQuery(const QSqlQuery &amp;query);
 QVariant data(const QModelIndex &amp;index, int role) const;

signals:

public slots:

};

sqlquerymodel.cpp

#include "sqlquerymodel.h"
#include <QSqlRecord>
#include <QSqlField>
#include <QDebug>

SqlQueryModel::SqlQueryModel(QObject *parent) :
 QSqlQueryModel(parent)
{ 

}

void SqlQueryModel::setQuery(const QString &amp;query, const QSqlDatabase &amp;db)
{
 QSqlQueryModel::setQuery(query,db);
 generateRoleNames();
}

void SqlQueryModel::setQuery(const QSqlQuery &amp; query)
{
 QSqlQueryModel::setQuery(query);
 generateRoleNames();
}

void SqlQueryModel::generateRoleNames()
{
 QHash<int, QByteArray> roleNames;
 for( int i = 0; i < record().count(); i+'') {
 roleNames[Qt::UserRole'' i + 1] = record().fieldName(i).toAscii();
 }
 setRoleNames(roleNames);
}

QVariant SqlQueryModel::data(const QModelIndex &amp;index, int role) const
{
 QVariant value = QSqlQueryModel::data(index, role);
 if(role < Qt::UserRole)
 {
 value = QSqlQueryModel::data(index, role);
 }
 else
 {
 int columnIdx = role- Qt::UserRole - 1;
 QModelIndex modelIndex = this->index(index.row(), columnIdx);
 value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);
 }
 return value;
}

And use it like this :

SqlQueryModel model1 = new SqlQueryModel(0);
model1->setQuery("SELECT FROM table WHERE column='value'");
SqlQueryModel model2 = new SqlQueryModel(0);
model2->setQuery("SELECT FROM anothertable WHERE anothercolumn='value'");
QmlApplicationViewer viewer;
viewer.rootContext()->setContextProperty("myFirstModel", model1);
viewer.rootContext()->setContextProperty("mySecondModel", model2);