En esta página

Tabla SQL en caché

El ejemplo «Tabla en caché» muestra cómo se puede utilizar una vista de tabla para acceder a una base de datos, almacenando en caché cualquier cambio en los datos hasta que el usuario los envíe explícitamente mediante un botón.

El usuario actualiza una celda de la tabla y pulsa el botón «Enviar» para aplicar el cambio en la base de datos.

El ejemplo consta de una única clase, ` TableEditor`, que es un control de diálogo personalizado que permite al usuario modificar los datos almacenados en una base de datos. En primer lugar, repasaremos la definición de la clase y cómo utilizarla; a continuación, analizaremos su implementación.

Definición de la clase `TableEditor`

La clase ` TableEditor ` hereda de ` QWidget `, lo que convierte al control de edición de tabla en una ventana de diálogo de nivel superior.

class TableEditor : public QWidget
{
    Q_OBJECT

public:
    explicit TableEditor(const QString &tableName, QWidget *parent = nullptr);

private slots:
    void submit();

private:
    QPushButton *submitButton;
    QPushButton *revertButton;
    QPushButton *quitButton;
    QDialogButtonBox *buttonBox;
    QSqlTableModel *model;
};

El constructor de ` TableEditor ` toma dos argumentos: el primero es una referencia a la tabla de la base de datos sobre la que operará el objeto ` TableEditor `. El otro es un puntero al widget padre y se pasa al constructor de la clase base.

Fíjate en la declaración de la variable ` QSqlTableModel `: como veremos en este ejemplo, la clase ` QSqlTableModel ` se puede utilizar para proporcionar datos a clases de visualización como ` QTableView`. La clase ` QSqlTableModel ` proporciona un modelo de datos editable que permite leer y escribir registros de la base de datos desde una única tabla. Se basa en la clase de nivel inferior ` QSqlQuery `, que proporciona los medios para ejecutar y manipular sentencias SQL.

También vamos a mostrar cómo se puede utilizar una vista de tabla para almacenar en caché cualquier cambio en los datos hasta que el usuario solicite explícitamente enviarlos. Por ese motivo, necesitamos declarar un campo « submit() » además del modelo y los botones del editor.

Conexión a una base de datos
Antes de poder utilizar la clase ` TableEditor `, debemos establecer una conexión con la base de datos que contiene la tabla que queremos editar:
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    if (!createConnection())
        return 1;

    TableEditor editor("person");
    editor.show();
    return app.exec();
}

La función ` createConnection() ` es una función auxiliar proporcionada para mayor comodidad. Está definida en el archivo ` connection.h `, que se encuentra en el directorio de ejemplos ` sql ` (todos los ejemplos del directorio ` sql ` utilizan esta función para conectarse a una base de datos).

static bool createConnection()
{
    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
    db.setDatabaseName(":memory:");
    if (!db.open()) {
        QMessageBox::critical(nullptr, QObject::tr("Cannot open database"),
            QObject::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."), QMessageBox::Cancel);
        return false;
    }

    QSqlQuery query;
    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')");

    query.exec("create table items (id int primary key,"
                                             "imagefile int,"
                                             "itemtype varchar(20),"
                                             "description varchar(100))");
    query.exec("insert into items "
               "values(0, 0, 'Qt',"
               "'Qt is a full development framework with tools designed to "
               "streamline the creation of stunning applications and  "
               "amazing user interfaces for desktop, embedded and mobile "
               "platforms.')");
    query.exec("insert into items "
               "values(1, 1, 'Qt Quick',"
               "'Qt Quick is a collection of techniques designed to help "
               "developers create intuitive, modern-looking, and fluid "
               "user interfaces using a CSS & JavaScript like language.')");
    query.exec("insert into items "
               "values(2, 2, 'Qt Creator',"
               "'Qt Creator is a powerful cross-platform integrated "
               "development environment (IDE), including UI design tools "
               "and on-device debugging.')");
    query.exec("insert into items "
               "values(3, 3, 'Qt Project',"
               "'The Qt Project governs the open source development of Qt, "
               "allowing anyone wanting to contribute to join the effort "
               "through a meritocratic structure of approvers and "
               "maintainers.')");

    query.exec("create table images (itemid int, file varchar(20))");
    query.exec("insert into images values(0, 'images/qt-logo.png')");
    query.exec("insert into images values(1, 'images/qt-quick.png')");
    query.exec("insert into images values(2, 'images/qt-creator.png')");
    query.exec("insert into images values(3, 'images/qt-project.png')");

    return true;
}

La función createConnection abre una conexión con una base de datos SQLITE en memoria y crea una tabla de prueba. Si deseas utilizar otra base de datos, solo tienes que modificar el código de esta función.

Implementación de la clase TableEditor

La implementación de la clase consta únicamente de dos funciones: el constructor y la ranura « submit() ». En el constructor creamos y personalizamos el modelo de datos y los distintos elementos de la ventana:

TableEditor::TableEditor(const QString &tableName, QWidget *parent)
    : QWidget(parent)
{
    model = new QSqlTableModel(this);
    model->setTable(tableName);
    model->setEditStrategy(QSqlTableModel::OnManualSubmit);
    model->select();

    model->setHeaderData(0, Qt::Horizontal, tr("ID"));
    model->setHeaderData(1, Qt::Horizontal, tr("First name"));
    model->setHeaderData(2, Qt::Horizontal, tr("Last name"));

En primer lugar, creamos el modelo de datos y establecemos la tabla de la base de datos SQL sobre la que queremos que opere el modelo. Ten en cuenta que la función ` QSqlTableModel::setTable()` no selecciona datos de la tabla; solo recupera la información de sus campos. Por ese motivo, llamamos posteriormente a la función ` QSqlTableModel::select()`, que rellena el modelo con datos de la tabla. La selección se puede personalizar especificando filtros y condiciones de ordenación (consulta la documentación de la clase ` QSqlTableModel ` para obtener más detalles).

También configuramos la estrategia de edición del modelo. La estrategia de edición determina cuándo se aplican realmente a la base de datos los cambios realizados por el usuario en la vista. Dado que queremos almacenar en caché los cambios en la vista de la tabla (es decir, en el modelo) hasta que el usuario los envíe explícitamente, elegimos la estrategia QSqlTableModel::OnManualSubmit. Las alternativas son QSqlTableModel::OnFieldChange y QSqlTableModel::OnRowChange.

Por último, configuramos las etiquetas que se muestran en el encabezado de la vista utilizando la función ` setHeaderData()` que el modelo hereda de la clase ` QSqlQueryModel `.

    QTableView *view = new QTableView;
    view->setModel(model);
    view->resizeColumnsToContents();

A continuación, creamos una vista de tabla. La clase ` QTableView ` proporciona una implementación predeterminada de modelo/vista para una vista de tabla, es decir, implementa una vista de tabla que muestra elementos de un modelo. También permite al usuario editar los elementos, almacenando los cambios en el modelo. Para crear una vista de solo lectura, se debe establecer el indicador adecuado mediante la propiedad ` editTriggers `, que la vista hereda de la clase ` QAbstractItemView `.

Para que la vista muestre nuestros datos, pasamos nuestro modelo a la vista mediante la función ` setModel()`.

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

    buttonBox = new QDialogButtonBox(Qt::Vertical);
    buttonBox->addButton(submitButton, QDialogButtonBox::ActionRole);
    buttonBox->addButton(revertButton, QDialogButtonBox::ActionRole);
    buttonBox->addButton(quitButton, QDialogButtonBox::RejectRole);

Los botones de TableEditor son objetos QPushButton normales. Los añadimos a un cuadro de botones para garantizar que se muestren con un diseño adecuado al estilo actual del widget. La razón es que los cuadros de diálogo y los cuadros de mensaje suelen presentar los botones con un diseño que se ajusta a las directrices de interfaz de esa plataforma. Inevitablemente, las distintas plataformas tienen diseños diferentes para sus cuadros de diálogo. « QDialogButtonBox » permite al desarrollador añadirle botones y utilizará automáticamente el diseño adecuado para el entorno de escritorio del usuario.

La mayoría de los botones de un cuadro de diálogo cumplen determinadas funciones. Al añadir un botón a un cuadro de botones mediante la función ` addButton() `, se debe especificar la función del botón utilizando la enumeración ` QDialogButtonBox::ButtonRole `. Como alternativa, ` QDialogButtonBox ` proporciona varios botones estándar (por ejemplo, ` OK`, ` Cancel`, ` Save`) que puedes utilizar. Estos existen como indicadores, por lo que puedes combinarlos mediante la operación OR en el constructor.

    connect(submitButton, &QPushButton::clicked, this, &TableEditor::submit);
    connect(revertButton, &QPushButton::clicked,  model, &QSqlTableModel::revertAll);
    connect(quitButton, &QPushButton::clicked, this, &TableEditor::close);

Conectamos el botón « Quit » a la ranura « close()» del editor de tablas, y el botón « Submit » a nuestra ranura privada « submit() ». Esta última ranura se encargará de las transacciones de datos. Por último, conectamos el botón « Revert » a la ranura « revertAll()» de nuestro modelo, lo que revierte todos los cambios pendientes (es decir, restaura los datos originales).

    QHBoxLayout *mainLayout = new QHBoxLayout;
    mainLayout->addWidget(view);
    mainLayout->addWidget(buttonBox);
    setLayout(mainLayout);

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

Al final, añadimos el cuadro del botón y la vista de tabla a un diseño, instalamos el diseño en el widget del editor de tablas y configuramos el título de la ventana del editor.

void TableEditor::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: %1")
                             .arg(model->lastError().text()));
    }
}

La ranura submit() se invoca cada vez que los usuarios pulsan el botón « Submit » para guardar sus cambios.

En primer lugar, iniciamos una transacción en la base de datos mediante la función QSqlDatabase::transaction(). Una transacción de base de datos es una unidad de interacción con un sistema de gestión de bases de datos o similar que se trata de forma coherente y fiable, independientemente de otras transacciones. Se puede obtener un puntero a la base de datos utilizada mediante la función QSqlTableModel::database().

A continuación, intentamos enviar todos los cambios pendientes, es decir, los elementos modificados del modelo. Si no se produce ningún error, confirmamos la transacción en la base de datos mediante la función ` QSqlDatabase::commit()` (tenga en cuenta que, en algunas bases de datos, esta función no funcionará si hay una transacción ` QSqlQuery ` activa en la base de datos). De lo contrario, revertimos la transacción mediante la función ` QSqlDatabase::rollback()` y mostramos una advertencia al usuario.

Véase también:

Una lista completa de las clases de bases de datos SQL de Qt y la documentación sobre programación de modelos y vistas.

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.