En esta página

Controladores de bases de datos SQL

El módulo « Qt SQL » utiliza complementos de controlador para comunicarse con las diferentes API de bases de datos. Dado que la API del módulo Qt SQL es independiente de la base de datos, todo el código específico de cada base de datos se encuentra dentro de estos controladores. Qt incluye varios controladores, y se pueden añadir otros. Se proporciona el código fuente de los controladores, que puede utilizarse como modelo para escribir tus propios controladores.

Bases de datos compatibles

La siguiente tabla enumera los controladores incluidos con Qt:

Nombre del controladorSGBD
QDB2IBM DB2 (versión 7.1 y superiores)
QIBASEBorland InterBase / Firebird
QMYSQL / MARIADBMySQL o MariaDB (versión 5.6 y superiores)
QOCIControlador Oracle Call Interface (versión 12.1 y superiores)
QODBCOpen Database Connectivity (ODBC): Microsoft SQL Server y otras bases de datos compatibles con ODBC
QPSQLPostgreSQL (versiones 7.3 y superiores)
QSQLITESQLite versión 3
QMIMERMimer SQL (versión 11 y superiores)

SQLite es el sistema de bases de datos en proceso con mayor cobertura de pruebas y mejor compatibilidad en todas las plataformas. Oracle a través de OCI, PostgreSQL y MySQL, ya sea mediante ODBC o un controlador nativo, han sido sometidos a pruebas exhaustivas en Windows y Linux. La exhaustividad de la compatibilidad con otros sistemas depende de la disponibilidad y la calidad de las bibliotecas de cliente.

Nota: Para compilar un complemento de controlador, necesitas disponer de la biblioteca de cliente adecuada para tu sistema de gestión de bases de datos (SGBD). Esta proporciona acceso a la API expuesta por el SGBD y, por lo general, se incluye con él. La mayoría de los programas de instalación también permiten instalar «bibliotecas de desarrollo», que son las que necesitas. Estas bibliotecas se encargan de la comunicación de bajo nivel con el SGBD. Asegúrate también de instalar las bibliotecas de base de datos adecuadas para tu arquitectura Qt (32 o 64 bits).

Nota: Si utilizas Qt bajo condiciones de código abierto pero con una base de datos propietaria, comprueba que la licencia de la biblioteca de cliente sea compatible con la LGPL.

Compilación de los controladores

Compilar Qt con un controlador específico

El script de Qt XML « configure » intenta detectar automáticamente las bibliotecas de cliente disponibles en tu equipo. Ejecuta « configure -help » para ver qué controladores se pueden compilar. Deberías obtener un resultado similar a este:

[...]

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]

[...]

El script configure no puede detectar las bibliotecas y los archivos de inclusión necesarios si no se encuentran en las rutas estándar, por lo que puede ser necesario especificar estas rutas utilizando variables de ruta de inclusión y de biblioteca específicas del controlador, o bien CMAKE_INCLUDE_PATH y CMAKE_LIBRARY_PATH. Por ejemplo, si tus archivos de MySQL están instalados en C:\mysql-connector-c-6.1.11-winx64 en Windows, pasa el siguiente parámetro a la parte con dos guiones de la línea de configure:

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
...

Cuando se configuran los controladores de la forma descrita anteriormente, CMake omite cualquier comprobación de dependencias y utiliza las rutas proporcionadas tal cual. Esto resulta especialmente útil si el paquete proporciona su propio conjunto de bibliotecas del sistema que no deben ser reconocidas por la rutina de compilación.

A continuación se explican los detalles de cada controlador.

Nota: Si surge algún problema y quieres que CMake vuelva a comprobar los controladores disponibles, es posible que tengas que eliminar el archivo CMakeCache.txt del directorio de compilación.

Compilar solo un controlador SQL específico

Es posible compilar únicamente un controlador SQL específico cuando Qt ya está compilado o instalado como versión binaria. Pero debes asegurarte de instalar exactamente la misma versión de los fuentes de Qt (por ejemplo, a través de Qt Maintenance Tool); de lo contrario, podrías obtener errores de compilación debido a cambios en las API. Asegúrate también de configurar correctamente el entorno de compilación ejecutando el comando de línea de comandos de Qt adecuado en el menú Inicio de Windows.

Una ejecución típica de qt-cmake (en este caso, para configurar MySQL) tiene este aspecto:

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

Tras la configuración con « qt-cmake », compila el controlador ejecutando « ninja ».

Nota: Tal y como se menciona en «Compilar Qt con un controlador específico», si no se encuentra el controlador o no está habilitado, vuelve a empezar eliminando el archivo CMakeCache.txt.

Debido a las dificultades prácticas que entraña gestionar las dependencias externas, solo se incluye el complemento SQLite en las compilaciones binarias de Qt. Las compilaciones binarias de Qt para Windows también incluyen los complementos ODBC y PostgreSQL. Para poder añadir controladores adicionales a la instalación de Qt sin tener que volver a compilar todo Qt, es posible configurar y compilar el directorio ` qtbase/src/plugins/sqldrivers ` fuera del directorio de compilación completo de Qt. Ten en cuenta que no es posible configurar cada controlador por separado, sino solo todos a la vez. No obstante, los controladores se pueden compilar por separado.

Nota: Debes especificar CMAKE_INSTALL_PREFIX si deseas instalar complementos una vez finalizada la compilación.

Detalles sobre los controladores

QMYSQL para MySQL o MariaDB 5.6 y versiones posteriores

MariaDB es una bifurcación de MySQL diseñada para seguir siendo un programa libre y de código abierto bajo la Licencia Pública General de GNU. MariaDB tiene como objetivo mantener una alta compatibilidad con MySQL, garantizando una sustitución directa gracias a la paridad de los binarios de las bibliotecas y a la correspondencia exacta con las API y los comandos de MySQL. Por lo tanto, los complementos para MySQL y MariaDB se han combinado en un único complemento de Qt.

Compatibilidad con marcas de tiempo

Desde Qt 6.8, los valores de « QDateTime » se convierten a UTC antes de su inserción y se vuelven a convertir desde UTC durante su recuperación. Para que esto funcione, el controlador establece la zona horaria de la conexión en UTC durante la llamada a open() (SET time_zone = '+00:00'). Dado que MySQL no almacena ninguna información sobre la zona horaria, esta información se pierde y todos los valores recuperados mediante QDateTime son UTC.

Compatibilidad con procedimientos almacenados de QMYSQL

MySQL admite procedimientos almacenados a nivel de SQL, pero no dispone de una API para controlar los parámetros IN, OUT e INOUT. Por lo tanto, los parámetros deben establecerse y leerse mediante comandos SQL en lugar de QSqlQuery::bindValue().

Ejemplo de procedimiento almacenado:

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

Código fuente para acceder a los valores OUT:

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"

Nota: « @outval1 » y « @outval2 » son variables locales de la conexión actual y no se verán afectadas por las consultas enviadas desde otro servidor o conexión.

Servidor MySQL integrado

El servidor MySQL integrado es un sustituto directo de la biblioteca de cliente habitual. Con el servidor MySQL integrado, no es necesario disponer de un servidor MySQL para utilizar las funcionalidades de MySQL.

Para utilizar el servidor MySQL integrado, basta con vincular el complemento de Qt a libmysqld en lugar de libmysqlclient. Esto se puede hacer añadiendo -DMySQL_LIBRARY=<path/to/mysqld/>libmysqld.<so|lib|dylib> a la línea de comandos de configure.

Consulte la documentación de MySQL, en el capítulo «libmysqld, la biblioteca del servidor MySQL integrado», para obtener más información sobre el servidor MySQL integrado.

Opciones de conexión

El complemento Qt MySQL/MariaDB admite las siguientes opciones de conexión:

AtributoValor posible
CLIENT_COMPRESSSi se activa, cambia al protocolo comprimido tras una autenticación correcta
CLIENT_FOUND_ROWSSi se activa, envía las filas encontradas en lugar de las filas afectadas
CLIENT_IGNORE_SPACESi se activa, se ignoran los espacios antes de «(»
CLIENT_NO_SCHEMASi se activa, no permite el formato «base de datos.tabla.columna»
CLIENT_INTERACTIVESi se activa, el cliente se trata como interactivo
MYSQL_OPT_PROTOCOLEspecifica explícitamente el protocolo que se va a utilizar:
MYSQL_PROTOCOL_TCP: utiliza una conexión TCP (la IP o el nombre de host se especifican mediante setHostname()) MYSQL_PROTOCOL_SOCKET: se conecta a través de un socket especificado en UNIX_SOCKET. MYSQL_PROTOCOL_PIPE: se conecta a través de una tubería con nombre especificada en UNIX_SOCKET. MYSQL_PROTOCOL_MEMORY: se conecta a través de la memoria compartida especificada en MYSQL_SHARED_MEMORY_BASE_NAME
UNIX_SOCKETEspecifica el socket o la tubería con nombre que se va a utilizar; aunque se denomine UNIX_SOCKET, también se puede utilizar en Windows
MYSQL_SHARED_MEMORY_BASE_NAMEEspecifica el nombre del segmento de memoria compartida que se va a utilizar
MYSQL_OPT_RECONNECTTRUE o 1: se vuelve a conectar automáticamente tras una pérdida de conexión
FALSE o 0: no hay reconexión automática tras una pérdida de conexión (por defecto)
Véase «Control de reconexión automática»
MYSQL_OPT_CONNECT_TIMEOUTEl tiempo de espera de conexión en segundos
MYSQL_OPT_READ_TIMEOUTEl tiempo de espera, en segundos, para cada intento de lectura del servidor
MYSQL_OPT_WRITE_TIMEOUTEl tiempo de espera, en segundos, para cada intento de escritura en el servidor
MYSQL_OPT_LOCAL_INFILEEstablecer en 1 para habilitar la compatibilidad con LOAD_DATA local; se deshabilita si no se establece o si se establece en 0
MYSQL_OPT_SSL_MODEEl modo de seguridad que se utilizará para la conexión con el servidor: SSL_MODE_DISABLED, SSL_MODE_PREFERRED, SSL_MODE_REQUIRED, SSL_MODE_VERIFY_CA, SSL_MODE_VERIFY_IDENTITY. Solo disponible cuando se enlaza con MySQL 5.7.10 o superior.
MYSQL_OPT_TLS_VERSIONUna lista de los protocolos que el cliente permite para las conexiones cifradas. El valor puede ser una combinación de «TLSv1», «TLSv1.1», «TLSv1.2» o «TLSv1.3», dependiendo de la versión del servidor MySQL utilizada. Solo está disponible cuando se vincula con MySQL 5.7.11 o superior, o con MariaDB C Connector 3.1.10.
MYSQL_OPT_SSL_KEY / SSL_KEY (obsoleto)La ruta del archivo de la clave privada del cliente
MYSQL_OPT_SSL_CERT / SSL_CERT (obsoleto)La ruta de acceso al archivo del certificado de la clave pública del cliente
MYSQL_OPT_SSL_CA / SSL_CA (obsoleto)La ruta de acceso al archivo del certificado de la autoridad de certificación (CA)
MYSQL_OPT_SSL_CAPATH / SSL_CAPATH (obsoleto)La ruta de acceso al directorio que contiene los archivos de certificados SSL de CA de confianza
MYSQL_OPT_SSL_CIPHER / SSL_CIPHER (obsoleto)La lista de cifrados permitidos para el cifrado SSL
MYSQL_OPT_SSL_CRLLa ruta de acceso al archivo que contiene las listas de revocación de certificados
MYSQL_OPT_SSL_CRLPATHLa ruta de acceso al directorio que contiene los archivos con las listas de revocación de certificados
MYSQL_OPT_SSL_VERIFY_SERVER_CERTTRUE o 1: habilita la verificación de la identidad del nombre común del servidor (por defecto)
FALSE o 0: habilita la verificación de la identidad del nombre común del servidor
Solo disponible cuando se enlaza con MySQL 5.7.11 o MariaDB; se ha eliminado en MySQL 8.0.

Para obtener información más detallada sobre las opciones de conexión, consulta la documentación de MySQL sobre mysql_options().

Cómo compilar el complemento QMYSQL en Unix y macOS

Necesitarás los archivos de encabezado de MySQL / MariaDB, así como la biblioteca compartida libmysqlclient.<so|dylib> / libmariadb.<so|dylib>. Dependiendo de tu distribución de Linux, es posible que tengas que instalar un paquete que suele llamarse «mysql-devel» o «mariadb-devel».

Indica a qt-cmake dónde se encuentran los archivos de encabezado y las bibliotecas compartidas de MySQL/MariaDB (aquí se da por hecho que MySQL/MariaDB está instalado en /usr/local) y compila:

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 .

Cómo compilar el complemento QMYSQL en Windows

Debes obtener los archivos de instalación de MySQL (por ejemplo, el instalador web de MySQL o el conector C de MariaDB). Ejecuta el instalador, selecciona la instalación personalizada e instala el conector C de MySQL que se corresponda con tu instalación de Qt (x86 o x64). Tras la instalación, comprueba que los archivos necesarios estén presentes:

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

y para MariaDB

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

Nota: A partir de MySQL 8.0.19, el C Connector ya no se ofrece como componente independiente instalable. En su lugar, puede obtener mysql.h y libmysql.* instalando el servidor MySQL completo (solo x64) o el MariaDB C Connector.

Compila el complemento de la siguiente manera (aquí se da por hecho que <MySQL dir> es C:\mysql-8.0.22-winx64):

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 .

Cuando distribuyas tu aplicación, recuerda incluir libmysql.dll / libmariadb.dll en tu paquete de instalación. Deben colocarse en la misma carpeta que el ejecutable de la aplicación. libmysql.dll necesita además las bibliotecas de tiempo de ejecución de MSVC, que pueden instalarse con vcredist.exe

QOCI para la Interfaz de Llamadas de Oracle (OCI)

El complemento Qt OCI permite conectarse a una base de datos Oracle según la versión del Instant Client utilizada. Esto depende de lo que Oracle indique que es compatible. El complemento detectará automáticamente la versión de la base de datos y habilitará las funciones en consecuencia.

Es posible conectarse a una base de datos Oracle sin un archivo tnsnames.ora. Para ello, es necesario pasar el SID de la base de datos al controlador como nombre de la base de datos y especificar un nombre de host.

Autenticación de usuario OCI

El complemento OCI de Qt admite la autenticación mediante credenciales externas (OCI_CRED_EXT). Por lo general, esto significa que el servidor de la base de datos utilizará la autenticación de usuario proporcionada por el sistema operativo en lugar de su propio mecanismo de autenticación.

Deja en blanco el nombre de usuario y la contraseña al establecer una conexión con ` QSqlDatabase ` para utilizar la autenticación mediante credenciales externas.

Compatibilidad con BLOB/LOB de OCI

Se pueden leer y escribir objetos binarios de gran tamaño (BLOB), pero ten en cuenta que este proceso puede requerir mucha memoria. Debes utilizar una consulta de solo lectura para seleccionar campos LOB (consulta QSqlQuery::setForwardOnly()).

La inserción de BLOB debe realizarse mediante una consulta preparada en la que los BLOB se vinculen a marcadores de posición o mediante QSqlTableModel, que utiliza una consulta preparada para realizar esta operación internamente.

Opciones de conexión

El complemento Qt OCI admite las siguientes opciones de conexión:

AtributoValor posible
OCI_ATTR_PREFETCH_ROWSEstablece el atributo OCI OCI_ATTR_PREFETCH_ROWS en el valor especificado
OCI_ATTR_PREFETCH_MEMORYEstablece el atributo OCI OCI_ATTR_PREFETCH_MEMORY en el valor especificado
OCI_AUTH_MODEOCI_SYSDBA: autenticación para acceso SYSDBA
OCI_SYSOPER: autenticación para acceso SYSOPER
OCI_DEFAULT: autenticación con acceso normal
Consulte OCISessionBegin para obtener más información sobre los modos de acceso

Cómo compilar el complemento OCI en Unix y macOS

Todo lo que necesitas es el «- Basic» y el «Instant Client Package - SDK».

Archivos de la biblioteca de Oracle necesarios para compilar el controlador:

  • libclntsh.<so|dylib> (todas las versiones)

Indica a « qt-cmake » dónde se encuentran los archivos de cabecera y las bibliotecas compartidas de Oracle y compílalo.

Damos por hecho que has instalado los paquetes RPM del Instant Client Package SDK (debes ajustar el número de versión según corresponda):

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 .

Nota: Si utiliza el paquete Oracle Instant Client, deberá configurar LD_LIBRARY_PATH al compilar el complemento OCI SQL y al ejecutar una aplicación que utilice dicho complemento.

Cómo compilar el complemento OCI en Windows

Por lo general, basta con seleccionar la opción «Programador» en el instalador de Oracle Client desde el CD de instalación de Oracle Client para compilar el complemento. En algunas versiones de Oracle Client, es posible que también tengas que seleccionar la opción «Interfaz de llamada (OCI)», si está disponible.

Compila el complemento de la siguiente manera (aquí se da por hecho que Oracle Client está instalado en C:\oracle y que el SDK está instalado en C:\oracle\sdk):

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 .

Al ejecutar la aplicación, también deberá añadir la ruta oci.dll a la variable de entorno PATH:

set PATH=%PATH%;C:\oracle

QODBC para Open Database Connectivity (ODBC)

ODBC es una interfaz general que te permite conectarte a múltiples sistemas de gestión de bases de datos (SGBD) mediante una interfaz común. El controlador QODBC te permite conectarte a un gestor de controladores ODBC y acceder a las fuentes de datos disponibles. Ten en cuenta que también debes instalar y configurar los controladores ODBC para el gestor de controladores ODBC que tengas instalado en tu sistema. El complemento QODBC te permite entonces utilizar estas fuentes de datos en tus aplicaciones Qt.

Nota: Se recomienda utilizar el controlador nativo, si está disponible, en lugar del controlador ODBC. La compatibilidad con ODBC puede utilizarse como alternativa para las bases de datos compatibles en caso de que no haya ningún controlador nativo disponible.

En Windows, el gestor de controladores ODBC viene instalado por defecto. En los sistemas Unix, existen algunas implementaciones que deben instalarse previamente. Ten en cuenta que todos los usuarios finales de tu aplicación deben tener instalado un gestor de controladores ODBC; de lo contrario, el complemento QODBC no funcionará.

Al conectarse a una fuente de datos ODBC, debe pasar el nombre de la fuente de datos ODBC (DSN) a la función QSqlDatabase::setDatabaseName(), en lugar del nombre real de la base de datos. También es posible pasar un nombre de archivo FILEDSN (*.dsn) o una cadena completa del controlador ODBC. Al pasar una cadena de controlador, debes asegurarte de que todos los parámetros (nombre de usuario, contraseña, etc.) estén correctamente escapados. Si pasas el nombre de usuario o la contraseña a través de las funciones ` QSqlDatabase `, el complemento QODBC se encarga del escape.

El complemento QODBC necesita un gestor de controladores compatible con ODBC, versión 2.0 o posterior. Algunos controladores ODBC afirman ser compatibles con la versión 2.0, pero no ofrecen toda la funcionalidad necesaria. Por lo tanto, el complemento QODBC comprueba si se puede utilizar el origen de datos una vez establecida la conexión y se niega a funcionar si la comprobación falla. Si no te gusta este comportamiento, puedes eliminar la línea « #define ODBC_CHECK_DRIVER » del archivo « qsql_odbc.cpp ». ¡Hazlo bajo tu propia responsabilidad!

Por defecto, Qt indica al controlador ODBC que se comporte como un controlador ODBC 2.x. Sin embargo, en algunas combinaciones de gestor de controladores y controladores ODBC 3.x (por ejemplo, unixODBC/MaxDB ODBC), indicar al controlador ODBC que se comporte como un controlador 2.x puede provocar un comportamiento inesperado del complemento del controlador. Para evitar este problema, indica al controlador ODBC que se comporte como un controlador 3.x mediante ` setting the connect option ` ` "SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC3" ` antes de ` open your database connection`. Ten en cuenta que esto afectará a múltiples aspectos del comportamiento del controlador ODBC, por ejemplo, los SQLSTATE. Antes de configurar esta opción de conexión, consulta la documentación de ODBC sobre las diferencias de comportamiento que puedes esperar.

Si el acceso a la fuente de datos ODBC resulta muy lento, asegúrate de que el seguimiento de llamadas ODBC esté desactivado en el gestor de fuentes de datos ODBC.

Algunos controladores no admiten cursores desplazables. En ese caso, solo se podrán utilizar correctamente las consultas en modo « QSqlQuery::setForwardOnly()».

Compatibilidad con marcas de tiempo

ODBC utiliza TIMESTAMP_STRUCT, que no contiene información sobre ninguna zona horaria ni datos similares. Por este motivo, se utiliza la función QDateTime sin tener en cuenta la zona horaria en absoluto.

Nota: Esto podría cambiar en el futuro.

Compatibilidad con procedimientos almacenados de ODBC

Con Microsoft SQL Server, solo se podrá acceder al conjunto de resultados devuelto por un procedimiento almacenado que utilice la instrucción «return» o que devuelva varios conjuntos de resultados si se configura el modo «solo avance» de la consulta en «avanzar» mediante ` QSqlQuery::setForwardOnly()`.

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

Nota: El valor devuelto por la instrucción «return» del procedimiento almacenado se descarta.

Compatibilidad con Unicode de ODBC

El complemento QODBC utilizará la API Unicode si se define UNICODE. En sistemas basados en Windows, esta es la configuración por defecto. Ten en cuenta que el controlador ODBC y el SGBD también deben ser compatibles con Unicode.

En el caso del controlador ODBC de Oracle 9 (Windows), es necesario marcar la opción «Compatibilidad con SQL_WCHAR» en el gestor de controladores ODBC; de lo contrario, Oracle convertirá todas las cadenas Unicode a la representación local de 8 bits.

Opciones de conexión

El complemento ODBC de Qt admite las siguientes opciones de conexión:

AtributoValor posible
SQL_ATTR_ACCESS_MODESQL_MODE_READ_ONLY: abre la base de datos en modo de solo lectura
SQL_MODE_READ_WRITE: abre la base de datos en modo de lectura y escritura (por defecto)
SQL_ATTR_LOGIN_TIMEOUTNúmero de segundos que se esperará por la conexión a la base de datos durante el inicio de sesión (un valor de 0 significa que se esperará indefinidamente)
SQL_ATTR_CONNECTION_TIMEOUTNúmero de segundos de espera para cualquier solicitud a la base de datos (un valor de 0 significa que se esperará indefinidamente)
SQL_ATTR_CURRENT_CATALOGEl catálogo (base de datos) que se utilizará para esta conexión
SQL_ATTR_METADATA_IDSQL_TRUE: los argumentos de cadena de las funciones de catálogo se tratan como identificadores
SQL_FALSE: los argumentos de cadena de las funciones de catálogo no se tratan como identificadores
SQL_ATTR_PACKET_SIZEEspecifica el tamaño del paquete de red en bytes
SQL_ATTR_TRACEFILEUna cadena que contiene el nombre del archivo de seguimiento
SQL_ATTR_TRACESQL_OPT_TRACE_ON: Activa el seguimiento de consultas a la base de datos
SQL_OPT_TRACE_OFF: Desactiva el seguimiento de consultas a la base de datos (valor predeterminado)
SQL_ATTR_CONNECTION_POOLINGActiva o desactiva el agrupamiento de conexiones a nivel de entorno.
SQL_CP_DEFAULT, SQL_CP_OFF: El agrupamiento de conexiones está desactivado (por defecto)
SQL_CP_ONE_PER_DRIVER: Se admite un único grupo de conexiones para cada controlador
SQL_CP_ONE_PER_HENV: Se admite un único grupo de conexiones para cada entorno
SQL_ATTR_ODBC_VERSIONSQL_OV_ODBC3: El controlador debe funcionar como un controlador ODBC 3.x
SQL_OV_ODBC2: El controlador debe funcionar como un controlador ODBC 2.x (por defecto)
SQL_ATTR_CP_MATCHPuede ser SQL_CP_STRICT_MATCH, SQL_CP_RELAXED_MATCH o SQL_CP_MATCH_DEFAULT. Consulte la documentación de SQLConnect() ODBC para obtener más información
SQL_PERCENT_ENCODE_PASSWORDSe trata de una opción personalizada del controlador ODBC de Qt para dar soporte a controladores (Oracle, PostgreSQL) que necesitan que los caracteres especiales se codifiquen con el código de porcentaje, en lugar de entre llaves, tal y como define el estándar ODBC.

Para obtener información más detallada sobre las opciones de conexión, consulta la documentación de ODBC sobre SQLSetConnectAttr().

Cómo compilar el complemento ODBC en Unix y macOS

Se recomienda utilizar unixODBC. Puede encontrar la última versión y los controladores ODBC en http://www.unixodbc.org. Necesitará los archivos de cabecera y las bibliotecas compartidas de unixODBC.

Indica a qt-cmake dónde encontrar los archivos de cabecera y las bibliotecas compartidas de unixODBC (aquí se supone que unixODBC está instalado en /usr/local/unixODBC) y compila:

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 .

Cómo compilar el complemento ODBC en Windows

Los archivos de cabecera e inclusión de ODBC ya deberían estar instalados en los directorios correctos. Solo tienes que compilar el complemento de la siguiente manera:

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 para PostgreSQL (versión 7.3 y superiores)

El controlador QPSQL es compatible con la versión 7.3 y superiores del servidor PostgreSQL.

Para obtener más información sobre PostgreSQL, visita http://www.postgresql.org.

Compatibilidad con marcas de tiempo

Desde Qt 6.8, los valores de tipo ` QDateTime ` se convierten a UTC antes de su inserción y se vuelven a convertir desde UTC durante su recuperación. Para que esto funcione, el controlador establece la zona horaria de la conexión en UTC durante la llamada a open() (SET TIME ZONE 'UTC'). Aunque PostgreSQL dispone del tipo de columna `timestamptz`, la zona horaria utilizada durante la inserción no se conserva y, por lo tanto, todos los valores recuperados de QDateTime son UTC.

Compatibilidad con Unicode en QPSQL

El controlador QPSQL detecta automáticamente si la base de datos PostgreSQL a la que te estás conectando es compatible con Unicode o no. Se utiliza Unicode automáticamente si el servidor lo admite. Ten en cuenta que el controlador solo admite la codificación UTF-8. Si tu base de datos utiliza cualquier otra codificación, el servidor debe estar compilado con soporte para la conversión a Unicode.

La compatibilidad con Unicode se introdujo en la versión 7.1 de PostgreSQL y solo funcionará si tanto el servidor como la biblioteca del cliente se han compilado con soporte multibyte. Encontrará más información sobre cómo configurar un servidor PostgreSQL con soporte multibyte en la Guía del administrador de PostgreSQL, capítulo 5.

Distinción entre mayúsculas y minúsculas en QPSQL

Las bases de datos PostgreSQL solo distinguirán entre mayúsculas y minúsculas si el nombre de la tabla o del campo se escribe entre comillas al crear la tabla. Así, por ejemplo, una consulta SQL como:

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

garantizará que se pueda acceder a ella con las mismas mayúsculas y minúsculas que se utilizaron. Si el nombre de la tabla o del campo no se escribe entre comillas al crearla, el nombre real de la tabla o del campo aparecerá en minúsculas. Cuando QSqlDatabase::record() o QSqlDatabase::primaryIndex() acceden a una tabla o un campo que no se puso entre comillas al crearse, el nombre pasado a la función debe estar en minúsculas para garantizar que se encuentre. Por ejemplo:

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

Compatibilidad con consultas de avance único en QPSQL

Para utilizar consultas de solo avance, debes compilar el complemento de QPSQL con la biblioteca cliente de PostgreSQL versión 9.2 o posterior. Si el complemento se compila con una versión anterior, el modo de solo avance no estará disponible; llamar a ` QSqlQuery::setForwardOnly()` con ` true ` no tendrá ningún efecto.

Advertencia: Si compila el complemento QPSQL con la versión 9.2 o posterior de PostgreSQL, deberá distribuir su aplicación con la versión 9.2 o posterior de libpq. De lo contrario, la carga del complemento QPSQL fallará con el siguiente mensaje:

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

Al navegar por los resultados en modo de avance único, el identificador de QSqlResult puede cambiar. Las aplicaciones que utilicen el identificador de bajo nivel del resultado SQL deben obtener un nuevo identificador después de cada llamada a cualquiera de las funciones de recuperación de QSqlResult. Ejemplo:

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...
        }
    }
}

Al leer los resultados de una consulta de avance único con PostgreSQL, la conexión a la base de datos no se puede utilizar para ejecutar otras consultas. Se trata de una limitación de la biblioteca libpq. Ejemplo:

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
}

Este problema no se producirá si query1 y query2 utilizan conexiones a la base de datos diferentes, o si ejecutamos query2 después del bucle «while».

Nota: Algunos métodos de ` QSqlDatabase `, como `tables()` y `primaryIndex()`, ejecutan implícitamente consultas SQL, por lo que tampoco pueden utilizarse mientras se recorre los resultados de una consulta de avance único.

Nota: QPSQL mostrará la siguiente advertencia si detecta una pérdida de resultados de la consulta:

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

Opciones de conexión

El complemento Qt PostgreSQL respeta todas las opciones de conexión especificadas en la documentación de PostgreSQL para la función connect().

Cómo compilar el complemento QPSQL en Unix y macOS

Es necesario tener instaladas la biblioteca de cliente de PostgreSQL y los encabezados.

Para que qt-cmake encuentre los archivos de encabezado y las bibliotecas compartidas de PostgreSQL, compila el complemento de la siguiente manera (suponiendo que el cliente de PostgreSQL esté instalado en /usr/local/pgsql):

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 .

Cómo compilar el complemento QPSQL en Windows

Instala las bibliotecas de desarrollo de PostgreSQL adecuadas para tu compilador. Suponiendo que PostgreSQL se haya instalado en C:\pgsql, compila el complemento de la siguiente manera:

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 .

Los usuarios de MinGW pueden consultar el siguiente documento en línea: PostgreSQL MinGW/Native Windows.

Cuando distribuyas tu aplicación, recuerda incluir libpq.dll en tu paquete de instalación. Debe colocarse en la misma carpeta que el ejecutable de la aplicación.

QDB2 para IBM DB2 (versión 7.1 y superiores)

El complemento QDB2 de Qt permite acceder a bases de datos IBM DB2. Se ha probado con IBM DB2 v7.1 y 7.2. Debes instalar la biblioteca de cliente de desarrollo de IBM DB2, que contiene los archivos de cabecera y de biblioteca necesarios para compilar el complemento QDB2.

El controlador QDB2 admite consultas preparadas, la lectura y escritura de cadenas Unicode y la lectura y escritura de BLOB.

Recomendamos utilizar una consulta de solo avance al llamar a procedimientos almacenados en DB2 (véase QSqlQuery::setForwardOnly()).

Opciones de conexión

El complemento Qt para IBM DB2 admite las siguientes opciones de conexión:

AtributoValor posible
SQL_ATTR_ACCESS_MODESQL_MODE_READ_ONLY: abre la base de datos en modo de solo lectura
SQL_MODE_READ_WRITE: abre la base de datos en modo de lectura y escritura (por defecto)
SQL_ATTR_LOGIN_TIMEOUTNúmero de segundos que se esperará para establecer la conexión con la base de datos durante el inicio de sesión (máx.: 32767; un valor de 0 significa que se esperará indefinidamente)

Cómo compilar el complemento QDB2 en Unix y 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 .

Cómo compilar el complemento QDB2 en Windows

Los archivos de cabecera e inclusión de DB2 ya deberían estar instalados en los directorios correctos. Solo tienes que compilar el complemento de la siguiente manera:

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 para SQLite (versión 3 y superiores)

El complemento Qt SQLite permite acceder a bases de datos SQLite. SQLite es una base de datos en proceso, lo que significa que no es necesario disponer de un servidor de bases de datos. SQLite funciona con un único archivo, que debe indicarse como nombre de la base de datos al establecer una conexión. Si el archivo no existe, SQLite intentará crearlo. SQLite también admite bases de datos en memoria y temporales. Basta con pasar «:memory:» o una cadena vacía, respectivamente, como nombre de la base de datos.

SQLite tiene algunas restricciones en lo que respecta a múltiples usuarios y múltiples transacciones. Si intentas leer o escribir en un recurso desde diferentes transacciones, tu aplicación podría bloquearse hasta que una de las transacciones se confirme o se revierta. El controlador Qt SQLite volverá a intentar escribir en un recurso bloqueado hasta que se agote el tiempo de espera (consulta « QSQLITE_BUSY_TIMEOUT » en QSqlDatabase::setConnectOptions()).

En SQLite, cualquier columna, a excepción de una columna INTEGER PRIMARY KEY, puede utilizarse para almacenar cualquier tipo de valor. Por ejemplo, una columna declarada como INTEGER puede contener un valor entero en una fila y un valor de texto en la siguiente. Esto se debe a que SQLite asocia el tipo de un valor con el propio valor, en lugar de con la columna en la que está almacenado. Una consecuencia de ello es que el tipo devuelto por QSqlField::metaType() solo indica el tipo recomendado para el campo. No debe hacerse ninguna suposición sobre el tipo real a partir de esto, y debe comprobarse el tipo de cada valor individual.

El controlador queda bloqueado para actualizaciones mientras se ejecuta una consulta `SELECT`. Esto puede causar problemas al utilizar ` QSqlTableModel `, ya que las vistas de elementos de Qt recuperan los datos según sea necesario (mediante `QSqlQuery::fetchMore()` en el caso de ` QSqlTableModel`.

Puede encontrar información sobre SQLite en http://www.sqlite.org.

Compatibilidad con marcas de tiempo

SQLite no dispone de un tipo de columna específico para marcas de tiempo. Un « QDateTime » se almacena como cadena de caracteres, con el formato Qt::ISODateWithMs, por lo que la información de la zona horaria QDateTime se conserva durante la inserción y la selección.

Opciones de conexión

El complemento Qt SQLite admite las siguientes opciones de conexión:

AtributoValor posible
QSQLITE_BUSY_TIMEOUTTiempo de espera del controlador de ocupado en milisegundos (valor <= 0: desactivado); consulta la documentación de SQLite para obtener más información
QSQLITE_USE_QT_VFSSi se establece, la base de datos se abre utilizando el VFS de Qt, lo que permite abrir bases de datos mediante ` QFile`. De este modo, se pueden abrir bases de datos desde cualquier ubicación de lectura y escritura (por ejemplo, el almacenamiento compartido de Android), pero también desde recursos de solo lectura (por ejemplo, qrc o los activos de Android). Ten en cuenta que, al abrir bases de datos desde recursos de solo lectura, debes asegurarte de añadir también el atributo QSQLITE_OPEN_READONLY. De lo contrario, no se podrá abrir.
QSQLITE_OPEN_READONLYSi se establece, la base de datos se abre en modo de solo lectura, lo que provocará un error si no existe ninguna base de datos. De lo contrario, la base de datos se abrirá en modo de lectura y escritura y se creará si el archivo de la base de datos aún no existe (por defecto).
QSQLITE_OPEN_URIEl nombre de archivo proporcionado se interpreta como un URI; véase SQLITE_OPEN_URI
QSQLITE_ENABLE_SHARED_CACHESi se establece, la base de datos se abre en modo de caché compartida; en caso contrario, se abre en modo de caché privada
QSQLITE_ENABLE_REGEXPSi se activa, el complemento define una función «regex» que puede utilizarse en consultas; se utiliza QRegularExpression para evaluar la consulta con expresiones regulares
QSQLITE_NO_USE_EXTENDED_RESULT_CODESDesactiva el uso de la función de códigos de resultado ampliados en SQLite
QSQLITE_ENABLE_NON_ASCII_CASE_FOLDINGSi se activa, el complemento sustituye las funciones «lower» y «upper» por las funciones de QString para garantizar la conversión correcta de mayúsculas y minúsculas de los caracteres no ASCII
QSQLITE_OPEN_NOFOLLOWSi se activa, no se permite que el nombre del archivo de la base de datos contenga un enlace simbólico

Cómo compilar el complemento QSQLITE

La versión 3 de SQLite se incluye como biblioteca de terceros en Qt. Se puede compilar pasando el parámetro « -DFEATURE_system_sqlite=OFF » a la línea de comandos « qt-cmake ».

Si no deseas utilizar la biblioteca SQLite incluida con Qt, puedes pasar -DFEATURE_system_sqlite=ON a la línea de comandos qt-cmake para utilizar las bibliotecas SQLite del sistema operativo. Se recomienda hacerlo siempre que sea posible, ya que reduce el tamaño de la instalación y elimina un componente para el que es necesario estar al tanto de los avisos de seguridad.

En Unix y macOS (sustituye $SQLITE por el directorio donde se encuentra SQLite):

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 .

En Windows (suponiendo que SQLite esté instalado en C:\SQLITE):

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 .

Activar el operador REGEXP

SQLite incluye una operación REGEXP. Sin embargo, el usuario debe proporcionar la implementación necesaria. Para mayor comodidad, se puede habilitar una implementación predeterminada mediante setting the connect option QSQLITE_ENABLE_REGEXP antes de the database connection is opened. De este modo, una instrucción SQL como «column REGEXP 'pattern'» se expande básicamente al código Qt

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

Para mejorar el rendimiento, las expresiones regulares se almacenan en caché internamente. Por defecto, el tamaño de la caché es de 25, pero se puede modificar mediante el valor de la opción. Por ejemplo, al pasar «QSQLITE_ENABLE_REGEXP=10 », el tamaño de la caché se reduce a 10.

Compatibilidad con formatos de archivo de QSQLITE

Las versiones menores de SQLite a veces rompen la compatibilidad con versiones posteriores del formato de archivo. Por ejemplo, SQLite 3.3 puede leer archivos de base de datos creados con SQLite 3.2, pero las bases de datos creadas con SQLite 3.3 no pueden ser leídas por SQLite 3.2. Consulta la documentación de SQLite y los registros de cambios para obtener información sobre la compatibilidad del formato de archivo entre versiones.

Las versiones menores de Qt suelen seguir a las versiones menores de SQLite, mientras que las versiones de parche de Qt siguen a las versiones de parche de SQLite. Por lo tanto, las versiones de parche son compatibles tanto hacia atrás como hacia adelante.

Para obligar a SQLite a utilizar un formato de archivo específico, es necesario compilar e incluir tu propio complemento de base de datos con tu propia biblioteca de SQLite, tal y como se ha ilustrado anteriormente. Se puede obligar a algunas versiones de SQLite a escribir en un formato de archivo específico configurando la definición ` SQLITE_DEFAULT_FILE_FORMAT ` al compilar SQLite.

QMIMER para Mimer SQL versión 11 y superiores

El complemento Qt Mimer SQL permite trabajar con el SGBD Mimer SQL. Mimer SQL ofrece soluciones de bases de datos relacionales de tamaño reducido, escalables y robustas que cumplen con los estándares internacionales ISO SQL. Mimer SQL está disponible en Windows, Linux, macOS y OpenVMS, así como en varias plataformas integradas como QNX, Android y Linux integrado.

Mimer SQL es totalmente compatible con Unicode. Para trabajar con datos Unicode, deben utilizarse los tipos de columna «Carácter nacional» (NCHAR), «Carácter nacional variable» (NVARCHAR) u «Objeto grande de carácter nacional» (NCLOB). Para obtener más información sobre Mimer SQL y Unicode, consulta https://developer.mimer.com/features/multilingual-support

Compatibilidad con marcas de tiempo

Mimer SQL no tiene en cuenta las zonas horarias y la fecha « QDateTime » se utiliza sin tener en cuenta la zona horaria en absoluto.

Nota: Esto podría cambiar en el futuro.

Compatibilidad con procedimientos almacenados de QMIMER

Mimer SQL dispone de procedimientos almacenados conformes con el estándar SQL (PSM) y el complemento es totalmente compatible con los parámetros IN, OUT e INOUT, así como con los procedimientos de conjuntos de resultados.

Ejemplo de procedimiento almacenado con parámetros INOUT y OUT:

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

Código fuente para acceder a los valores INOUT y OUT:

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

Cómo compilar el complemento QMIMER en Unix y macOS

Necesitarás los archivos de cabecera y las bibliotecas compartidas de Mimer SQL. Consíguelos instalando cualquiera de las variantes de Mimer SQL que encontrarás en https://developer.mimer.com.

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 .

Cómo compilar el complemento QMIMER en Windows

Necesitarás los archivos de cabecera y las bibliotecas compartidas de Mimer SQL. Para obtenerlos, instala cualquiera de las versiones de Mimer SQL disponibles en https://developer.mimer.com.

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 para Borland InterBase

El complemento Qt InterBase permite acceder a las bases de datos InterBase y Firebird. InterBase puede utilizarse en modo cliente/servidor o sin servidor, en cuyo caso opera con archivos locales. El archivo de la base de datos debe existir antes de que se pueda establecer una conexión. Firebird debe utilizarse con una configuración de servidor.

Ten en cuenta que InterBase requiere que especifiques la ruta completa al archivo de la base de datos, independientemente de si está almacenado localmente o en otro servidor.

Compatibilidad con marcas de tiempo

InterBase almacena las marcas de tiempo en UTC sin ninguna información sobre la zona horaria. Por este motivo, se utiliza el ` QDateTime ` sin tener en cuenta en absoluto la zona horaria.

Desde Firebird 4.0, la base de datos admite marcas de tiempo con zonas horarias. La información sobre la zona horaria se almacena por separado de la marca de tiempo, de modo que pueda recuperarse correctamente más adelante. Consulte la documentación de Firebird para obtener más información sobre el manejo de las marcas de tiempo.

Opciones de conexión

El complemento Qt para Borland InterBase admite las siguientes opciones de conexión:

AtributoValor posible
ISC_DPB_SQL_ROLE_NAMEEspecifica el nombre del rol de inicio de sesión

Cómo compilar el complemento QIBASE

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

Para compilar este complemento, necesitas los encabezados y las bibliotecas de desarrollo de InterBase/Firebird.

Debido a incompatibilidades de licencia con la GPL, los usuarios de la edición de código abierto de Qt no pueden vincular este complemento a las ediciones comerciales de InterBase. Utiliza Firebird o la edición gratuita de InterBase.

Procedimientos almacenados de QIBASE

InterBase/Firebird devuelven los valores OUT como conjunto de resultados, por lo que, al llamar a un procedimiento almacenado, solo es necesario vincular los valores IN mediante QSqlQuery::bindValue(). Los valores RETURN/OUT se pueden recuperar mediante QSqlQuery::value(). Ejemplo:

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

Cómo compilar el complemento QIBASE en Unix y macOS

En lo que sigue se da por hecho que InterBase o Firebird están instalados en /opt/interbase:

Si utilizas InterBase:

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 .

Si lo prefieres, utiliza las variables de CMake Interbase_INCLUDE_DIR y Interbase_LIBRARY para especificar directamente la ruta de inclusión y la biblioteca.

Cómo compilar el complemento QIBASE en Windows

En lo que sigue se da por hecho que InterBase o Firebird están instalados en C:\interbase:

Si utilizas InterBase:

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 .

Si lo prefieres, utiliza las variables de CMake Interbase_INCLUDE_DIR y Interbase_LIBRARY para especificar directamente la ruta de inclusión y la biblioteca.

Ten en cuenta que C:\interbase\bin debe estar en PATH.

Solución de problemas

Siempre debes utilizar bibliotecas de cliente que se hayan compilado con el mismo compilador que estás utilizando para tu proyecto. Si no puedes conseguir una distribución de código fuente para compilar tú mismo las bibliotecas de cliente, debes asegurarte de que la biblioteca precompilada sea compatible con tu compilador; de lo contrario, obtendrás numerosos errores de «símbolos no definidos».

Si la compilación de un complemento se realiza correctamente pero después no se puede cargar, sigue los siguientes pasos para averiguar cuál es el problema:

  1. Asegúrate de que el complemento se encuentra en el directorio correcto. Puedes utilizar QApplication::libraryPaths() para determinar dónde busca Qt los complementos.
  2. Asegúrate de que las bibliotecas de cliente del SGBD estén disponibles en el sistema. En Unix, ejecuta el comando ` ldd ` y pasa el nombre del complemento como parámetro, por ejemplo, ` ldd libqsqlmysql.so`. Recibirás una advertencia si no se encuentra alguna de las bibliotecas de cliente. En Windows, puede utilizar el Dependency Walker de Visual Studio o la interfaz gráfica Dependencies para averiguar cuáles son las bibliotecas dependientes. Con Qt Creator, puede actualizar la variable de entorno ` PATH ` en la sección «Ejecutar» del panel «Proyecto» para incluir la ruta a la carpeta que contiene las bibliotecas cliente.
  3. Si utilizas MSVC, asegúrate también de que el complemento se haya compilado con el tipo de compilación correcto. Debido a que MSVC utiliza entornos de ejecución diferentes para las versiones de depuración y de lanzamiento, una compilación de Qt en modo de depuración no puede cargar un complemento de Qt en modo de lanzamiento, y viceversa.
  4. Ejecuta el ejecutable de Qt compilado con la variable de entorno QT_DEBUG_PLUGINS configurada para obtener una salida de depuración muy detallada al cargar los complementos.
  5. Para recuperar posibles mensajes de depuración del subsistema SQL, habilita la salida configurando la variable de entorno « QT_LOGGING_RULES » como « qt.sql.*.debug=true ». No olvides habilitar la consola cuando trabajes en Windows. Consulta Logging Rules para obtener una explicación más detallada sobre cómo configurar las reglas de registro.

Asegúrate de haber seguido la guía sobre cómo implementar complementos.

Cómo escribir su propio controlador de base de datos

QSqlDatabase se encarga de cargar y gestionar los complementos de controladores de bases de datos. Cuando se añade una base de datos (véase QSqlDatabase::addDatabase()), se carga el complemento de controlador adecuado (utilizando QSqlDriverPlugin). QSqlDatabase depende del complemento de controlador para proporcionar interfaces para QSqlDriver y QSqlResult.

QSqlDriver es una clase base abstracta que define la funcionalidad de un controlador de base de datos SQL. Esto incluye funciones como QSqlDriver::open() y QSqlDriver::close(). QSqlDriver se encarga de conectarse a una base de datos, establecer el entorno adecuado, etc. Además, QSqlDriver puede crear objetos QSqlQuery adecuados para la API concreta de la base de datos. QSqlDatabase reenvía muchas de sus llamadas a funciones directamente a QSqlDriver, que proporciona la implementación concreta.

QSqlResult es una clase base abstracta que define la funcionalidad de una consulta a una base de datos SQL. Esto incluye sentencias como SELECT, UPDATE y ALTER TABLE . QSqlResult contiene funciones como QSqlResult::next() y QSqlResult::value(). QSqlResult se encarga de enviar consultas a la base de datos, devolver los datos resultantes, etc. QSqlQuery reenvía muchas de sus llamadas a funciones directamente a QSqlResult, que proporciona la implementación concreta.

QSqlDriver y QSqlResult están estrechamente relacionadas. Al implementar un controlador Qt SQL, es necesario crear subclases de ambas clases e implementar los métodos virtuales abstractos de cada una de ellas.

Para implementar un controlador Qt SQL como complemento (de modo que la biblioteca Qt lo reconozca y lo cargue en tiempo de ejecución), el controlador debe utilizar la macro Q_PLUGIN_METADATA(). Consulta «Cómo crear complementos de Qt» para obtener más información al respecto. También puedes ver cómo se hace esto en los complementos SQL que se incluyen con Qt en QTDIR/qtbase/src/plugins/sqldrivers.

El siguiente código puede utilizarse como esqueleto para un controlador SQL:

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

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