SQL-Datenbanktreiber

Das Modul „ Qt SQL “ nutzt Treiber-Plugins, um mit den verschiedenen Datenbank-APIs zu kommunizieren. Da die Qt SQL-API datenbankunabhängig ist, ist der gesamte datenbankspezifische Code in diesen Treibern enthalten. Qt wird mit mehreren Treibern ausgeliefert, und es können weitere Treiber hinzugefügt werden. Der Quellcode der Treiber wird bereitgestellt und kann als Vorlage für die Erstellung eigener Treiber dienen.

Unterstützte Datenbanken

Die folgende Tabelle listet die in Qt enthaltenen Treiber auf:

SQLite ist das In-Process-Datenbanksystem mit der besten Testabdeckung und Unterstützung auf allen Plattformen. Oracle über OCI, PostgreSQL und MySQL ü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 Qt XML-Skript „ configure “ versucht, die auf Ihrem Rechner verfügbaren Client-Bibliotheken automatisch zu erkennen. Führen Sie „ configure -help “ aus, um zu sehen, welche Treiber erstellt werden können. Sie sollten eine Ausgabe erhalten, die in etwa so aussieht:

[...]

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 erforderlichen Bibliotheken und Include-Dateien nicht erkennen, wenn diese sich nicht in den Standardpfaden befinden. Daher kann es erforderlich sein, diese Pfade entweder mithilfe treiberspezifischer Include- und Bibliothekspfadvariablen oder über CMAKE_INCLUDE_PATH und CMAKE_LIBRARY_PATH anzugeben. Wenn Ihre MySQL-Dateien beispielsweise unter Windows im Verzeichnis „ C:\mysql-connector-c-6.1.11-winx64 “ installiert sind, übergeben Sie den folgenden Parameter an den Doppelstrich-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 alle Abhängigkeitsprüfungen und verwendet die angegebenen Pfade unverändert. Dies ist besonders nützlich, wenn das Paket eigene Systembibliotheken bereitstellt, die von der Build-Routine nicht erkannt werden sollen.

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

Nur einen bestimmten SQL-Treiber kompilieren

Es ist möglich, nur einen bestimmten SQL-Treiber zu kompilieren, wenn Qt bereits kompiliert oder als Binärversion installiert ist. Sie müssen jedoch sicherstellen, dass Sie genau dieselbe Version der Qt-Quellcodes installieren (beispielsweise über Qt Maintenance Tool) – andernfalls können aufgrund geänderter APIs Kompilierungsfehler auftreten. Stellen Sie außerdem sicher, dass die Build-Umgebung ordnungsgemäß eingerichtet ist, indem Sie den entsprechenden Qt-Befehl über das Windows-Startmenü ausführen.

Ein typischer Aufruf von ` qt-cmake ` (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

Nach der Konfiguration mit ` qt-cmake` kompilieren Sie den Treiber, indem Sie ` ninja` ausführen.

Aufgrund praktischer Erwägungen im Umgang mit externen Abhängigkeiten wird mit den Binärversionen von Qt nur das SQLite-Plugin ausgeliefert. Binärversionen von Qt für Windows enthalten zudem die ODBC- und PostgreSQL-Plugins. Um der Qt-Installation zusätzliche Treiber hinzufügen zu können, ohne das gesamte Qt neu kompilieren 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 kompilieren. Beachten Sie, dass es nicht möglich ist, jeden Treiber einzeln zu konfigurieren, sondern nur alle gleichzeitig. Die Treiber können jedoch separat kompiliert werden.

Spezifische Informationen zu Treibern

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

MariaDB ist ein Fork von MySQL, der darauf abzielt, freie und quelloffene Software unter der GNU General Public License zu bleiben. MariaDB soll eine hohe Kompatibilität mit MySQL gewährleisten und somit eine nahtlose Ersatzfähigkeit durch binäre Bibliotheksparität sowie eine exakte Übereinstimmung mit den MySQL-APIs und -Befehlen sicherstellen. Daher sind die Plugins für MySQL und MariaDB in einem einzigen Qt-Plugin zusammengefasst.

Unterstützung von Zeitstempeln

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

Unterstützung für QMYSQL-Stored-Procedures

MySQL bietet Unterstützung für gespeicherte Prozeduren auf SQL-Ebene, verfügt jedoch über keine API zur Steuerung von IN-, OUT- und INOUT-Parametern. Daher müssen Parameter mithilfe von SQL-Befehlen anstelle von ` QSqlQuery::bindValue()` gesetzt und ausgelesen werden.

Beispiel für eine gespeicherte 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 direkter Ersatz für die normale Client-Bibliothek. Mit dem eingebetteten MySQL-Server ist kein MySQL-Server erforderlich, um MySQL-Funktionen zu nutzen.

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

Weitere Informationen zum eingebetteten MySQL-Server finden Sie in der MySQL-Dokumentation im Kapitel „libmysqld, die Bibliothek für den eingebetteten MySQL-Server“.

Verbindungsoptionen

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

Ausführlichere Informationen zu den Verbindungsoptionen finden Sie in der MySQL-Dokumentation unter mysql_options().

So kompilieren Sie das QMYSQL-Plugin unter Unix und macOS

Sie benötigen die MySQL-/MariaDB-Header-Dateien sowie die gemeinsam genutzte Bibliothek libmysqlclient.<so|dylib> / libmariadb.<so|dylib>. Je nach Ihrer Linux-Distribution müssen Sie möglicherweise ein Paket installieren, das in der Regel „mysql-devel“ oder „mariadb-devel“ heißt.

Geben Sie in qt-cmake an, wo sich die MySQL-/MariaDB-Header-Dateien und -Shared-Libraries befinden (hier wird davon ausgegangen, dass MySQL/MariaDB unter /usr/local installiert ist), und führen Sie den Kompilierungsvorgang durch:

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 .

So kompilieren Sie das QMYSQL-Plugin unter Windows

Sie benötigen die MySQL-Installationsdateien (z. B. den MySQL-Web-Installer oder den MariaDB C Connector). Führen Sie das Installationsprogramm aus, wählen Sie die benutzerdefinierte Installation und installieren Sie den MySQL C Connector, der zu Ihrer Qt-Installation passt (x86 oder x64). Überprüfen Sie nach der Installation, ob die erforderlichen 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> gleich 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 .

Denken Sie beim Verteilen Ihrer Anwendung daran, libmysql.dll bzw. libmariadb.dll in Ihr Installationspaket aufzunehmen. Die Datei muss im selben Ordner wie die ausführbare Anwendungsdatei abgelegt werden. libmysql.dll benötigt zusätzlich die MSVC-Laufzeitbibliotheken, die mit vcredist.exe installiert werden können.

QOCI für das Oracle Call Interface (OCI)

Das Qt-OCI-Plugin unterstützt die Verbindung zu Oracle-Datenbanken entsprechend der verwendeten Instant-Client-Version. Dies hängt davon ab, welche Funktionen Oracle offiziell unterstützt. 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 und ein Hostname angegeben werden.

OCI-Benutzerauthentifizierung

Das Qt-OCI-Plugin unterstützt die Authentifizierung mithilfe externer Anmeldedaten (OCI_CRED_EXT). In der Regel 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 ` herstellen, um die Authentifizierung mit externen Anmeldedaten zu verwenden.

OCI-BLOB/LOB-Unterstützung

Binary Large Objects (BLOBs) können gelesen und geschrieben werden; beachten Sie jedoch, dass dieser Vorgang unter Umständen viel Speicherplatz beansprucht. Verwenden Sie zum Auswählen von LOB-Feldern eine „Forward-Only“-Abfrage (siehe QSqlQuery::setForwardOnly()).

Das Einfügen von BLOBs sollte entweder mithilfe einer vorbereiteten Abfrage erfolgen, bei der die BLOBs an Platzhalter gebunden werden, oder über ` QSqlTableModel`, das hierfür intern eine vorbereitete Abfrage verwendet.

Verbindungsoptionen

Das Qt-OCI-Plugin unterstützt die folgenden Verbindungsoptionen:

So erstellen Sie das OCI-Plugin unter Unix und macOS

Sie benötigen lediglich das „- Basic“- und das „Instant Client Package – SDK“.

Für die Erstellung des Treibers erforderliche Oracle-Bibliotheksdateien:

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

Geben Sie in „ qt-cmake “ an, wo sich die Oracle-Header-Dateien und -Shared-Libraries befinden, und führen Sie den Build durch.

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

In der Regel reicht es aus, im Oracle-Client-Installationsprogramm auf der Oracle-Client-Installations-CD die Option „Programmer“ auszuwählen, um das Plugin zu erstellen. Bei einigen Versionen des Oracle-Clients müssen Sie möglicherweise zusätzlich die Option „Call Interface (OCI)“ auswählen, sofern diese verfügbar ist.

Erstellen Sie das Plugin wie folgt (hier wird davon ausgegangen, dass der Oracle Client unter C:\oracle und das 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 außerdem 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, über eine einheitliche Schnittstelle eine Verbindung zu verschiedenen DBMS herzustellen. 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 zusätzlich ODBC-Treiber für den auf Ihrem System installierten ODBC-Treibermanager installieren und konfigurieren müssen. Das QODBC-Plugin ermöglicht es Ihnen dann, diese Datenquellen in Ihren Qt-Anwendungen zu nutzen.

Unter Windows ist standardmäßig ein ODBC-Treibermanager installiert. Für Unix-Systeme gibt es einige Implementierungen, die zunächst installiert werden müssen. Beachten Sie, dass bei jedem Endbenutzer Ihrer Anwendung ein ODBC-Treibermanager installiert sein muss, da das QODBC-Plugin andernfalls nicht funktioniert.

Bei der Verbindung zu einer ODBC-Datenquelle sollten Sie den Namen der ODBC-Datenquelle (DSN) an die Funktion ` QSqlDatabase::setDatabaseName()` übergeben, anstatt den tatsächlichen Datenbanknamen. Es ist auch möglich, einen FILEDSN-Dateinamen (*.dsn) oder eine vollständige ODBC-Treiberzeichenfolge zu übergeben. Bei der Übergabe einer Treiberzeichenfolge müssen Sie sicherstellen, dass alle Parameter (Benutzername, Passwort, …) ordnungsgemäß maskiert sind. Bei der Übergabe des Benutzernamens oder Passworts über die Funktionen ` QSqlDatabase ` erfolgt die Maskierung durch das QODBC-Plugin.

Das QODBC-Plugin benötigt einen ODBC-kompatiblen Treibermanager der Version 2.0 oder höher. Einige ODBC-Treiber geben zwar an, mit Version 2.0 kompatibel zu sein, bieten jedoch nicht alle erforderlichen Funktionen. Das QODBC-Plugin prüft daher nach dem Aufbau einer Verbindung, ob die Datenquelle verwendet werden kann, und verweigert die Ausführung, falls die Prüfung fehlschlägt. Wenn Ihnen dieses Verhalten nicht zusagt, können Sie die Zeile ` #define ODBC_CHECK_DRIVER ` aus der Datei ` qsql_odbc.cpp` entfernen. Dies geschieht auf eigene Gefahr!

Standardmäßig weist Qt den ODBC-Treiber an, sich wie ein ODBC-2.x-Treiber zu verhalten. Bei einigen Kombinationen aus Treiber-Manager und ODBC-3.x-Treibern (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 als 3.x-Treiber zu verhalten, indem Sie vor dem Aufruf von ` open your database connection` die Option ` setting the connect option ` mit ` "SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC3" ` setzen. Beachten Sie, dass dies mehrere Aspekte des Verhaltens des ODBC-Treibers beeinflusst, z. B. die SQLSTATEs. Bevor Sie diese Verbindungsoption festlegen, lesen Sie in Ihrer ODBC-Dokumentation nach, welche Verhaltensunterschiede zu erwarten sind.

Sollte der Zugriff auf die ODBC-Datenquelle sehr langsam sein, stellen Sie sicher, dass die ODBC-Aufrufverfolgung im ODBC-Datenquellen-Manager deaktiviert ist.

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

Unterstützung von Zeitstempeln

ODBC verwendet TIMESTAMP_STRUCT, das keine Informationen über Zeitzonen oder Ähnliches enthält. Aus diesem Grund wird die Funktion „ QDateTime “ verwendet, ohne die Zeitzone in irgendeiner Weise zu berücksichtigen.

Unterstützung für ODBC-gespeicherte Prozeduren

Bei Microsoft SQL Server ist auf das von einer gespeicherten Prozedur zurückgegebene Resultset – sofern diese die `RETURN`-Anweisung verwendet oder mehrere Resultseats zurückgibt – nur dann Zugriff möglich, wenn Sie den „Forward-Only“-Modus der Abfrage mithilfe von ` QSqlQuery::setForwardOnly()` auf „Forward“ 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 auch der ODBC-Treiber und das DBMS Unicode unterstützen müssen.

Beim Oracle 9-ODBC-Treiber (Windows) muss im ODBC-Treiber-Manager die Option „SQL_WCHAR-Unterstützung“ aktiviert werden, da Oracle andernfalls alle Unicode-Zeichenfolgen in die lokale 8-Bit-Darstellung konvertiert.

Verbindungsoptionen

Das Qt-ODBC-Plugin unterstützt die folgenden Verbindungsoptionen:

Ausführlichere Informationen zu den Verbindungsoptionen finden Sie in der ODBC-Dokumentation zu SQLSetConnectAttr().

So kompilieren Sie das ODBC-Plugin unter Unix und macOS

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

Geben Sie in „ qt-cmake “ an, wo sich die unixODBC-Header-Dateien und -Bibliotheken befinden (hier wird davon ausgegangen, dass unixODBC unter „ /usr/local/unixODBC “ installiert ist), und führen Sie den Kompilierungsvorgang durch:

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 .

So kompilieren Sie das ODBC-Plugin unter Windows

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

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 Version 7.3 und höher des PostgreSQL-Servers.

Weitere Informationen zu PostgreSQL finden Sie unter http://www.postgresql.org.

Unterstützung von Zeitstempeln

Seit Qt 6.8 werden ` QDateTime `-Werte vor dem Einfügen in UTC konvertiert und beim Abrufen wieder aus UTC zurückkonvertiert. Damit dies funktioniert, setzt der Treiber die Zeitzone der Verbindung während des Aufrufs von `open()` auf UTC (SET TIME ZONE 'UTC'). Obwohl PostgreSQL den Spaltentyp `timestamptz` unterstützt, wird die beim Einfügen verwendete Zeitzone nicht beibehalten, sodass alle abgerufenen Werte von ` QDateTime ` in UTC vorliegen.

QPSQL-Unicode-Unterstützung

Der QPSQL-Treiber erkennt automatisch, ob die PostgreSQL-Datenbank, mit der Sie eine Verbindung herstellen, Unicode unterstützt oder nicht. Unicode wird automatisch verwendet, wenn der Server dies 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 Unterstützung für die Unicode-Konvertierung kompiliert sein.

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 zur Einrichtung eines Multibyte-fähigen PostgreSQL-Servers finden Sie im PostgreSQL-Administratorhandbuch, Kapitel 5.

Groß-/Kleinschreibung in QPSQL

PostgreSQL-Datenbanken berücksichtigen die Groß-/Kleinschreibung nur, wenn der Tabellen- oder Feldname bei der Erstellung der Tabelle in Anführungszeichen gesetzt wird. So sieht beispielsweise eine SQL-Abfrage wie die folgende aus:

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

stellt sicher, dass der Zugriff mit genau derselben Groß-/Kleinschreibung erfolgt, die bei der Erstellung verwendet wurde. Wird der Tabellen- oder Feldname bei der Erstellung nicht in Anführungszeichen gesetzt, wird der tatsächliche Tabellen- oder Feldname in Kleinbuchstaben geschrieben. Wenn „ QSqlDatabase::record()“ oder „ QSqlDatabase::primaryIndex()“ auf eine Tabelle oder ein Feld zugreifen, die bzw. 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());

Unterstützung für „Forward-only“-Abfragen in QPSQL

Um „Forward-Only“-Abfragen nutzen zu können, müssen Sie das QPSQL-Plugin mit der PostgreSQL-Client-Bibliothek ab Version 9.2 kompilieren. Wenn das Plugin mit einer älteren Version kompiliert wurde, steht der „Forward-Only“-Modus nicht zur Verfügung – der Aufruf von ` QSqlQuery::setForwardOnly()` mit ` true ` hat dann keine Wirkung.

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

Beim Durchlaufen der Ergebnisse 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 abrufen. 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 des Lesens der Ergebnisse einer „Forward-Only“-Abfrage mit PostgreSQL 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 „query2“ nach der „while“-Schleife ausgeführt wird.

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

Verbindungsoptionen

Das Qt-PostgreSQL-Plugin berücksichtigt alle Verbindungsoptionen, die in der PostgreSQL-Dokumentation zur Funktion `connect()` angegeben sind.

So kompilieren Sie das QPSQL-Plugin unter Unix und macOS

Die PostgreSQL-Client-Bibliothek und die Header müssen installiert sein.

Damit „ qt-cmake “ die PostgreSQL-Header-Dateien und -Shared-Libraries findet, kompilieren Sie das Plugin wie folgt (vorausgesetzt, der PostgreSQL-Client ist unter „ /usr/local/pgsql “ installiert):

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 .

So kompilieren Sie das QPSQL-Plugin unter Windows

Installieren Sie die für Ihren Compiler geeigneten PostgreSQL-Entwicklerbibliotheken. Angenommen, PostgreSQL wurde unter C:\pgsql installiert, kompilieren 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 sollten möglicherweise die folgende Online-Dokumentation konsultieren: PostgreSQL MinGW/Native Windows.

Denken Sie bei der Verteilung Ihrer Anwendung daran, die Datei `libpq.dll` in Ihr Installationspaket aufzunehmen. Sie muss im selben Ordner wie die ausführbare Datei der Anwendung abgelegt werden.

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-Entwickler-Client-Bibliothek installieren, die die zum Kompilieren des QDB2-Plugins erforderlichen Header- und Bibliotheksdateien enthält.

Der QDB2-Treiber unterstützt vorbereitete Abfragen, das Lesen und Schreiben von Unicode-Zeichenketten sowie das Lesen und Schreiben von BLOBs.

Wir empfehlen die Verwendung einer „Forward-Only“-Abfrage beim Aufruf von gespeicherten Prozeduren in DB2 (siehe QSqlQuery::setForwardOnly()).

Verbindungsoptionen

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

So kompilieren Sie das QDB2-Plugin unter Unix und macOS

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_ROOT="/usr/local/db2"
cmake --build .
cmake --install .

So kompilieren 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 lediglich wie folgt kompilieren:

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_ROOT="C:\db2"
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 In-Process-Datenbank, was bedeutet, dass kein Datenbankserver erforderlich ist. SQLite arbeitet mit einer einzigen Datei, die beim Öffnen einer Verbindung als Datenbankname angegeben werden muss. Falls die Datei nicht existiert, versucht SQLite, sie anzulegen. SQLite unterstützt außerdem In-Memory- und temporäre Datenbanken. Übergeben Sie dazu einfach „:memory:“ bzw. eine leere Zeichenfolge als Datenbanknamen.

SQLite unterliegt einigen Einschränkungen hinsichtlich mehrerer Benutzer und mehrerer Transaktionen. Wenn Sie versuchen, in einer Ressource aus verschiedenen Transaktionen zu lesen oder zu schreiben, kann es vorkommen, dass Ihre Anwendung blockiert, 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 – zum Speichern beliebiger Werttypen verwendet werden. Beispielsweise kann eine als INTEGER deklarierte Spalte in einer Zeile einen ganzzahligen Wert und in der nächsten einen Textwert enthalten. Dies liegt daran, dass SQLite den Typ eines Werts dem Wert selbst zuordnet und nicht der Spalte, in der er gespeichert ist. Eine Folge davon ist, dass der von ` QSqlField::metaType()` zurückgegebene Typ lediglich den empfohlenen Typ des Feldes angibt. Daraus sollten keine Rückschlüsse auf den tatsächlichen Typ gezogen werden, und der Typ der einzelnen Werte sollte überprüft werden.

Der Treiber ist während der Ausführung einer `select`-Anweisung für Aktualisierungen gesperrt. Dies kann bei der Verwendung von ` QSqlTableModel ` zu Problemen führen, da die Item-Ansichten von Qt Daten nach Bedarf abrufen (im Fall von ` QSqlTableModel` mit `QSqlQuery::fetchMore()`).

Informationen zu SQLite finden Sie unter http://www.sqlite.org.

Unterstützung für Zeitstempel

SQLite verfügt über keinen speziellen Spaltentyp für Zeitstempel. Ein Zeitstempel vom Typ „ QDateTime “ wird als Zeichenkette im Format „ Qt::ISODateWithMs “ gespeichert, wodurch die Zeitzonenangaben „ QDateTime “ beim Einfügen und Abfragen erhalten bleiben.

Verbindungsoptionen

Das Qt-SQLite-Plugin unterstützt die folgenden Verbindungsoptionen:

So kompilieren Sie das QSQLITE-Plugin

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

Wenn Sie die in Qt enthaltene SQLite-Bibliothek nicht verwenden möchten, können Sie den Parameter „ -DFEATURE_system_sqlite=ON “ an die Befehlszeile „ qt-cmake “ übergeben, um die SQLite-Bibliotheken des Betriebssystems zu nutzen. Dies wird nach Möglichkeit empfohlen, da es den Speicherbedarf der Installation verringert 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, SQLite ist unter C:\SQLITE installiert):

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 verfügt über einen REGEXP-Operator. Die erforderliche Implementierung muss jedoch vom Benutzer bereitgestellt werden. Der Einfachheit halber kann eine Standardimplementierung über 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 in den Qt-Code umgewandelt

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

Zur Leistungsoptimierung werden die regulären Ausdrücke intern zwischengespeichert. Standardmäßig beträgt die Cache-Größe 25, kann jedoch über den Wert der Option geändert werden. Durch die Übergabe von „QSQLITE_ENABLE_REGEXP=10 “ wird die Cache-Größe beispielsweise auf 10 reduziert.

Kompatibilität mit dem QSQLITE-Dateiformat

Kleinere Versions-Releases von SQLite beeinträchtigen manchmal die Vorwärtskompatibilität des Dateiformats. Beispielsweise kann SQLite 3.3 mit SQLite 3.2 erstellte Datenbankdateien lesen, aber mit SQLite 3.3 erstellte Datenbanken können von SQLite 3.2 nicht gelesen werden. Informationen zur Dateiformatkompatibilität zwischen den Versionen finden Sie in der SQLite-Dokumentation und den Änderungsprotokollen.

Qt-Minor-Releases folgen in der Regel den SQLite-Minor-Releases, während Qt-Patch-Releases den SQLite-Patch-Releases folgen. Patch-Releases sind daher sowohl abwärts- als auch vorwärtskompatibel.

Um SQLite zur Verwendung eines bestimmten Dateiformats zu zwingen, ist es notwendig, ein eigenes Datenbank-Plugin mit einer eigenen SQLite-Bibliothek zu erstellen und auszuliefern, wie oben dargestellt. Bei einigen SQLite-Versionen kann die Verwendung eines bestimmten Dateiformats erzwungen werden, indem beim Kompilieren von SQLite die Makrodefinition ` SQLITE_DEFAULT_FILE_FORMAT ` gesetzt wird.

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

Das Qt-Mimer-SQL-Plugin ermöglicht die Arbeit mit dem relationalen Datenbankmanagementsystem (RDBMS) Mimer SQL. Mimer SQL bietet ressourcenschonende, skalierbare und robuste relationale Datenbanklösungen, die den internationalen ISO-SQL-Standards entsprechen. Mimer SQL ist unter 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. Für die Arbeit mit Unicode-Daten müssen die Spaltentypen „National Character“ (NCHAR), „National Character Varying“ (NVARCHAR) oder „National Character Large Object“ (NCLOB) verwendet werden. Weitere Informationen zu Mimer SQL und Unicode finden Sie unter https://developer.mimer.com/features/multilingual-support

Unterstützung von Zeitstempeln

Mimer SQL kennt keine Zeitzonen, und die Funktion „ QDateTime “ wird verwendet, ohne die Zeitzone in irgendeiner Weise zu berücksichtigen.

Unterstützung für QMIMER-Stored-Procedures

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

Beispiel für eine gespeicherte Prozedur 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();

So kompilieren Sie das QMIMER-Plugin unter Unix und macOS

Sie benötigen die Mimer-SQL-Header-Dateien und die gemeinsam genutzten Bibliotheken. Diese erhalten Sie durch die Installation einer der Mimer-SQL-Varianten, die unter https://developer.mimer.com zu finden sind.

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 .

So kompilieren Sie das QMIMER-Plugin unter Windows

Sie benötigen die Mimer-SQL-Header-Dateien und die gemeinsam genutzten Bibliotheken. Diese erhalten Sie durch die Installation einer beliebigen Mimer-SQL-Variante, die unter https://developer.mimer.com zu finden 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> -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 InterBase- und Firebird-Datenbanken. InterBase kann entweder als Client/Server-System oder ohne Server verwendet werden; in diesem Fall arbeitet es mit lokalen Dateien. Die Datenbankdatei muss bereits vorhanden sein, bevor eine Verbindung hergestellt werden kann. Firebird muss in 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.

Unterstützung von Zeitstempeln

InterBase speichert Zeitstempel in UTC ohne Angaben zur Zeitzone. Aus diesem Grund wird die Funktion ` QDateTime ` verwendet, ohne die Zeitzone in irgendeiner Weise zu berücksichtigen.

Seit Firebird 4.0 unterstützt die Datenbank Zeitstempel mit Zeitzonen. Die Zeitzonenangaben werden getrennt vom Zeitstempel gespeichert, damit sie später korrekt abgerufen werden können. Weitere Informationen zur Verarbeitung von Zeitstempeln finden Sie in der Firebird-Dokumentation.

Verbindungsoptionen

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

So erstellen Sie das QIBASE-Plugin

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

Zum Erstellen dieses Plugins benötigen Sie die InterBase/Firebird-Entwicklungs-Header und -Bibliotheken.

Aufgrund von Lizenzinkompatibilitäten mit der GPL ist es Nutzern der Qt Open Source Edition nicht gestattet, dieses Plugin mit den kommerziellen Editionen von InterBase zu verknüpfen. Bitte verwenden Sie Firebird oder die kostenlose Edition von InterBase.

QIBASE Gespeicherte Prozeduren

InterBase/Firebird geben OUT-Werte als Ergebnismenge zurück. Beim Aufruf einer gespeicherten Prozedur müssen daher nur IN-Werte über ` QSqlQuery::bindValue()` gebunden werden. 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

So kompilieren Sie das QIBASE-Plugin unter Unix und macOS

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 sich „ C:\interbase\bin “ im Verzeichnis „ PATH “ befinden muss.

Fehlerbehebung

Sie sollten stets Client-Bibliotheken verwenden, die mit demselben Compiler kompiliert wurden, den Sie auch für Ihr Projekt verwenden. Wenn Sie keine Quelldistribution erhalten, um die Client-Bibliotheken selbst zu kompilieren, müssen Sie sicherstellen, dass die vorkompilierte Bibliothek mit Ihrem Compiler kompatibel ist; andernfalls erhalten Sie zahlreiche Fehlermeldungen wegen „undefinierter Symbole“.

Wenn die Kompilierung eines Plugins erfolgreich verläuft, dieses anschließend jedoch nicht geladen werden kann, führen Sie die folgenden Schritte durch, um die Ursache zu ermitteln:

1. Stellen Sie sicher, dass sich das Plugin im richtigen Verzeichnis befindet. Mit `QApplication::libraryPaths()` können Sie feststellen, wo Qt nach Plugins sucht.
2. Stellen Sie sicher, dass die Client-Bibliotheken des DBMS auf dem System verfügbar sind. Führen Sie unter Unix den Befehl ` ldd ` aus und übergeben Sie 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 die „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 so aktualisieren, dass sie den Pfad zu dem Ordner enthält, in dem sich die Client-Bibliotheken befinden.
3. Wenn Sie MSVC verwenden, stellen Sie außerdem sicher, dass das Plugin mit dem richtigen Build-Typ erstellt wurde. Da es für Debug- und Release-Versionen unterschiedliche MSVC-Laufzeitumgebungen gibt, kann ein Qt-Debug-Build kein Qt-Release-Plugin laden und umgekehrt.
4. Führen Sie die kompilierte Qt-Ausführungsdatei mit der gesetzten Umgebungsvariablen ` QT_DEBUG_PLUGINS ` aus, um beim Laden von Plugins eine sehr ausführliche Debug-Ausgabe zu erhalten.
5. Um mögliche Debug-Meldungen aus dem 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. Eine ausführlichere Erläuterung zur Festlegung von Protokollierungsregeln finden Sie unter Logging Rules.

Stellen Sie sicher, dass Sie die Anleitung zur Bereitstellung von Plugins befolgt haben.

So schreiben Sie Ihren eigenen Datenbanktreiber

QSqlDatabase ist für das Laden und Verwalten von Datenbanktreiber-Plugins zuständig. Wenn eine Datenbank hinzugefügt wird (siehe QSqlDatabase::addDatabase()), wird das entsprechende Treiber-Plugin geladen (mithilfe von QSqlDriverPlugin). QSqlDatabase ist darauf angewiesen, dass das Treiber-Plugin Schnittstellen für QSqlDriver und QSqlResult bereitstellt.

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 für die Verbindung mit einer Datenbank, die Einrichtung der entsprechenden Umgebung usw. zuständig. Darüber hinaus kann QSqlDriver Objekte vom Typ QSqlQuery 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 “, „ ALTER “ und „ TABLE “. „ QSqlResult “ enthält Funktionen wie „QSqlResult::next()“ und „QSqlResult::value()“. „ QSqlResult “ ist dafür zuständig, Abfragen an die Datenbank zu senden, Ergebnisdaten zurückzugeben usw. „ 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 unterklassifiziert und die abstrakten virtuellen Methoden in jeder Klasse implementiert werden.

Um einen „ Qt SQL “-Treiber als Plugin zu implementieren (damit er zur Laufzeit von der Qt-Bibliothek erkannt und geladen wird), muss der Treiber das Makro „ Q_PLUGIN_METADATA()“ verwenden. Weitere Informationen hierzu finden Sie unter „How to Create Qt Plugins “. Sie können sich auch unter QTDIR/qtbase/src/plugins/sqldrivers ansehen, wie dies in den mit Qt mitgelieferten SQL-Plugins umgesetzt wird.

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); }
};