database, QSqlTableModel, QSqlTableModel example, qt, qt таблицы, sql, sqlite

Um die in einer Datenbanktabelle enthaltenen Informationen darzustellen, verwendet das Qt-Framework mehrere Klassen:

• QSqlQueryModel - ein Modell, das eine Tabelle durch Angabe einer rohen SQL-Abfrage bildet. Es kann nützlich sein, wenn Sie besonders anspruchsvolle Filter erstellen und Informationen aus verschiedenen Datenbanktabellen zusammenstellen. Mehr dazu in den folgenden Lektionen.
• QSqlTableModel - das Thema unseres Gesprächs in diesem Artikel. Ein Modell, das eine Tabelle mit dem Namen der Tabelle bildet, die in der Datenbank vorhanden ist. Von den Minuspunkten können wir das Fehlen von Methoden zum Verbinden von Links mit anderen Tabellen feststellen, um Werte in Feldern aus anderen Tabellen nach ID zu ersetzen.
• QSqlRelationalTableModel - eine Klasse, die es Ihnen ermöglicht, eine Tabelle mit Links aus anderen Tabellen zu bilden und die Werte der Tabelle, die dieses Modell darstellt, gemäß den IDs der in anderen Tabellen enthaltenen Datensätze zu ersetzen.

Für komfortables Arbeiten mit Informationen, die in die Datenbank gestellt werden, wird eine zusätzliche Klasse verwendet, die teilweise ein Gestaltungsmuster "Fassade" ist.

Der Programmcode wurde in QtCreator 3.3.1 basierend auf Qt 5.4.1 geschrieben.

Projektstruktur für QSqlTableModel

Das Projekt wird als Qt-Widgets-Anwendung erstellt, in der die folgenden Dateien erstellt werden:

• DataBase.pro - Profil;
• mainwindow.h - Header-Datei des Hauptanwendungsfensters;
• mainwindow.cpp - Fensterquellcode;
• main.cpp - die Hauptquelldatei, von der aus die Anwendung startet;
• mainwindow.ui - Form des Hauptanwendungsfensters;
• database.h - Header-Datei der Hilfsklasse, die verwendet wird, um mit Informationen zu arbeiten, die in der Datenbank platziert sind;
• database.cpp - die Quelldatei der Hilfsklasse, die verwendet wird, um mit Informationen zu arbeiten, die in der Datenbank platziert sind;

Notiz. Ich erstelle den größten Teil der Benutzeroberfläche im Designer, um die Logik des Hauptcodes nicht mit unnötigen Informationen zu überladen. Tatsächlich ist dies nur eine Frage des Geschmacks und der Gewohnheit.

mainwindow.ui

Formular für QSqlTableModel Erstellen Sie ein Formular für die Testanwendung, das ein QTableView Objekt namens tableView von der GUI verwendet.

DataBase.pro

Dem Projektprofil muss eine Direktive hinzugefügt werden, die die Verwendung von SQL-Bibliotheken deklariert.

#-------------------------------------------------
#
# Project created by QtCreator 2015-08-10T16:08:24
#
#-------------------------------------------------

QT       += core
QT       += gui
QT       += sql

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = DataBase
TEMPLATE = app


SOURCES += main.cpp\
        mainwindow.cpp \
    database.cpp

HEADERS  += mainwindow.h \
    database.h

FORMS    += mainwindow.ui

main.cpp

Die Datei wird im Projekt verwendet und wird standardmäßig erstellt.

#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

mainwindow.h

Diese Header-Datei enthält die Deklaration des QSqlTableModel und DataBase Objekts, einer Hilfsklasse, die verwendet wird, um mit Informationen zu arbeiten, die in der Datenbank platziert werden. Darüber hinaus werden Methoden zur Initialisierung des Erscheinungsbilds und des Modells QSqlTableModel unserer Anwendung deklariert.

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QSqlTableModel>
/* Подключаем заголовочный файл для работы с информацией, которая помещена в базу данных */
#include "database.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow  *ui;
    /* В проекте используются объекты для взаимодействия с информацией в базе данных
     * и моделью представления таблицы базы данных
     * */
    DataBase        *db;
    QSqlTableModel  *model;

private:
    /* Также присутствуют два метода, которые формируют модель
     * и внешний вид TableView
     * */
    void setupModel(const QString &tableName, const QStringList &headers);
    void createUI();
};

#endif // MAINWINDOW_H

mainwindow.cpp

Die Quelldatei, in der alle Hauptaktionen für die Interaktion mit dem Datenpräsentationsmodell stattfinden.

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    /* Первым делом необходимо создать объект, который будет использоваться для работы с данными нашей БД
     * и инициализировать подключение к базе данных
     * */
    db = new DataBase();
    db->connectToDataBase();

    /* После чего производим наполнение таблицы базы данных
     * контентом, который будет отображаться в TableView
     * */
    for(int i = 0; i < 4; i++){
        QVariantList data;
        int random = qrand(); // Получаем случайные целые числа для вставки а базу данных
        data.append(QDate::currentDate()); // Получаем текущую дату для вставки в БД
        data.append(QTime::currentTime()); // Получаем текущее время для вставки в БД
        // Подготавливаем полученное случайное число для вставки в БД
        data.append(random);           
        // Подготавливаем сообщение для вставки в базу данных
        data.append("Получено сообщение от " + QString::number(random)); 
        // Вставляем данные в БД
        db->inserIntoTable(data);
    }

    /* Инициализируем модель для представления данных
     * с заданием названий колонок
     * */
    this->setupModel(TABLE,
                     QStringList() << trUtf8("id")
                                   << trUtf8("Дата")
                                   << trUtf8("Время")
                                   << trUtf8("Рандомное число")
                                   << trUtf8("Сообщение")
               );

    /* Инициализируем внешний вид таблицы с данными
     * */
    this->createUI();
}

MainWindow::~MainWindow()
{
    delete ui;
}

/* Метод для инициализации модеи представления данных
 * */
void MainWindow::setupModel(const QString &tableName, const QStringList &headers)
{
    /* Производим инициализацию модели представления данных
     * с установкой имени таблицы в базе данных, по которому
     * будет производится обращение в таблице
     * */
    model = new QSqlTableModel(this);
    model->setTable(tableName);

    /* Устанавливаем названия колонок в таблице с сортировкой данных
     * */
    for(int i = 0, j = 0; i < model->columnCount(); i++, j++){
        model->setHeaderData(i,Qt::Horizontal,headers[j]);
    }
    // Устанавливаем сортировку по возрастанию данных по нулевой колонке
    model->setSort(0,Qt::AscendingOrder);
}

void MainWindow::createUI()
{
    ui->tableView->setModel(model);     // Устанавливаем модель на TableView
    ui->tableView->setColumnHidden(0, true);    // Скрываем колонку с id записей
    // Разрешаем выделение строк
    ui->tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
    // Устанавливаем режим выделения лишь одно строки в таблице
    ui->tableView->setSelectionMode(QAbstractItemView::SingleSelection);
    // Устанавливаем размер колонок по содержимому
    ui->tableView->resizeColumnsToContents();
    ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableView->horizontalHeader()->setStretchLastSection(true);

    model->select(); // Делаем выборку данных из таблицы
}

database.h

Um die Frage der Interaktion mit der Datenbank nicht im Dunkeln zu lassen, versorge ich Listings dieser Klasse auch mit Kommentaren. Die Arbeit wird mit der SQLite-Datenbank erledigt, aber das Prinzip der Arbeit mit Netzwerkdatenbanken ist dasselbe, mit Ausnahme der Netzwerkverbindung und der Nuancen der Arbeit mit jeder spezifischen Datenbank.

In der Header-Datei der DataBase -Klasse ist es für die weitere Arbeit erforderlich, Direktiven für die Namen der Tabelle und der Tabellenspalten anzugeben. Und auch die Methoden, die verwendet werden, um mit der Datenbank zu interagieren, sowie Schnittstellen für diese Interaktion mit übergeordneten Schichten der Anwendung bereitzustellen.

#ifndef DATABASE_H
#define DATABASE_H

#include <QObject>
#include <QSql>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlDatabase>
#include <QFile>
#include <QDate>
#include <QDebug>

/* Директивы имен таблицы, полей таблицы и базы данных */
#define DATABASE_HOSTNAME   "ExampleDataBase"
#define DATABASE_NAME       "DataBase.db"

#define TABLE                   "TableExample"
#define TABLE_DATE              "Date"
#define TABLE_TIME              "Time"
#define TABLE_MESSAGE           "Message"
#define TABLE_RANDOM            "Random"

class DataBase : public QObject
{
    Q_OBJECT
public:
    explicit DataBase(QObject *parent = 0);
    ~DataBase();
    /* Методы для непосредственной работы с классом
     * Подключение к базе данных и вставка записей в таблицу
     * */
    void connectToDataBase();
    bool inserIntoTable(const QVariantList &data);

private:
    // Сам объект базы данных, с которым будет производиться работа
    QSqlDatabase    db;

private:
    /* Внутренние методы для работы с базой данных
     * */
    bool openDataBase();
    bool restoreDataBase();
    void closeDataBase();
    bool createTable();
};

#endif // DATABASE_H

datenbank.cpp

Die Quelldatei für eine Hilfsklasse, die verwendet wird, um mit Informationen zu arbeiten, die in der Datenbank platziert werden. In diesem Fall wird die Bildung von SQL-Abfragen in dieser Klasse maximal ausgeblendet, um die Anzahl der Verknüpfungen im Programmcode zu reduzieren. Eine solche Praxis am Anfang kann einem Anfänger helfen, sofort Code zu schreiben, in dem verschiedene Klassen so weit wie möglich voneinander isoliert sind, was einer der Aspekte von OOP ist.

#include "database.h"

DataBase::DataBase(QObject *parent) : QObject(parent)
{

}

DataBase::~DataBase()
{

}

/* Методы для подключения к базе данных
 * */
void DataBase::connectToDataBase()
{
    /* Перед подключением к базе данных производим проверку на её существование.
     * В зависимости от результата производим открытие базы данных или её восстановление
     * */
    if(!QFile("C:/example/" DATABASE_NAME).exists()){
        this->restoreDataBase();
    } else {
        this->openDataBase();
    }
}

/* Методы восстановления базы данных
 * */
bool DataBase::restoreDataBase()
{
    if(this->openDataBase()){
        if(!this->createTable()){
            return false;
        } else {
            return true;
        }
    } else {
        qDebug() << "Не удалось восстановить базу данных";
        return false;
    }
    return false;
}

/* Метод для открытия базы данных
 * */
bool DataBase::openDataBase()
{
    /* База данных открывается по заданному пути
     * и имени базы данных, если она существует
     * */
    db = QSqlDatabase::addDatabase("QSQLITE");
    db.setHostName(DATABASE_HOSTNAME);
    db.setDatabaseName("C:/example/" DATABASE_NAME);
    if(db.open()){
        return true;
    } else {
        return false;
    }
}

/* Методы закрытия базы данных
 * */
void DataBase::closeDataBase()
{
    db.close();
}

/* Метод для создания таблицы в базе данных
 * */
bool DataBase::createTable()
{
    /* В данном случае используется формирование сырого SQL-запроса
     * с последующим его выполнением.
     * */
    QSqlQuery query;
    if(!query.exec( "CREATE TABLE " TABLE " ("
                            "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                            TABLE_DATE      " DATE            NOT NULL,"
                            TABLE_TIME      " TIME            NOT NULL,"
                            TABLE_RANDOM    " INTEGER         NOT NULL,"
                            TABLE_MESSAGE   " VARCHAR(255)    NOT NULL"
                        " )"
                    )){
        qDebug() << "DataBase: error of create " << TABLE;
        qDebug() << query.lastError().text();
        return false;
    } else {
        return true;
    }
    return false;
}

/* Метод для вставки записи в базу данных
 * */
bool DataBase::inserIntoTable(const QVariantList &data)
{
    /* Запрос SQL формируется из QVariantList,
     * в который передаются данные для вставки в таблицу.
     * */
    QSqlQuery query;
    /* В начале SQL запрос формируется с ключами,
     * которые потом связываются методом bindValue
     * для подстановки данных из QVariantList
     * */
    query.prepare("INSERT INTO " TABLE " ( " TABLE_DATE ", "
                                             TABLE_TIME ", "
                                             TABLE_RANDOM ", "
                                             TABLE_MESSAGE " ) "
                  "VALUES (:Date, :Time, :Random, :Message )");
    query.bindValue(":Date",        data[0].toDate());
    query.bindValue(":Time",        data[1].toTime());
    query.bindValue(":Random",      data[2].toInt());
    query.bindValue(":Message",     data[3].toString());
    // После чего выполняется запросом методом exec()
    if(!query.exec()){
        qDebug() << "error insert into " << TABLE;
        qDebug() << query.lastError().text();
        return false;
    } else {
        return true;
    }
    return false;
}

Ergebnis

Als Ergebnis sollten Sie eine Platte der folgenden Form mit den Daten erhalten, die vorbereitet und in den Konstruktor des Hauptanwendungsfensters eingefügt wurden.

Anwendungsdarstellung mit QSqlTableModel