← C++

C++ · 21 / 24

Aufträge mit SQLite und Transaktionen speichern

Du implementierst ein dauerhaftes Repository und weist nach, dass ein Fehler mitten im Import keine teilweise Änderung hinterlässt.

  • Groß
  • Anspruchsvoll
  • 120 min

Voraussetzungen: Austauschbare Repositories und gezielte Test-Doubles

In diesem Tutorial
  1. Qt SQL und den SQLite-Treiber bereitstellen
  2. Den bisherigen Vertrag übernehmen
  3. Transaktion und Ressourcen begrenzen
  4. Einen echten Fehler einschleusen
  5. Wiederöffnung und Rollback prüfen
  6. Eine fachliche Stapelaktion ergänzen
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20, CMake ab 3.25, CTest und Python 3. Qt 6.8 mit Core, Widgets und Test. Zusätzlich Qt SQL mit QSQLITE-Plugin. Setze CMAKE_PREFIX_PATH auf deinen Qt-Installationsordner, falls Qt nicht automatisch gefunden wird. Lokal geprüft mit Qt 6.8.3. Entpacke das ZIP in einen neuen Ordner. python3 run_checks.py prüft Beispiel und Lösung in einer temporären Kopie und erhält deine Dateien. Für einen eigenen Build führe python3 verify.py aus. Danach liegt das Demo unter build/order_lab. Die Qt-Demos verwenden englische Beschriftungen. Automatische Widgettests nutzen standardmäßig offscreen. Starte die sichtbare Demo in einer Desktop-Sitzung ohne QT_QPA_PLATFORM=offscreen. Native Windows-Ausführung ist nicht verifiziert.

Geprüft am 21.10.2026 unter Linux x86_64. Echte SQLite-Dateien, Wiederöffnung, gebundene Parameter, Constraints, Triggerfehler nach dem ersten INSERT und vollständiges Rollback. Die Übung prüft einen atomaren Statuswechsel. Kein Stromausfall- oder Mehrprozess-Konflikttest.

Ein Import besteht aus mehreren SQL-Anweisungen. Ohne Transaktion kann eine gelöschte Liste oder nur ein Teil der neuen Aufträge zurückbleiben. Unser SQLite-Repository setzt den Austausch deshalb als eine Transaktion um. Ein Test erzeugt absichtlich einen Datenbankfehler beim zweiten Einfügen. Danach müssen exakt die zuvor gespeicherten Aufträge lesbar sein.

Paketinhalt und einzelne Dateien

01Qt SQL und den SQLite-Treiber bereitstellen

Installiere Qt 6.8 einschließlich des QSQLITE-Plugins. CMake verknüpft Qt6::Sql. Ein fehlender Treiber oder eine nicht zu öffnende Datei führt zu einem Fehler, nicht zu einer stillen Speicherattrappe. python3 verify.py prüft echte SQLite-Dateien in temporären Verzeichnissen.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(cpp_21 LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
enable_testing()
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
  add_compile_options(-Wall -Wextra -Wpedantic -Werror)
endif()
find_package(Qt6 6.8 REQUIRED COMPONENTS Core Test Widgets Sql)
set(CMAKE_AUTOMOC ON)
add_executable(order_lab main.cpp)
target_link_libraries(order_lab PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Sql)
add_executable(lesson_tests tests.cpp)
target_link_libraries(lesson_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Sql)
add_test(NAME lesson_tests COMMAND lesson_tests)
set_tests_properties(lesson_tests PROPERTIES TIMEOUT 30)
add_executable(exercise_solution solution.cpp)
target_link_libraries(exercise_solution PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Sql)
add_test(NAME exercise_solution COMMAND exercise_solution)
set_tests_properties(exercise_solution PROPERTIES TIMEOUT 30)
Erwartetes Ergebnis

Die Tests öffnen echte Datenbankdateien ohne externen Datenbankserver.

02Den bisherigen Vertrag übernehmen

OrderService bleibt unverändert. SqliteRepository muss list und replaceAll erfüllen. Ein gelesener Bestand wird zusätzlich fachlich validiert. Die Anwendung ist weiterhin ein Beispiel für einen schreibenden Prozess. Eine globale Konfliktauflösung zwischen mehreren laufenden Instanzen ist nicht Teil dieses Vertrags.

repository.hpp · cppDatei öffnen
#pragma once
#include "order.hpp"

namespace orders {
class OrderRepository {
public:
  virtual ~OrderRepository() = default;
  virtual Result<std::vector<Order>> list() const = 0;
  // Contract: failure leaves the previously committed batch intact.
  virtual Result<Done> replaceAll(std::span<const Order> batch) = 0;
};
class MemoryRepository final : public OrderRepository {
  std::vector<Order> data_;

public:
  Result<std::vector<Order>> list() const override { return data_; }
  Result<Done> replaceAll(std::span<const Order> batch) override {
    return replaceValidated(data_, batch);
  }
};
class OrderService {
  OrderRepository &repository_;

public:
  explicit OrderService(OrderRepository &repository)
      : repository_(repository) {}
  Result<std::vector<Order>> list() const { return repository_.list(); }
  Result<Done> replace(std::span<const Order> batch) {
    auto result = validateBatch(batch);
    if (!succeeded(result))
      return std::get<Error>(result);
    return repository_.replaceAll(batch);
  }
  Result<Done> save(const Order &order) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    auto found = std::ranges::find(batch, order.id, &Order::id);
    if (found == batch.end())
      batch.push_back(order);
    else
      *found = order;
    return replace(batch);
  }
  Result<Done> remove(int id) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    std::erase_if(batch, [id](const Order &order) { return order.id == id; });
    return replace(batch);
  }
};
} // namespace orders
Erwartetes Ergebnis

Der Dienst benötigt keine SQLite-spezifischen Methoden.

03Transaktion und Ressourcen begrenzen

Jede Instanz erhält einen eindeutigen Qt-Verbindungsnamen. Vor dem Entfernen der Verbindung werden ihre Abfragen und Datenbank-Handles freigegeben. replaceAll prüft zuerst die Eingabe, beginnt eine Transaktion, löscht den alten Bestand und fügt alle neuen Zeilen mit gebundenen Parametern ein. Ein RAII-Wächter führt bei jedem frühen Rückweg ein Rollback aus.

sqlite_repository.hpp · cppDatei öffnen
#pragma once
#include "repository.hpp"
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlQuery>
#include <QUuid>
#include <QVariant>

namespace orders {
class SqliteRepository final : public OrderRepository {
  QString name_ = QUuid::createUuid().toString();
  QSqlDatabase database_;
  std::string startupError_;
  Error failure(const QSqlQuery &query) const {
    return {ErrorCode::storage, query.lastError().text().toStdString()};
  }

public:
  explicit SqliteRepository(const QString &path)
      : database_(QSqlDatabase::addDatabase("QSQLITE", name_)) {
    database_.setDatabaseName(path);
    if (!database_.open()) {
      startupError_ = database_.lastError().text().toStdString();
      return;
    }
    QSqlQuery query(database_);
    if (!query.exec(
            "CREATE TABLE IF NOT EXISTS orders (id INTEGER PRIMARY KEY "
            "CHECK(id BETWEEN 1 AND 1000000), title TEXT NOT NULL "
            "CHECK(length(CAST(title AS BLOB)) BETWEEN 1 AND 80), priority "
            "INTEGER NOT NULL CHECK(priority BETWEEN 0 AND 2), status TEXT NOT "
            "NULL CHECK(status IN ('open', 'done')))"))
      startupError_ = query.lastError().text().toStdString();
  }
  SqliteRepository(const SqliteRepository &) = delete;
  SqliteRepository &operator=(const SqliteRepository &) = delete;
  ~SqliteRepository() override {
    database_.close();
    database_ = QSqlDatabase();
    QSqlDatabase::removeDatabase(name_);
  }
  Result<std::vector<Order>> list() const override {
    if (!startupError_.empty())
      return Error{ErrorCode::storage, startupError_};
    QSqlQuery query(database_);
    if (!query.exec("SELECT id,title,priority,status FROM orders ORDER BY id"))
      return failure(query);
    std::vector<Order> batch;
    while (query.next()) {
      const auto status = query.value(3).toString();
      if (status != "open" && status != "done")
        return Error{ErrorCode::invalid, "Unknown stored status"};
      batch.push_back({query.value(0).toInt(),
                       query.value(1).toString().toStdString(),
                       query.value(2).toInt(),
                       status == "open" ? Status::open : Status::done});
    }
    if (query.lastError().isValid())
      return failure(query);
    auto valid = validateBatch(batch);
    if (!succeeded(valid))
      return std::get<Error>(valid);
    return batch;
  }
  Result<Done> replaceAll(std::span<const Order> batch) override {
    auto valid = validateBatch(batch);
    if (!succeeded(valid))
      return std::get<Error>(valid);
    if (!startupError_.empty())
      return Error{ErrorCode::storage, startupError_};
    if (!database_.transaction())
      return Error{ErrorCode::storage,
                   database_.lastError().text().toStdString()};
    struct Rollback {
      QSqlDatabase &database;
      bool committed{false};
      ~Rollback() {
        if (!committed)
          database.rollback();
      }
    } transaction{database_};
    QSqlQuery query(database_);
    if (!query.exec("DELETE FROM orders"))
      return failure(query);
    if (!query.prepare(
            "INSERT INTO orders(id,title,priority,status) VALUES(?,?,?,?)"))
      return failure(query);
    for (const auto &order : batch) {
      query.bindValue(0, order.id);
      query.bindValue(1, QString::fromStdString(order.title));
      query.bindValue(2, order.priority);
      query.bindValue(3, order.status == Status::open ? "open" : "done");
      if (!query.exec())
        return failure(query);
    }
    if (!database_.commit())
      return Error{ErrorCode::storage,
                   database_.lastError().text().toStdString()};
    transaction.committed = true;
    return Done{};
  }
};
} // namespace orders
Erwartetes Ergebnis

Erst ein erfolgreicher Commit deaktiviert das Rollback.

04Einen echten Fehler einschleusen

Die Testhilfe öffnet eine zweite kurzlebige Verbindung. Darüber installiert der Test einen Trigger, der eine bestimmte ID ablehnt. Der erste neue Datensatz kann so erfolgreich eingefügt werden, bevor der zweite scheitert. Das prüft mehr als eine bereits vor der Transaktion abgefangene ungültige Eingabe.

sql_test_helper.hpp · cppDatei öffnen
#pragma once
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QUuid>
inline bool execSql(const QString &path, const QString &sql) {
  const auto name = QUuid::createUuid().toString();
  bool success = false;
  {
    auto database = QSqlDatabase::addDatabase("QSQLITE", name);
    database.setDatabaseName(path);
    if (database.open()) {
      QSqlQuery query(database);
      success = query.exec(sql);
    }
  }
  QSqlDatabase::removeDatabase(name);
  return success;
}
Erwartetes Ergebnis

Der Trigger erzwingt einen SQL-Fehler mitten im Austausch.

05Wiederöffnung und Rollback prüfen

Der Test schließt zunächst ein Repository und liest dieselbe Datei mit einer neuen Instanz. Dann löst er den Trigger aus und vergleicht den vollständigen alten Bestand. Weitere Fälle prüfen doppelte IDs, Anführungszeichen in Titeln, einen ausdrücklich leeren Austausch und einen nicht vorhandenen Elternordner.

tests.cpp · cppDatei öffnen
#include "sql_test_helper.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include <QTemporaryDir>
#include <QtTest>
using namespace orders;
class SqlTests : public QObject {
  Q_OBJECT
private slots:
  void roundTripAndRollback() {
    QTemporaryDir directory;
    QVERIFY(directory.isValid());
    auto path = directory.filePath("orders.sqlite");
    {
      SqliteRepository repository(path);
      QVERIFY(succeeded(repository.replaceAll(samples())));
    }
    SqliteRepository reopened(path);
    QVERIFY(std::get<std::vector<Order>>(reopened.list()) == samples());
    QVERIFY(execSql(
        path,
        "CREATE TRIGGER reject_import BEFORE INSERT ON orders WHEN NEW.id=22 "
        "BEGIN SELECT RAISE(ABORT, 'injected database failure'); END"));
    std::vector<Order> incoming{{11, "First insertion"},
                                {22, "Rejected insertion"}};
    auto failed = reopened.replaceAll(incoming);
    QVERIFY(!succeeded(failed));
    QCOMPARE(std::get<Error>(failed).code, ErrorCode::storage);
    QVERIFY(std::get<std::vector<Order>>(reopened.list()) == samples());
    incoming[1].id = 11;
    QVERIFY(!succeeded(reopened.replaceAll(incoming)));
    QVERIFY(std::get<std::vector<Order>>(reopened.list()) == samples());
    std::vector<Order> quoted{{9, "O'Reilly \"parts\"", 2}};
    QVERIFY(succeeded(reopened.replaceAll(quoted)));
    QVERIFY(std::get<std::vector<Order>>(reopened.list()) == quoted);
    QVERIFY(succeeded(reopened.replaceAll({})));
    QVERIFY(std::get<std::vector<Order>>(reopened.list()).empty());
  }
  void cannotOpen() {
    QTemporaryDir directory;
    SqliteRepository bad(directory.filePath("missing/parent/db.sqlite"));
    QVERIFY(!succeeded(bad.list()));
    QVERIFY(!succeeded(bad.replaceAll(samples())));
  }
};
QTEST_GUILESS_MAIN(SqlTests)
#include "tests.moc"
Erwartetes Ergebnis

Nach dem gescheiterten zweiten INSERT sind alle ursprünglichen Aufträge erhalten.

06Eine fachliche Stapelaktion ergänzen

finishAll liest den Bestand, setzt die Statuswerte auf done und übergibt den gesamten Kandidaten an replace. Ein zweiter Trigger lehnt die Statusänderung eines bestimmten Auftrags ab. Die Lösung prüft zunächst das vollständige Rollback und anschließend die erfolgreiche, erneut lesbare Änderung.

solution.cpp · cppDatei öffnen
#include "sql_test_helper.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include <QCoreApplication>
#include <QTemporaryDir>
orders::Result<orders::Done> finishAll(orders::OrderService &service) {
  auto loaded = service.list();
  if (!orders::succeeded(loaded))
    return std::get<orders::Error>(loaded);
  auto batch = std::get<std::vector<orders::Order>>(loaded);
  for (auto &order : batch)
    order.status = orders::Status::done;
  return service.replace(batch);
}
int main(int argc, char **argv) {
  QCoreApplication application(argc, argv);
  QTemporaryDir directory;
  auto path = directory.filePath("orders.sqlite");
  orders::SqliteRepository repository(path);
  orders::OrderService service(repository);
  require(orders::succeeded(service.replace(samples())), "seed");
  require(execSql(path, "CREATE TRIGGER reject_done BEFORE INSERT ON orders "
                        "WHEN NEW.id=2 AND NEW.status='done' BEGIN SELECT "
                        "RAISE(ABORT, 'reject done'); END"),
          "trigger installed");
  require(!orders::succeeded(finishAll(service)), "failure returned");
  require(std::get<std::vector<orders::Order>>(service.list()) == samples(),
          "no partial completion");
  require(execSql(path, "DROP TRIGGER reject_done"), "remove fault");
  require(orders::succeeded(finishAll(service)), "complete all");
  orders::SqliteRepository reopened(path);
  const auto persisted = reopened.list();
  require(orders::succeeded(persisted), "reopen succeeds");
  for (const auto &order : std::get<std::vector<orders::Order>>(persisted))
    require(order.status == orders::Status::done, "persisted done");
}
Erwartetes Ergebnis

Entweder sind alle Aufträge abgeschlossen oder der gesamte alte Zustand bleibt bestehen.

Deine Übung

Implementiere finishAll(OrderService&). Alle gespeicherten Aufträge sollen gemeinsam abgeschlossen werden. Simuliere einen Fehler beim zweiten Datensatz und prüfe, dass der erste ebenfalls unverändert bleibt.

Lösung mit Erklärung anzeigen

Die Lösung verändert einen geladenen Kandidaten und ruft genau einmal service.replace auf. Der Test entfernt den Fehlertrigger erst nach dem Rollback-Nachweis und prüft den erfolgreichen Stand über ein erneut geöffnetes Repository.

solution.cpp · cppDatei öffnen
#include "sql_test_helper.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include <QCoreApplication>
#include <QTemporaryDir>
orders::Result<orders::Done> finishAll(orders::OrderService &service) {
  auto loaded = service.list();
  if (!orders::succeeded(loaded))
    return std::get<orders::Error>(loaded);
  auto batch = std::get<std::vector<orders::Order>>(loaded);
  for (auto &order : batch)
    order.status = orders::Status::done;
  return service.replace(batch);
}
int main(int argc, char **argv) {
  QCoreApplication application(argc, argv);
  QTemporaryDir directory;
  auto path = directory.filePath("orders.sqlite");
  orders::SqliteRepository repository(path);
  orders::OrderService service(repository);
  require(orders::succeeded(service.replace(samples())), "seed");
  require(execSql(path, "CREATE TRIGGER reject_done BEFORE INSERT ON orders "
                        "WHEN NEW.id=2 AND NEW.status='done' BEGIN SELECT "
                        "RAISE(ABORT, 'reject done'); END"),
          "trigger installed");
  require(!orders::succeeded(finishAll(service)), "failure returned");
  require(std::get<std::vector<orders::Order>>(service.list()) == samples(),
          "no partial completion");
  require(execSql(path, "DROP TRIGGER reject_done"), "remove fault");
  require(orders::succeeded(finishAll(service)), "complete all");
  orders::SqliteRepository reopened(path);
  const auto persisted = reopened.list();
  require(orders::succeeded(persisted), "reopen succeeds");
  for (const auto &order : std::get<std::vector<orders::Order>>(persisted))
    require(order.status == orders::Status::done, "persisted done");
}

Projektbezug und Quellen

Eigenständiges Lernprojekt im Logistikthema von FactoryForge. Der bestehende FactoryForge-Quellstand dient als Architekturkontext. Die hier eingeführten SQLite-, Netzwerk- und Importfunktionen sind Funktionen des Lernprojekts. Das Order-Lab-JSON ist ein eigenes Format.