SQL-Datenbank-Treiber

Das Qt SQL Modul verwendet Treiber-Plugins, um mit den verschiedenen Datenbank-APIs zu kommunizieren. Da die SQL-Modul-API von Qt datenbankunabhängig ist, ist der gesamte datenbankspezifische Code in diesen Treibern enthalten. Mehrere Treiber werden mit Qt mitgeliefert, und weitere Treiber können hinzugefügt werden. Der Quellcode der Treiber wird mitgeliefert und kann als Vorlage für das Schreiben eigener Treiber verwendet werden.

Unterstützte Datenbanken

In der folgenden Tabelle sind die in Qt enthaltenen Treiber aufgeführt:

SQLite ist das prozessinterne Datenbanksystem mit der besten Testabdeckung und Unterstützung auf allen Plattformen. Oracle über OCI, PostgreSQL und MySQL entweder über ODBC oder einen nativen Treiber sind unter Windows und Linux gut getestet. Die Vollständigkeit der Unterstützung für andere Systeme hängt von der Verfügbarkeit und Qualität der Client-Bibliotheken ab.

Erstellen der Treiber

Kompilieren Sie Qt mit einem bestimmten Treiber

Das Skript Qt configure versucht, die verfügbaren Client-Bibliotheken auf Ihrem Rechner automatisch zu erkennen. Führen Sie configure -help aus, um zu sehen, welche Treiber gebaut werden können. Sie sollten eine ähnliche Ausgabe wie diese erhalten:

[...]

Database options:

  -sql-<driver> ........ Enable SQL <driver> plugin. Supported drivers:
                         db2 ibase mysql oci odbc psql sqlite
                         [all auto]
  -sqlite .............. Select used sqlite [system/qt]

[...]

Das Skript configure kann die notwendigen Bibliotheken und Include-Dateien nicht erkennen, wenn sie sich nicht in den Standardpfaden befinden. Daher kann es notwendig sein, diese Pfade entweder über treiberspezifische Include- und Bibliothekspfadvariablen oder über CMAKE_INCLUDE_PATH und CMAKE_LIBRARY_PATH anzugeben. Wenn Ihre MySQL-Dateien beispielsweise unter C:\mysql-connector-c-6.1.11-winx64 unter Windows installiert sind, übergeben Sie den folgenden Parameter an den Double-Dash-Teil der configure-Zeile:

C:\Qt\6.0.0\Src\configure.bat -sql-mysql -- -DMySQL_ROOT="C:\mysql-8.0.22-winx64"
Configure summary:

...
Qt Sql Drivers:
  DB2 (IBM) .............................. no
  InterBase .............................. no
  Mimer SQL .............................. yes
  MySql .................................. yes
  OCI (Oracle) ........................... no
  ODBC ................................... yes
  PostgreSQL ............................. no
  SQLite ................................. yes
    Using system provided SQLite ......... no
...

Wenn Sie Treiber auf die oben beschriebene Weise konfigurieren, überspringt CMake jegliche Abhängigkeitsüberprüfungen und verwendet die angegebenen Pfade so wie sie sind. Dies ist besonders nützlich, wenn das Paket einen eigenen Satz von Systembibliotheken bereitstellt, die von der Erstellungsroutine nicht erkannt werden sollen.

Die Einzelheiten zu den einzelnen Treibern werden im Folgenden erläutert.

Kompilieren Sie nur einen bestimmten SQL-Treiber

Es ist möglich, nur einen bestimmten SQL-Treiber zu kompilieren, wenn Qt bereits gebaut oder als Binärversion installiert ist. Sie müssen jedoch sicherstellen, dass Sie die exakt gleiche Version der Qt-Quellen installieren (z.B. über Qt Maintenance Tool) - andernfalls könnten Sie Kompilierfehler aufgrund von geänderten Apis erhalten. Stellen Sie außerdem sicher, dass Sie die Build-Umgebung richtig einrichten, indem Sie die entsprechende Qt-Eingabeaufforderung im Windows-Startmenü ausführen.

Ein typischer qt-cmake -Lauf (in diesem Fall zur Konfiguration für MySQL) sieht wie folgt aus:

C:\Qt\6.0.0\mingw81_64\bin\qt-cmake -G Ninja C:\Qt\6.0.0\Src\qtbase\src\plugins\sqldrivers -DMySQL_INCLUDE_DIR="C:\mysql-8.0.22-winx64\include" -DMySQL_LIBRARY="C:\mysql-8.0.22-winx64\lib\libmysql.lib" -DCMAKE_INSTALL_PREFIX="C:\Qt\6.0.0\mingw81_64"
Configure summary:

Qt Sql Drivers:
  DB2 (IBM) .............................. no
  InterBase .............................. no
  Mimer SQL .............................. yes
  MySql .................................. yes
  OCI (Oracle) ........................... no
  ODBC ................................... yes
  PostgreSQL ............................. no
  SQLite ................................. yes
    Using system provided SQLite ......... no

-- Configuring done
-- Generating done
-- Build files have been written to: C:/build-qt6-sqldrivers

Aufgrund des praktischen Umgangs mit externen Abhängigkeiten wird nur das SQLite-Plugin mit binären Builds von Qt ausgeliefert. Binäre Builds von Qt für Windows enthalten auch das ODBC- und PostgreSQL-Plugin. Um zusätzliche Treiber zur Qt-Installation hinzufügen zu können, ohne Qt neu erstellen zu müssen, ist es möglich, das Verzeichnis qtbase/src/plugins/sqldrivers außerhalb eines vollständigen Qt-Build-Verzeichnisses zu konfigurieren und zu erstellen. Beachten Sie, dass es nicht möglich ist, jeden Treiber einzeln zu konfigurieren, sondern nur alle auf einmal. Die Treiber können jedoch separat gebaut werden.

Spezifische Treiber

QMYSQL für MySQL oder MariaDB 5.6 und höher

MariaDB ist eine Abspaltung von MySQL und soll als freie und quelloffene Software unter der GNU General Public License weitergeführt werden. MariaDB beabsichtigt, eine hohe Kompatibilität mit MySQL beizubehalten, um eine Drop-in-Ersatzfähigkeit mit Bibliotheks-Binärparität und exakter Übereinstimmung mit MySQL-APIs und -Befehlen zu gewährleisten. Daher sind die Plugins für MySQL und MariaDB in einem Qt-Plugin zusammengefasst.

Timestamp-Unterstützung

Seit Qt 6.8 werden die Werte von QDateTime vor dem Einfügen in UTC konvertiert und beim Abrufen wieder von UTC zurück. Damit dies funktioniert, setzt der Treiber die Zeitzone der Verbindung während open() auf UTC (SET time_zone = '+00:00'). Da MySQL keine Zeitzoneninformationen speichert, gehen diese Informationen verloren, und alle abgerufenen QDateTime Werte sind UTC.

Unterstützung von QMYSQL Stored Procedure

MySQL unterstützt Stored Procedures auf SQL-Ebene, hat aber keine API zur Steuerung von IN-, OUT- und INOUT-Parametern. Daher müssen die Parameter mit SQL-Befehlen anstatt mit QSqlQuery::bindValue() gesetzt und gelesen werden.

Beispiel einer gespeicherten Prozedur:

create procedure qtestproc (OUT param1 INT, OUT param2 INT)
BEGIN
    set param1 = 42;
    set param2 = 43;
END

Quellcode für den Zugriff auf die OUT-Werte:

QSqlQuery q; q.exec("call qtestproc (@outval1, @outval2)"); q.exec("select @outval1, @outval2");if (q.next())    qDebug() << q.value(0) << q.value(1); // outputs "42" and "43"

Eingebetteter MySQL-Server

Der eingebettete MySQL-Server ist ein einfacher Ersatz für die normale Client-Bibliothek. Mit dem eingebetteten MySQL-Server ist ein MySQL-Server nicht erforderlich, um die MySQL-Funktionalität zu nutzen.

Um den eingebetteten MySQL-Server zu verwenden, verknüpfen Sie einfach das Qt-Plugin mit libmysqld anstelle von libmysqlclient. Dies kann durch Hinzufügen von -DMySQL_LIBRARY=<path/to/mysqld/>libmysqld.<so|lib|dylib> in der Befehlszeile von configure erfolgen.

Weitere Informationen über den eingebetteten MySQL-Server finden Sie in der MySQL-Dokumentation, Kapitel "libmysqld, die eingebettete MySQL-Server-Bibliothek".

Verbindungsoptionen

Das Qt MySQL/MariaDB Plugin unterstützt die folgenden Verbindungsoptionen:

Ausführlichere Informationen über die Verbindungsoptionen finden Sie in der MySQL-Dokumentation mysql_options().

Wie man das QMYSQL Plugin unter Unix und macOS erstellt

Sie benötigen die MySQL / MariaDB Header-Dateien, sowie die Shared Library libmysqlclient.<so|dylib> / libmariadb.<so|dylib>. Abhängig von Ihrer Linux-Distribution müssen Sie möglicherweise ein Paket installieren, das normalerweise "mysql-devel" oder "mariadb-devel" heißt.

Teilen Sie qt-cmake mit, wo die MySQL/MariaDB-Header-Dateien und die gemeinsam genutzten Bibliotheken zu finden sind (hier wird davon ausgegangen, dass MySQL/MariaDB in /usr/local installiert ist) und bauen Sie:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DMySQL_ROOT="/usr/local/mysql"
cmake --build .
cmake --install .

Wie man das QMYSQL Plugin unter Windows erstellt

Sie benötigen die MySQL Installationsdateien (z.B. MySQL Web Installer oder MariaDB C Connector). Starten Sie das Installationsprogramm, wählen Sie die benutzerdefinierte Installation und installieren Sie den MySQL C Connector, der zu Ihrer Qt-Installation passt (x86 oder x64). Prüfen Sie nach der Installation, ob die benötigten Dateien vorhanden sind:

• <MySQL dir>/lib/libmysql.lib
• <MySQL dir>/lib/libmysql.dll
• <MySQL dir>/include/mysql.h

und für MariaDB

• <MariaDB dir>/lib/libmariadb.lib
• <MariaDB dir>/lib/libmariadb.dll
• <MariaDB dir>/include/mysql.h

Erstellen Sie das Plugin wie folgt (hier wird davon ausgegangen, dass <MySQL dir> C:\mysql-8.0.22-winx64 ist):

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DMySQL_ROOT="C:\mysql-8.0.22-winx64"
cmake --build .
cmake --install .

Wenn Sie Ihre Anwendung verteilen, denken Sie daran, libmysql.dll / libmariadb.dll in Ihr Installationspaket aufzunehmen. Die libmysql.dll muss in denselben Ordner wie die ausführbare Datei der Anwendung gelegt werden. libmysql.dll benötigt zusätzlich die MSVC-Laufzeitbibliotheken, die mit vcredist.exe installiert werden können

QOCI für die Oracle-Aufrufschnittstelle (OCI)

Das Qt OCI-Plugin unterstützt die Verbindung zu Oracle-Datenbanken in Abhängigkeit von der Version des verwendeten Instant-Clients. Dies hängt davon ab, was Oracle anzeigt, dass es unterstützt wird. Das Plugin erkennt die Datenbankversion automatisch und aktiviert die entsprechenden Funktionen.

Es ist möglich, eine Verbindung zu einer Oracle-Datenbank ohne eine tnsnames.ora-Datei herzustellen. Dazu muss die Datenbank-SID als Datenbankname an den Treiber übergeben werden und ein Hostname angegeben werden.

OCI-Benutzerauthentifizierung

Das Qt OCI-Plugin unterstützt die Authentifizierung mit externen Anmeldedaten (OCI_CRED_EXT). Normalerweise bedeutet dies, dass der Datenbankserver die vom Betriebssystem bereitgestellte Benutzerauthentifizierung anstelle seines eigenen Authentifizierungsmechanismus verwendet.

Lassen Sie den Benutzernamen und das Passwort leer, wenn Sie eine Verbindung mit QSqlDatabase öffnen, um die Authentifizierung mit externen Anmeldeinformationen zu verwenden.

OCI BLOB/LOB-Unterstützung

Binary Large Objects (BLOBs) können gelesen und geschrieben werden, aber seien Sie sich bewusst, dass dieser Prozess viel Speicherplatz beanspruchen kann. Sie sollten eine Vorwärtsabfrage verwenden, um LOB-Felder auszuwählen (siehe QSqlQuery::setForwardOnly()).

Das Einfügen von BLOBs sollte entweder mit einer vorbereiteten Abfrage erfolgen, bei der die BLOBs an Platzhalter gebunden sind, oder mit QSqlTableModel, das intern eine vorbereitete Abfrage für diese Aufgabe verwendet.

Verbindungsoptionen

Das Qt OCI Plugin unterstützt die folgenden Verbindungsoptionen:

Wie man das OCI-Plugin unter Unix und macOS erstellt

Alles was Sie brauchen ist das " - Basic" und "Instant Client Package - SDK".

Oracle Bibliotheksdateien, die für die Erstellung des Treibers erforderlich sind:

• libclntsh.<so|dylib> (alle Versionen)

Teilen Sie qt-cmake mit, wo die Oracle-Header-Dateien und die gemeinsam genutzten Bibliotheken zu finden sind, und erstellen Sie sie.

Wir gehen davon aus, dass Sie die RPM-Pakete des Instant Client Package SDK installiert haben (Sie müssen die Versionsnummer entsprechend anpassen):

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DOracle_ROOT="/usr/include/oracle/21/client64"
cmake --build .
cmake --install .

So erstellen Sie das OCI-Plugin unter Windows

Die Auswahl der Option "Programmer" im Oracle Client Installer von der Oracle Client Installations-CD ist im Allgemeinen ausreichend, um das Plugin zu erstellen. Bei einigen Versionen des Oracle-Clients müssen Sie möglicherweise auch die Option "Call Interface (OCI)" auswählen, wenn diese verfügbar ist.

Erstellen Sie das Plugin wie folgt (hier wird davon ausgegangen, dass Oracle Client unter C:\oracle und SDK unter C:\oracle\sdk installiert ist):

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DOracle_ROOT="C:\oracle"
cmake --build .
cmake --install .

Wenn Sie Ihre Anwendung ausführen, müssen Sie auch den Pfad oci.dll zu Ihrer Umgebungsvariablen PATH hinzufügen:

set PATH=%PATH%;C:\oracle

QODBC für Open Database Connectivity (ODBC)

ODBC ist eine allgemeine Schnittstelle, die es Ihnen ermöglicht, sich mit mehreren DBMS über eine gemeinsame Schnittstelle zu verbinden. Mit dem QODBC-Treiber können Sie eine Verbindung zu einem ODBC-Treibermanager herstellen und auf die verfügbaren Datenquellen zugreifen. Beachten Sie, dass Sie auch ODBC-Treiber für den ODBC-Treiber-Manager, der auf Ihrem System installiert ist, installieren und konfigurieren müssen. Das QODBC-Plugin ermöglicht es Ihnen dann, diese Datenquellen in Ihren Qt-Anwendungen zu verwenden.

Unter Windows wird standardmäßig ein ODBC-Treiber-Manager installiert. Für Unix-Systeme gibt es einige Implementierungen, die zuerst installiert werden müssen. Beachten Sie, dass jeder Endbenutzer Ihrer Anwendung einen ODBC-Treiber-Manager installiert haben muss, da das QODBC-Plugin sonst nicht funktioniert.

Wenn Sie sich mit einer ODBC-Datenquelle verbinden, sollten Sie den Namen der ODBC-Datenquelle (DSN) an die Funktion QSqlDatabase::setDatabaseName() übergeben und nicht den eigentlichen Datenbanknamen. Es ist auch möglich, einen FILEDSN (*.dsn) Dateinamen oder einen vollständigen ODBC-Treiberstring zu übergeben. Bei der Übergabe eines Treiberstrings müssen Sie darauf achten, dass alle Parameter (Benutzername, Passwort, ...) korrekt escaped werden. Wenn Sie den Benutzernamen oder das Passwort über die QSqlDatabase Funktionen übergeben, wird das Escaping vom QODBC Plugin übernommen.

Das QODBC-Plugin benötigt einen ODBC-kompatiblen Treibermanager der Version 2.0 oder höher. Einige ODBC-Treiber behaupten zwar, Version 2.0-kompatibel zu sein, bieten aber nicht alle notwendigen Funktionen. Das QODBC-Plugin prüft daher nach dem Verbindungsaufbau, ob die Datenquelle verwendet werden kann, und verweigert die Arbeit, wenn die Prüfung fehlschlägt. Wenn Sie dieses Verhalten nicht wünschen, können Sie die Zeile #define ODBC_CHECK_DRIVER aus der Datei qsql_odbc.cpp entfernen. Tun Sie dies auf eigene Gefahr!

Standardmäßig weist Qt den ODBC-Treiber an, sich wie ein ODBC 2.x-Treiber zu verhalten. Bei einigen Treiber-Manager/ODBC 3.x-Treiber-Kombinationen (z.B. unixODBC/MaxDB ODBC) kann die Anweisung an den ODBC-Treiber, sich wie ein 2.x-Treiber zu verhalten, jedoch zu unerwartetem Verhalten des Treiber-Plugins führen. Um dieses Problem zu vermeiden, weisen Sie den ODBC-Treiber an, sich wie ein 3.x-Treiber zu verhalten, indem Sie setting the connect option "SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC3" eingeben, bevor Sie open your database connection aufrufen. Beachten Sie, dass dies mehrere Aspekte des Verhaltens des ODBC-Treibers beeinflussen wird, z.B. die SQLSTATEs. Bevor Sie diese Connect-Option setzen, sollten Sie sich in Ihrer ODBC-Dokumentation über die zu erwartenden Verhaltensunterschiede informieren.

Wenn der Zugriff auf die ODBC-Datenquelle sehr langsam ist, stellen Sie sicher, dass die ODBC-Aufrufverfolgung im ODBC-Datenquellenmanager ausgeschaltet ist.

Einige Treiber unterstützen keine scrollbaren Cursor. In diesem Fall können nur Abfragen im Modus QSqlQuery::setForwardOnly() erfolgreich verwendet werden.

Zeitstempel-Unterstützung

ODBC verwendet TIMESTAMP_STRUCT, das keine Informationen über eine Zeitzone oder ähnliches enthält. Aus diesem Grund wird QDateTime verwendet, ohne die Zeitzone zu berücksichtigen.

ODBC Stored Procedure Unterstützung

Mit Microsoft SQL Server ist die Ergebnismenge, die von einer gespeicherten Prozedur zurückgegeben wird, die die Rückgabeanweisung verwendet oder mehrere Ergebnismengen zurückgibt, nur dann zugänglich, wenn Sie den Modus "Nur Vorwärts" der Abfrage mit QSqlQuery::setForwardOnly() auf "Vorwärts" setzen.

// STORED_PROC uses the return statement or returns multiple result sets
QSqlQuery query;
query.setForwardOnly(true);
query.exec("{call STORED_PROC}");

ODBC Unicode-Unterstützung

Das QODBC-Plugin verwendet die Unicode-API, wenn UNICODE definiert ist. Auf Windows-basierten Systemen ist dies die Standardeinstellung. Beachten Sie, dass der ODBC-Treiber und das DBMS ebenfalls Unicode unterstützen müssen.

Für den Oracle 9 ODBC-Treiber (Windows) muss im ODBC-Treiber-Manager die Option "SQL_WCHAR support" aktiviert werden, andernfalls konvertiert Oracle alle Unicode-Strings in die lokale 8-Bit-Darstellung.

Verbindungsoptionen

Das Qt ODBC-Plugin berücksichtigt die folgenden Verbindungsoptionen:

Weitere Informationen zu den Verbindungsoptionen finden Sie in der SQLSetConnectAttr() ODBC-Dokumentation.

Wie man das ODBC-Plugin unter Unix und macOS erstellt

Es wird empfohlen, dass Sie unixODBC verwenden. Die neueste Version und ODBC-Treiber finden Sie unter http://www.unixodbc.org. Sie benötigen die unixODBC-Header-Dateien und gemeinsam genutzte Bibliotheken.

Teilen Sie qt-cmake mit, wo Sie die unixODBC-Headerdateien und die gemeinsam genutzten Bibliotheken finden können (hier wird davon ausgegangen, dass unixODBC unter /usr/local/unixODBC installiert ist), und erstellen Sie sie:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DODBC_INCLUDE_DIR="/usr/local/unixODBC/include" -DODBC_LIBRARY="/usr/local/unixODBC/lib/libodbc.<so|dylib>"
cmake --build .
cmake --install .

Wie man das ODBC-Plugin unter Windows erstellt

Die ODBC-Header- und Include-Dateien sollten bereits in den richtigen Verzeichnissen installiert sein. Sie müssen das Plugin nur noch wie folgt erstellen:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform>
cmake --build .
cmake --install .

QPSQL für PostgreSQL (Version 7.3 und höher)

Der QPSQL-Treiber unterstützt die Version 7.3 und höher des PostgreSQL-Servers.

Für weitere Informationen über PostgreSQL besuchen Sie http://www.postgresql.org.

Timestamp-Unterstützung

Seit Qt 6.8 werden die Werte von QDateTime vor dem Einfügen in UTC konvertiert und beim Abrufen wieder von UTC zurück. Damit dies funktioniert, setzt der Treiber die Zeitzone der Verbindung während open() auf UTC (SET TIME ZONE 'UTC'). Obwohl PostgreSQL über den Spaltentyp `timestamptz` verfügt, wird die beim Einfügen verwendete Zeitzone nicht beibehalten, so dass alle abgerufenen QDateTime Werte UTC sind.

QPSQL Unicode Unterstützung

Der QPSQL-Treiber erkennt automatisch, ob die PostgreSQL-Datenbank, mit der Sie sich verbinden, Unicode unterstützt oder nicht. Unicode wird automatisch verwendet, wenn der Server es unterstützt. Beachten Sie, dass der Treiber nur die UTF-8 Kodierung unterstützt. Wenn Ihre Datenbank eine andere Kodierung verwendet, muss der Server mit Unicode-Konvertierungsunterstützung kompiliert werden.

Die Unicode-Unterstützung wurde in PostgreSQL Version 7.1 eingeführt und funktioniert nur, wenn sowohl der Server als auch die Client-Bibliothek mit Multibyte-Unterstützung kompiliert wurden. Weitere Informationen über die Einrichtung eines PostgreSQL-Servers mit Multibyte-Unterstützung finden Sie im PostgreSQL Administrator Guide, Kapitel 5.

QPSQL Groß-/Kleinschreibunterscheidung

PostgreSQL-Datenbanken beachten die Groß- und Kleinschreibung nur, wenn der Tabellen- oder Feldname bei der Erstellung der Tabelle in Anführungszeichen gesetzt wird. So kann zum Beispiel eine SQL-Abfrage wie folgt aussehen:

CREATE TABLE "testTable" ("id" INTEGER);

wird sicherstellen, dass der Zugriff mit der gleichen Groß- und Kleinschreibung erfolgt, die verwendet wurde. Wenn der Tabellen- oder Feldname bei der Erstellung nicht in Anführungszeichen gesetzt wird, wird der tatsächliche Tabellen- oder Feldname kleingeschrieben. Wenn QSqlDatabase::record() oder QSqlDatabase::primaryIndex() auf eine Tabelle oder ein Feld zugreifen, das bei der Erstellung nicht in Anführungszeichen gesetzt wurde, muss der an die Funktion übergebene Name in Kleinbuchstaben geschrieben sein, damit er gefunden wird. Zum Beispiel:

QString tableString("testTable");
QSqlQuery q;
// Create table query is not quoted, therefore it is mapped to lower case
q.exec(QString("CREATE TABLE %1 (id INTEGER)").arg(tableString));
// Call toLower() on the string so that it can be matched
QSqlRecord rec = database.record(tableString.toLower());

QPSQL Unterstützung von Nur-Vorwärts-Abfragen

Um Forward-Only-Abfragen zu verwenden, müssen Sie das QPSQL-Plugin mit der PostreSQL-Client-Bibliothek Version 9.2 oder höher erstellen. Wenn das Plugin mit einer älteren Version erstellt wurde, ist der Forward-Only-Modus nicht verfügbar - der Aufruf von QSqlQuery::setForwardOnly() mit true hat keine Auswirkungen.

QSqlDatabase: QPSQL driver not loaded
QSqlDatabase: available drivers: QSQLITE QMYSQL QMARIADB QODBC QPSQL
Could not create database object

Während der Navigation in den Ergebnissen im Forward-Only-Modus kann sich das Handle von QSqlResult ändern. Anwendungen, die das Low-Level-Handle des SQL-Ergebnisses verwenden, müssen nach jedem Aufruf einer der QSqlResult Fetch-Funktionen ein neues Handle erhalten. Beispiel:

QSqlQuery query;
QVariant v;
query.setForwardOnly(true);
query.exec("SELECT * FROM table");
while (query.next()) {
    // Handle changes in every iteration of the loop
    v = query.result()->handle();

    if (qstrcmp(v.typeName(), "PGresult*") == 0) {
        PGresult *handle = *static_cast<PGresult **>(v.data());
        if (handle) {
            // Do something...
        }
    }
}

Während die Ergebnisse einer Forward-Only-Abfrage mit PostgreSQL gelesen werden, kann die Datenbankverbindung nicht zur Ausführung anderer Abfragen verwendet werden. Dies ist eine Einschränkung der libpq-Bibliothek. Beispiel:

int value;
QSqlQuery query1;
query1.setForwardOnly(true);
query1.exec("select * FROM table1");
while (query1.next()) {
    value = query1.value(0).toInt();
    if (value == 1) {
        QSqlQuery query2;
        query2.exec("update table2 set col=2");  // WRONG: This will discard all results of
    }                                            // query1, and cause the loop to quit
}

Dieses Problem tritt nicht auf, wenn query1 und query2 unterschiedliche Datenbankverbindungen verwenden oder wenn wir query2 nach der while-Schleife ausführen.

QPSQLDriver::getResult: Query results lost - probably discarded on executing another SQL query.

Verbindungsoptionen

Das Qt PostgreSQL Plugin beachtet alle Verbindungsoptionen, die in der connect() PostgreSQL Dokumentation angegeben sind.

Wie man das QPSQL-Plugin unter Unix und macOS erstellt

Sie benötigen die PostgreSQL-Client-Bibliothek und Header installiert.

Um qt-cmake dazu zu bringen, die PostgreSQL-Header-Dateien und die gemeinsam genutzten Bibliotheken zu finden, erstellen Sie das Plugin auf folgende Weise (unter der Annahme, dass der PostgreSQL-Client unter /usr/local/pgsql installiert ist):

mkdir build-psql-driver
cd build-psql-driver

qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers-DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DPostgreSQL_ROOT="/usr/local/pgsql"
cmake --build .
cmake --install .

Wie man das QPSQL Plugin unter Windows erstellt

Installieren Sie die entsprechenden PostgreSQL Entwicklerbibliotheken für Ihren Compiler. Unter der Annahme, dass PostgreSQL in C:\pgsql installiert wurde, bauen Sie das Plugin wie folgt:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DPostgreSQL_ROOT="C:\pgsql"
cmake --build .
cmake --install .

Benutzer von MinGW möchten vielleicht das folgende Online-Dokument konsultieren: PostgreSQL MinGW/Native Windows.

Wenn Sie Ihre Anwendung weitergeben, denken Sie daran, libpq.dll in Ihr Installationspaket aufzunehmen. Sie muss sich im selben Ordner wie die ausführbare Datei der Anwendung befinden.

QDB2 für IBM DB2 (Version 7.1 und höher)

Das Qt DB2-Plugin ermöglicht den Zugriff auf IBM DB2-Datenbanken. Es wurde mit IBM DB2 v7.1 und 7.2 getestet. Sie müssen die IBM DB2 Entwicklungs-Client-Bibliothek installieren, die die Header- und Bibliotheksdateien enthält, die zum Kompilieren des QDB2-Plugins erforderlich sind.

Der QDB2-Treiber unterstützt vorbereitete Abfragen, Lesen/Schreiben von Unicode-Strings und Lesen/Schreiben von BLOBs.

Wir empfehlen, beim Aufruf von Stored Procedures in DB2 eine Forward-Only-Abfrage zu verwenden (siehe QSqlQuery::setForwardOnly()).

Verbindungsoptionen

Das Qt IBM DB2 Plugin unterstützt die folgenden Verbindungsoptionen:

Wie man das QDB2-Plugin unter Unix und macOS erstellt

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DDB2_INCLUDE_DIR="/usr/local/db2/include" -DDB2_LIBRARY="/usr/local/db2/lib/libdb2.<so|dylib>"
cmake --build .
cmake --install .

So erstellen Sie das QDB2-Plugin unter Windows

Die DB2-Header- und Include-Dateien sollten bereits in den richtigen Verzeichnissen installiert sein. Sie müssen das Plugin nur noch wie folgt erstellen:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DDB2_INCLUDE_DIR="C:\db2\include" -DDB2_LIBRARY="C:\db2\lib\db2.lib"
cmake --build .
cmake --install .

QSQLITE für SQLite (Version 3 und höher)

Das Qt SQLite-Plugin ermöglicht den Zugriff auf SQLite-Datenbanken. SQLite ist eine prozessinterne Datenbank, d.h. es ist kein Datenbankserver erforderlich. SQLite arbeitet mit einer einzigen Datei, die beim Öffnen einer Verbindung als Datenbankname angegeben werden muss. Wenn die Datei nicht existiert, versucht SQLite, sie zu erstellen. SQLite unterstützt auch In-Memory- und temporäre Datenbanken. Geben Sie einfach ":memory:" oder einen leeren String als Datenbanknamen an.

SQLite hat einige Einschränkungen in Bezug auf mehrere Benutzer und mehrere Transaktionen. Wenn Sie versuchen, von verschiedenen Transaktionen aus auf eine Ressource zu lesen/schreiben, kann Ihre Anwendung einfrieren, bis eine Transaktion bestätigt oder zurückgesetzt wird. Der Qt SQLite-Treiber versucht so lange, in eine gesperrte Ressource zu schreiben, bis ein Timeout auftritt (siehe QSQLITE_BUSY_TIMEOUT unter QSqlDatabase::setConnectOptions()).

In SQLite kann jede Spalte, mit Ausnahme einer INTEGER PRIMARY KEY-Spalte, verwendet werden, um jeden Werttyp zu speichern. Eine Spalte, die als INTEGER deklariert ist, kann zum Beispiel in einer Zeile einen Integer-Wert und in der nächsten Zeile einen Text-Wert enthalten. Das liegt daran, dass SQLite den Typ eines Wertes mit dem Wert selbst assoziiert und nicht mit der Spalte, in der er gespeichert ist. Eine Folge davon ist, dass der von QSqlField::type() zurückgegebene Typ nur den empfohlenen Typ des Feldes angibt. Daraus sollte nicht auf den tatsächlichen Typ geschlossen werden und der Typ der einzelnen Werte sollte überprüft werden.

Der Treiber ist für Aktualisierungen gesperrt, während ein Select ausgeführt wird. Dies kann bei der Verwendung von QSqlTableModel zu Problemen führen, da die Elementansichten von Qt die Daten bei Bedarf abrufen (mit QSqlQuery::fetchMore() im Fall von QSqlTableModel).

Informationen über SQLite finden Sie auf http://www.sqlite.org.

Zeitstempel-Unterstützung

SQLite verfügt nicht über einen speziellen Zeitstempel-Spaltentyp. Ein QDateTime wird als String gespeichert und in Qt::ISODateWithMs formatiert, so dass die Zeitzoneninformation QDateTime beim Einfügen und Auswählen erhalten bleibt.

Verbindungsoptionen

Das Qt SQLite Plugin unterstützt die folgenden Verbindungsoptionen:

Wie man das QSQLITE Plugin erstellt

SQLite Version 3 ist als Bibliothek eines Drittanbieters in Qt enthalten. Es kann erstellt werden, indem der Parameter -DFEATURE_system_sqlite=OFF an die qt-cmake Befehlszeile übergeben wird.

Wenn Sie die in Qt enthaltene SQLite-Bibliothek nicht verwenden möchten, können Sie -DFEATURE_system_sqlite=ON an die Befehlszeile qt-cmake übergeben, um die SQLite-Bibliotheken des Betriebssystems zu verwenden. Dies wird empfohlen, wann immer es möglich ist, da es die Installationsgröße reduziert und eine Komponente entfernt, für die Sie Sicherheitshinweise verfolgen müssen.

Unter Unix und macOS (ersetzen Sie $SQLITE durch das Verzeichnis, in dem sich SQLite befindet):

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DFEATURE_system_sqlite=ON -DCMAKE_INCLUDE_PATH="$SQLITE/include" -DCMAKE_LIBRARY_PATH="$SQLITE/lib"
cmake --build .
cmake --install .

Unter Windows (vorausgesetzt, dass SQLite in C:\SQLITE installiert ist):

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DFEATURE_system_sqlite=ON -DCMAKE_INCLUDE_PATH="C:\SQLITE\include" -DCMAKE_LIBRARY_PATH="C:\SQLITE\lib"
cmake --build .
cmake --install .

Aktivieren Sie den REGEXP-Operator

SQLite wird mit einer REGEXP-Operation geliefert. Die benötigte Implementierung muss jedoch vom Benutzer bereitgestellt werden. Der Einfachheit halber kann eine Standardimplementierung durch setting the connect option QSQLITE_ENABLE_REGEXP vor the database connection is opened aktiviert werden. Dann wird eine SQL-Anweisung wie "column REGEXP 'pattern'" im Grunde zum Qt-Code erweitert

column.contains(QRegularExpression("pattern"));

Für eine bessere Leistung werden die regulären Ausdrücke intern zwischengespeichert. Standardmäßig beträgt die Cache-Größe 25, sie kann aber durch den Wert der Option geändert werden. Durch die Angabe von "QSQLITE_ENABLE_REGEXP=10" wird die Cache-Größe beispielsweise auf 10 reduziert.

QSQLITE Dateiformat-Kompatibilität

SQLite Minor Releases brechen manchmal die Vorwärtskompatibilität von Dateiformaten. Zum Beispiel kann SQLite 3.3 Datenbankdateien lesen, die mit SQLite 3.2 erstellt wurden, aber Datenbanken, die mit SQLite 3.3 erstellt wurden, können nicht von SQLite 3.2 gelesen werden. Informationen zur Dateiformatkompatibilität zwischen den Versionen finden Sie in der SQLite-Dokumentation und den Änderungsprotokollen.

Qt-Nebenversionen folgen normalerweise den SQLite-Nebenversionen, während Qt-Patch-Versionen den SQLite-Patch-Versionen folgen. Patch-Releases sind daher sowohl rückwärts- als auch vorwärtskompatibel.

Um SQLite zu zwingen, ein bestimmtes Dateiformat zu verwenden, ist es notwendig, ein eigenes Datenbank-Plugin mit einer eigenen SQLite-Bibliothek zu erstellen und auszuliefern, wie oben dargestellt. Einige Versionen von SQLite können gezwungen werden, ein bestimmtes Dateiformat zu schreiben, indem man das SQLITE_DEFAULT_FILE_FORMAT define beim Erstellen von SQLite setzt.

QMIMER für Mimer SQL Version 11 und höher

Das Qt Mimer SQL Plugin ermöglicht die Arbeit mit dem Mimer SQL RDBMS. Mimer SQL bietet kompakte, skalierbare und robuste relationale Datenbanklösungen, die den internationalen ISO SQL-Standards entsprechen. Mimer SQL ist auf Windows, Linux, macOS und OpenVMS sowie auf verschiedenen Embedded-Plattformen wie QNX, Android und Embedded Linux verfügbar.

Mimer SQL unterstützt Unicode vollständig. Um mit Unicode-Daten zu arbeiten, müssen die Spaltentypen National Character (NCHAR), National Character Varying (NVARCHAR), oder National Character Large Object (NCLOB) verwendet werden. Für weitere Informationen über Mimer SQL und Unicode siehe https://developer.mimer.com/features/multilingual-support

Zeitstempel-Unterstützung

MimerSQL weiß nichts über Zeitzonen und QDateTime wird ohne Berücksichtigung der Zeitzone verwendet.

QMIMER Stored Procedure Unterstützung

Mimer SQL verfügt über Stored Procedures nach dem SQL-Standard (PSM) und das Plugin unterstützt IN-, OUT- und INOUT-Parameter sowie Resultset-Prozeduren vollständig.

Beispiel einer Stored Procedure mit INOUT und OUT Parametern:

create procedure inout_proc (INOUT param1 INT, OUT param2 INT)
BEGIN
    set param1 = param1 * 2;
    set param2 = param1 * param1;
END

Quellcode für den Zugriff auf die INOUT- und OUT-Werte:

    QSqlDatabase db;
    QSqlQuery query;
    int i1 = 10, i2 = 0;
    query.prepare("call qtestproc(?, ?)");
    query.bindValue(0, i1, QSql::InOut);
    query.bindValue(1, i2, QSql::Out);
    query.exec();

Erstellung des QMIMER-Plugins unter Unix und macOS

Sie benötigen die Mimer SQL Header-Dateien und Shared Libraries. Diese erhalten Sie, indem Sie eine der Mimer-SQL-Varianten installieren, die Sie unter https://developer.mimer.com finden.

mkdir build-sqldrivers
cd build-sqldrivers

qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DMimer_INCLUDE_DIR="/usr/include" -DMimer_LIBRARIES="/usr/lib/libmimer.so"
cmake --build .
cmake --install .

Erstellen des QMIMER-Plugins unter Windows

Sie benötigen die Mimer SQL Header-Dateien und Shared Libraries. Diese erhalten Sie, indem Sie eine der Mimer-SQL-Varianten installieren, die Sie unter https://developer.mimer.com finden.

mkdir build-sqldrivers
cd build-sqldrivers

qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DMimer_INCLUDE_DIR="C:\Program Files\Mimer SQL Experience 11.0\dev\include" -DMimer_LIBRARIES="C:\Program Files\Mimer SQL Experience 11.0\dev\lib\amd64\mimapi64.lib|C:\Program Files\Mimer SQL Experience 11.0\dev\lib\x86\mimapi32.lib"
cmake --build .
cmake --install .

QIBASE für Borland InterBase

Das Qt InterBase Plugin ermöglicht den Zugriff auf die InterBase und Firebird Datenbanken. InterBase kann entweder als Client/Server oder ohne Server verwendet werden, in diesem Fall arbeitet es mit lokalen Dateien. Die Datenbankdatei muss vorhanden sein, bevor eine Verbindung hergestellt werden kann. Firebird muss mit einer Serverkonfiguration verwendet werden.

Beachten Sie, dass Sie bei InterBase den vollständigen Pfad zur Datenbankdatei angeben müssen, unabhängig davon, ob diese lokal oder auf einem anderen Server gespeichert ist.

Zeitstempel-Unterstützung

Interbase speichert Zeitstempel in UTC ohne jegliche Zeitzoneninformation. Aus diesem Grund wird QDateTime verwendet, ohne die Zeitzone zu berücksichtigen.

Seit Firebird 4.0 unterstützt die Datenbank Zeitstempel mit Zeitzonen. Die Zeitzoneninformation wird separat zum Zeitstempel gespeichert, so dass sie später richtig abgerufen werden kann. Weitere Informationen über die Behandlung von Zeitstempeln finden Sie in der Firebird-Dokumentation.

Anschlussmöglichkeiten

Das Qt Borland InterBase Plugin unterstützt die folgenden Verbindungsoptionen:

Wie man das QIBASE-Plugin erstellt

QSqlDatabase db;
db.setHostName("MyServer");
db.setDatabaseName("C:\\test.gdb");

Sie benötigen die InterBase/Firebird Entwicklungsheader und Bibliotheken, um dieses Plugin zu erstellen.

Aufgrund von Lizenzinkompatibilitäten mit der GPL ist es Benutzern der Qt Open Source Edition nicht erlaubt, dieses Plugin mit den kommerziellen Editionen von InterBase zu verbinden. Bitte verwenden Sie Firebird oder die freie Edition von InterBase.

QIBASE Gespeicherte Prozeduren

InterBase/Firebird geben OUT-Werte als Ergebnismenge zurück, so dass beim Aufruf einer Stored Procedure nur IN-Werte über QSqlQuery::bindValue() gebunden werden müssen. Die RETURN/OUT-Werte können über QSqlQuery::value() abgerufen werden. Beispiel:

QSqlQuery q; q.exec("execute procedure my_procedure");if (q.next())    qDebug() << q.value(0); // outputs the first RETURN/OUT value

Wie man das QIBASE-Plugin unter Unix und macOS erstellt

Im Folgenden wird davon ausgegangen, dass InterBase oder Firebird unter /opt/interbase installiert ist:

Wenn Sie InterBase verwenden:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_source_directory>/qtbase/src/plugins/sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>/<platform> -DInterbase_ROOT="/opt/interbase/"
cmake --build .
cmake --install .

Optional können Sie die CMake-Variablen Interbase_INCLUDE_DIR und Interbase_LIBRARY verwenden, um den Include-Pfad und die Bibliothek direkt anzugeben.

So erstellen Sie das QIBASE-Plugin unter Windows

Im Folgenden wird davon ausgegangen, dass InterBase oder Firebird unter C:\interbase installiert ist:

Wenn Sie InterBase verwenden:

mkdir build-sqldrivers
cd build-sqldrivers
qt-cmake -G Ninja <qt_installation_path>\Src\qtbase\src\plugins\sqldrivers -DCMAKE_INSTALL_PREFIX=<qt_installation_path>\<platform> -DInterbase_ROOT="C:\interbase"
cmake --build .
cmake --install .

Optional können Sie die CMake-Variablen Interbase_INCLUDE_DIR und Interbase_LIBRARY verwenden, um den Include-Pfad und die Bibliothek direkt anzugeben.

Beachten Sie, dass C:\interbase\bin in der Datei PATH liegen muss.

Fehlersuche

Sie sollten immer Client-Bibliotheken verwenden, die mit demselben Compiler kompiliert wurden, den Sie für Ihr Projekt verwenden. Wenn Sie keine Quelldistribution erhalten können, um die Client-Bibliotheken selbst zu kompilieren, müssen Sie sicherstellen, dass die vorkompilierte Bibliothek mit Ihrem Compiler kompatibel ist, da Sie sonst eine Menge "undefinierte Symbole"-Fehler erhalten.

Wenn die Kompilierung eines Plugins erfolgreich war, es aber anschließend nicht geladen werden kann, überprüfen Sie die folgenden Schritte, um den Schuldigen zu finden:

1. Stellen Sie sicher, dass sich das Plugin im richtigen Verzeichnis befindet. Sie können QApplication::libraryPaths() verwenden, um festzustellen, wo Qt nach Plugins sucht.
2. Stellen Sie sicher, dass die Client-Bibliotheken des DBMS auf dem System verfügbar sind. Unter Unix führen Sie den Befehl ldd aus und übergeben den Namen des Plugins als Parameter, zum Beispiel ldd libqsqlmysql.so. Sie erhalten eine Warnung, wenn eine der Client-Bibliotheken nicht gefunden werden konnte. Unter Windows können Sie den Dependency Walker von Visual Studio oder das Dependencies GUI verwenden, um die abhängigen Bibliotheken zu ermitteln. Mit Qt Creator können Sie die Umgebungsvariable PATH im Abschnitt Ausführen des Projektfensters aktualisieren, um den Pfad zu dem Ordner mit den Client-Bibliotheken einzuschließen.
3. Wenn Sie MSVC verwenden, stellen Sie außerdem sicher, dass das Plugin mit dem richtigen Build-Typ erstellt wird. Aufgrund der unterschiedlichen MSVC-Laufzeiten für Debug und Release kann ein Qt-Debug-Build ein Qt-Release-Plugin nicht laden und umgekehrt.
4. Führen Sie das kompilierte Qt-Executable mit gesetzter Umgebungsvariable QT_DEBUG_PLUGINS aus, um sehr ausführliche Debug-Ausgaben beim Laden von Plugins zu erhalten.
5. Um mögliche Debug-Meldungen vom SQL-Subsystem abzurufen, aktivieren Sie die Ausgabe, indem Sie die Umgebungsvariable QT_LOGGING_RULES auf qt.sql.*.debug=true setzen. Vergessen Sie nicht, die Konsole zu aktivieren, wenn Sie unter Windows arbeiten. Unter Logging Rules finden Sie eine ausführlichere Erklärung, wie Sie Regeln für die Protokollierung festlegen.

Vergewissern Sie sich, dass Sie die Anleitung zur Bereitstellung von Plugins befolgt haben.

Wie Sie Ihren eigenen Datenbanktreiber schreiben

QSqlDatabase ist für das Laden und Verwalten von Datenbanktreiber-Plugins verantwortlich. Wenn eine Datenbank hinzugefügt wird (siehe QSqlDatabase::addDatabase()), wird das entsprechende Treiber-Plugin geladen (mit QSqlDriverPlugin). QSqlDatabase stützt sich auf das Treiber-Plugin, um Schnittstellen für QSqlDriver und QSqlResult bereitzustellen.

QSqlDriver ist eine abstrakte Basisklasse, die die Funktionalität eines SQL-Datenbanktreibers definiert. Dazu gehören Funktionen wie QSqlDriver::open() und QSqlDriver::close(). QSqlDriver ist verantwortlich für die Verbindung zu einer Datenbank, die Einrichtung der richtigen Umgebung usw. Darüber hinaus kann QSqlDriver QSqlQuery Objekte erstellen, die für die jeweilige Datenbank-API geeignet sind. QSqlDatabase leitet viele seiner Funktionsaufrufe direkt an QSqlDriver weiter, das die konkrete Implementierung bereitstellt.

QSqlResult ist eine abstrakte Basisklasse, die die Funktionalität einer SQL-Datenbankabfrage definiert. Dazu gehören Anweisungen wie SELECT, UPDATE und ALTER TABLE . QSqlResult enthält Funktionen wie QSqlResult::next() und QSqlResult::value(). QSqlResult ist für das Senden von Abfragen an die Datenbank, die Rückgabe von Ergebnisdaten usw. verantwortlich. QSqlQuery leitet viele seiner Funktionsaufrufe direkt an QSqlResult weiter, das die konkrete Implementierung bereitstellt.

QSqlDriver und QSqlResult sind eng miteinander verbunden. Bei der Implementierung eines Qt SQL -Treibers müssen beide Klassen als Unterklassen angelegt und die abstrakten virtuellen Methoden in jeder Klasse implementiert werden.

Um einen Qt SQL -Treiber als Plugin zu implementieren (so dass er von der Qt-Bibliothek zur Laufzeit erkannt und geladen wird), muss der Treiber das Makro Q_PLUGIN_METADATA() verwenden. Lesen Sie How to Create Qt Plugins für weitere Informationen dazu. Sie können sich auch ansehen, wie dies in den SQL-Plugins gemacht wird, die mit Qt in QTDIR/qtbase/src/plugins/sqldrivers bereitgestellt werden.

Der folgende Code kann als Grundgerüst für einen SQL-Treiber verwendet werden:

class XyzResult : public QSqlResult
{
public:
    XyzResult(const QSqlDriver *driver)
        : QSqlResult(driver) {}
    ~XyzResult() {}

protected:
    QVariant data(int /* index */) override { return QVariant(); }
    bool isNull(int /* index */) override { return false; }
    bool reset(const QString & /* query */) override { return false; }
    bool fetch(int /* index */) override { return false; }
    bool fetchFirst() override { return false; }
    bool fetchLast() override { return false; }
    int size() override { return 0; }
    int numRowsAffected() override { return 0; }
    QSqlRecord record() const override { return QSqlRecord(); }
};

class XyzDriver : public QSqlDriver
{
public:
    XyzDriver() {}
    ~XyzDriver() {}

    bool hasFeature(DriverFeature /* feature */) const override { return false; }
    bool open(const QString & /* db */, const QString & /* user */,
              const QString & /* password */, const QString & /* host */,
              int /* port */, const QString & /* options */) override
        { return false; }
    void close() override {}
    QSqlResult *createResult() const override { return new XyzResult(this); }
};