# Cached Table Example

The Cached Table example shows how a table view can be used to access a database, caching any changes to the data until the user explicitly submits them using a push button.

The example consists of a single class, `TableEditor`, which is a custom dialog widget that allows the user to modify data stored in a database. We will first review the class definiton and how to use the class, then we will take a look at the implementation.

## CachedTable Class Implementation

The `CachedTable` class inherits QDialog making the table editor widget a top-level dialog window.

        public class CachedTable extends QDialog {
            private QPushButton submitButton = null;
            private QPushButton revertButton = null;
            private QPushButton quitButton = null;
            private QSqlTableModel model = null;

Note the QSqlTableModel variable declaration: As we will see in this example, the QSqlTableModel class can be used to provide data to view classes such as QTableView. The QSqlTableModel class provides an editable data model making it possible to read and write database records from a single table. It is build on top of the lower-level QSqlQuery class which provides means of executing and manipulating SQL statements.

We define a static method to check for suitable database support:

            public static boolean checkSqlLite() {
                return QSqlDatabase.isDriverAvailable("QSQLITE");
            }

We are also going to show how a table view can be used to cache any changes to the data until the user explicitly requests to submit them. For that reason we need to declare a `submit()` slot in additon to the model and the editor's buttons.

Connecting to a Database
Before we can use the `CachedTable` class, we must create a connection to the database containing the table we want to edit. We do this by defining a `SqlCommon` class containing a method that performs this task:
        class SqlCommon
        {
            static boolean createConnection()
            {
                QSqlDatabase db = QSqlDatabase.addDatabase("QSQLITE", "qt_sql_default_connection");
                db.setDatabaseName(":memory:");
                if (!db.open()) {
                    QMessageBox.critical(null, QApplication.instance().tr("Cannot open database"),
                        QApplication.instance().tr("Unable to establish a database connection.\n" +
                                 "This example needs SQLite support. Please read " +
                                 "the Qt SQL driver documentation for information how " +
                                 "to build it.\n\n" +
                                 "Click Cancel to exit."),
                                 new QMessageBox.StandardButtons(QMessageBox.StandardButton.Cancel,
                                                                 QMessageBox.StandardButton.NoButton));
                    return false;
                }

                QSqlQuery query = new QSqlQuery();
                query.exec("create table person (id int primary key, " +
                           "firstname varchar(20), lastname varchar(20))");
                query.exec("insert into person values(101, 'Danny', 'Young')");
                query.exec("insert into person values(102, 'Christine', 'Holand')");
                query.exec("insert into person values(103, 'Lars', 'Gordon')");
                query.exec("insert into person values(104, 'Roberto', 'Robitaille')");
                query.exec("insert into person values(105, 'Maria', 'Papadopoulos')");

                return true;

            }
        }
The `createConnection()` method is a helper method provided for convenience. It opens a connection to an in-memory SQLITE database and creates a test table. If you want to use another database, simply modify this function's code.

Apart from the static `checkSqlLite()` method, the class implementation consists of only the constructor and the `submit()` slot. In the constructor we create and customize the data model and the various window elements:

            public CachedTable(QWidget parent)
            {
                super(parent);

                if (!SqlCommon.createConnection())
                    throw new RuntimeException("Couldn't connect to SQLITE server");

First we create the data model and set the SQL database table we want the model to operate on. Note that the QSqlTableModel::setTable() function does not select data from the table; it only fetches its field information. For that reason we call the QSqlTableModel::select() function later on, populating the model with data from the table. The selection can be customized by specifying filters and sort conditions (see the QSqlTableModel class documentation for more details).

                model = new QSqlTableModel(this);
                model.setTable(tableName);
                model.setEditStrategy(QSqlTableModel.EditStrategy.OnManualSubmit);
                model.select();

                model.setHeaderData(0, Qt.Orientation.Horizontal, tr("ID"));
                model.setHeaderData(1, Qt.Orientation.Horizontal, tr("First name"));
                model.setHeaderData(2, Qt.Orientation.Horizontal, tr("Last name"));

We also set the model's edit strategy: The edit strategy dictates when the changes done by the user in the view are actually applied to the database. Since we want to cache the changes in the table view (i.e. in the model) until the user explicitly submits them, we choose the QSqlTableModel::OnManualSubmit strategy. The alternatives are QSqlTableModel::OnFieldChange and QSqlTableModel::OnRowChange.

Finally, we set up the labels displayed in the view header using the setHeaderData() function the model inherits from the QSqlQueryModel class.

                QTableView view = new QTableView();
                view.setModel(model);

Then we create a table view. The QTableView class provides a default model/view implementation of a table view, i.e. it implements a table view that displays items from a model. It also allows the user to edit the items, storing the changes in the model. To create a read only view, set the proper flag using the editTriggers property the view inherits from the QAbstractItemView class.

We pass our model to the view, using the setModel() function, to make the view present our data.

                submitButton = new QPushButton(tr("Submit"));
                submitButton.setDefault(true);
                revertButton = new QPushButton(tr("&Revert"));
                quitButton = new QPushButton(tr("Quit"));

                submitButton.clicked.connect(this, "submit()");
                revertButton.clicked.connect(model, "revertAll()");
                quitButton.clicked.connect(this, "close()");

The `TableEditor`'s buttons are regular QPushButton objects. We connect the Quit button to the table editor's close() slot, and the Submit button to our private `submit()` slot. The latter slot will take care of the data transactions. Finally, we connect the Revert button to our model's revertAll() slot, reverting all pending changes (restoring the original data).

                QVBoxLayout buttonLayout = new QVBoxLayout();
                buttonLayout.addWidget(submitButton);
                buttonLayout.addWidget(revertButton);
                buttonLayout.addWidget(quitButton);
                buttonLayout.addStretch(1);

                QHBoxLayout mainLayout = new QHBoxLayout();
                mainLayout.addWidget(view);
                mainLayout.addLayout(buttonLayout);
                setLayout(mainLayout);

                setWindowTitle(tr("Cached Table"));
            }

In the end we add all the buttons and the table view to a layout, install the layout on the table editor widget, and set the editor's window title.

            protected void submit()
            {
                model.database().transaction();
                if (model.submitAll()) {
                    model.database().commit();
                } else {
                    model.database().rollback();
                    QMessageBox.warning(this, tr("Cached Table"),
                                        tr("The database reported an error: ") + model.lastError().text());
                }
            }

The `submit()` slot is called whenever the users hit the Submit button to save their changes.

First, we begin a transaction on the database using the QSqlDatabase::transaction() function. A database transaction is a unit of interaction with a database management system or similar system that is treated in a coherent and reliable way independent of other transactions. A pointer to the used database can be obtained using the QSqlTableModel::database() function.

Then, we try to submit all the pending changes, i.e. the model's modified items. If no error occurs, we commit the transaction to the database using the QSqlDatabase::commit() function (note that on some databases, this function will not work if there is an active QSqlQuery on the database). Otherwise we perform a rollback of the transaction using the QSqlDatabase::rollback() function and post a warning to the user.

See also: A complete list of Qt's SQL Database Classes, and the Model/View Programming documentation.