qt/qtbase/src/plugins/sqldrivers/firebird/qsql_firebird.cpp

Revision control

Copy as Markdown

// Copyright (C) 2026 The Qt Company Ltd.
// Copyright (C) 2026 Andreas Bacher
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qsql_firebird_p.h"
#include "qsql_firebird_driver_p.h"
#include "qsql_firebird_helpers_p.h"
#include "qsql_firebird_result_p.h"
#include <QtCore/qdatetime.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qvariant.h>
#include <QtSql/qsqlfield.h>
#include <QtSql/qsqlindex.h>
#include <QtSql/qsqlquery.h>
#include <QtSql/qsqlrecord.h>
#include <ibase.h> // DPB/TPB constants, isc_event_block
#include <firebird/Interface.h>
#include <algorithm>
#include <atomic>
#include <cstring>
#include <mutex>
/* The driver uses the Firebird 4.0 object-oriented C++ API. Configure-time
detection (FindFirebird.cmake with Firebird_MINIMUM_API_VERSION) already
disables the sql-firebird feature for older clients; this static_assert is a
backstop for out-of-tree builds that bypass configure. */
static_assert(FB_API_VER >= 40,
"The QFIREBIRD driver requires Firebird 4.0 or later client libraries.");
/* Error handling is built on the API's ThrowStatusWrapper/FbException model,
so the driver cannot be compiled without exceptions. Configure-time detection
already disables the sql-firebird feature in a -no-exceptions build; this is
the backstop for out-of-tree builds that bypass configure. */
#ifdef QT_NO_EXCEPTIONS
# error The QFIREBIRD driver requires C++ exception support
#endif
QT_BEGIN_NAMESPACE
// Firebird OO API types are used throughout; avoid full Firebird:: qualification.
using namespace Firebird;
using namespace Qt::StringLiterals;
/*! \internal
Event notification support (OO API)
Follows the pattern from Firebird's examples/interfaces/08.events.cpp:
- The subscription IS the callback (IEventCallback), ref-counted
- eventCallbackFunction (Firebird thread) memcpy's result + posts; it holds
a self-reference for its duration and a mutex around the buffer write and
the driver-pointer use (stop() clears the pointer under the same mutex,
so a returned stop() guarantees no callback still touches the driver)
- isc_event_counts and re-registration happen on the main thread; the read
takes the same mutex (re-arm does not — see qHandleEventNotification)
- Only release(), never cancel(), is used on IEvents
*/
class QFirebirdEventSubscription
: public IEventCallbackImpl<QFirebirdEventSubscription, CheckStatusWrapper>
{
public:
QFirebirdEventSubscription(QFirebirdDriver *drv, IAttachment *att,
const QString &eventName)
: name(eventName), driver(drv), attachment(att)
{
bufferLength = static_cast<unsigned>(
isc_event_block(&eventBuffer, &resultBuffer,
1, eventName.toUtf8().constData()));
}
// IRefCounted
void addRef() override { ++refCount; }
int release() override {
if (--refCount == 0) {
delete this;
return 0;
}
return 1;
}
/*! \internal
IEventCallback — called on Firebird's internal event thread.
Holds a self-reference for the duration so the owner thread's stop()/
release() cannot delete the subscription (and free resultBuffer) while
this callback is still running. The mutex serialises the resultBuffer
write against qHandleEventNotification's read on the owner thread, and
covers the driver-pointer use: stop() clears the pointer under the same
mutex, so the driver cannot be destroyed between the read and the
invokeMethod. The queued invokeMethod only posts an event — it neither
blocks nor re-enters Firebird — so holding the mutex across it cannot
deadlock with the re-arm lock-ordering constraint.
*/
void eventCallbackFunction(unsigned length, const unsigned char *data) override
{
addRef();
{
std::lock_guard<std::mutex> lock(mutex);
/* Clamp to the registered buffer size: fbclient should never
deliver a longer block, but the length arrives off the wire. */
length = std::min(length, bufferLength);
if (length > 0)
memcpy(resultBuffer, data, length);
++counter;
if (driver) {
QMetaObject::invokeMethod(driver, "qHandleEventNotification",
Qt::QueuedConnection, Q_ARG(QString, name));
}
}
release();
}
/*! \internal
Disconnect from the driver so the callback no longer posts to it,
and release the IEvents handle (no cancel — avoids Firebird internal
lock contention that causes crashes on Windows). Clearing the pointer
under the mutex waits out any in-flight callback that already loaded it,
so after stop() returns the driver can be destroyed safely.
*/
void stop()
{
{
std::lock_guard<std::mutex> lock(mutex);
driver = nullptr;
}
if (events) {
events->release();
events = nullptr;
}
}
QString name;
QFirebirdDriver *driver = nullptr; // guarded by mutex (written on the owner thread,
// read on the Firebird event thread)
IAttachment *attachment = nullptr;
IEvents *events = nullptr;
ISC_UCHAR *eventBuffer = nullptr;
ISC_UCHAR *resultBuffer = nullptr;
unsigned bufferLength = 0;
bool first = true;
std::atomic<int> counter = 0;
std::mutex mutex; // serialises resultBuffer access with the FB event thread
private:
~QFirebirdEventSubscription()
{
if (events)
events->release();
if (eventBuffer)
isc_free(reinterpret_cast<char *>(eventBuffer));
if (resultBuffer)
isc_free(reinterpret_cast<char *>(resultBuffer));
}
std::atomic<int> refCount = 0;
};
// QFirebirdDriverPrivate
void QFirebirdDriverPrivate::setFbError(const QString &context, QSqlError::ErrorType type)
{
Q_Q(QFirebirdDriver);
auto err = fbError(master, iStatus, type);
q->setLastError(QSqlError(context + u": " + err.databaseText(),
{}, err.type(), err.nativeErrorCode()));
iStatus->init();
}
bool QFirebirdDriverPrivate::finishTransaction(TxnEnd end)
{
Q_Q(QFirebirdDriver);
if (!iTrans) {
q->setLastError(QSqlError(u"No active transaction"_s, {},
QSqlError::TransactionError));
return false;
}
try {
ThrowStatusWrapper st(iStatus);
finishAndClear(st, iTrans, end);
} catch (const FbException &e) {
q->setLastError(fbError(master, e.getStatus(), QSqlError::TransactionError));
iStatus->init();
return false;
}
return true;
}
// QFirebirdDriver
QFirebirdDriver::QFirebirdDriver(QObject *parent)
: QSqlDriver(*new QFirebirdDriverPrivate, parent)
{
}
QFirebirdDriver::~QFirebirdDriver()
{
close();
/* Neutralise any results that outlive this driver: once the driver private
below is freed, their drv_d_func() would dangle. After this, cleanup()
on those results becomes a no-op (see QFirebirdResultPrivate::cleanup()). */
Q_D(QFirebirdDriver);
for (QFirebirdResultPrivate *r : std::as_const(d->activeResults))
r->driverAlive = false;
d->activeResults.clear();
}
bool QFirebirdDriver::hasFeature(DriverFeature feature) const
{
Q_D(const QFirebirdDriver);
switch (feature) {
case Transactions:
case Unicode:
case BLOB:
case PreparedQueries:
case PositionalPlaceholders:
case LowPrecisionNumbers:
case EventNotifications:
case BatchOperations:
case FinishQuery: // QSqlQuery::finish() releases the cursor, keeps the prepare
case CancelQuery: // cancelQuery() raises fb_cancel_raise from another thread
return true;
case QuerySize:
/* Firebird cursors cannot report cardinality without fetching, so the
count is only available when the opt-in client-side row cache
(connect option FB_SCROLLABLE_CACHE=1) buffers the result set anyway
— see QFirebirdResult::size(). */
return d->cacheScrollableResults;
case NamedPlaceholders:
case LastInsertId:
case SimpleLocking:
case MultipleResultSets:
return false;
}
return false;
}
/*! \internal
Connection options recognized by open(), mapped to their DPB tag and value
kind. lc_ctype and the SQL dialect are intentionally NOT exposed: the driver
hardcodes UTF-8 and dialect 3 and decodes results on that basis. Integer
kinds also cover the boolean DPB options (pass 0/1).
*/
namespace {
enum DpbValueKind : quint8 { DpbString, DpbInt };
struct DpbOption {
QLatin1StringView key;
unsigned char tag;
DpbValueKind kind;
};
constexpr DpbOption dpbOptionTable[] = {
{ "ISC_DPB_SQL_ROLE_NAME"_L1, isc_dpb_sql_role_name, DpbString },
{ "ISC_DPB_SESSION_TIME_ZONE"_L1, isc_dpb_session_time_zone, DpbString },
{ "ISC_DPB_NUM_BUFFERS"_L1, isc_dpb_num_buffers, DpbInt },
{ "ISC_DPB_CONNECT_TIMEOUT"_L1, isc_dpb_connect_timeout, DpbInt },
{ "ISC_DPB_DUMMY_PACKET_INTERVAL"_L1, isc_dpb_dummy_packet_interval, DpbInt },
{ "ISC_DPB_NO_GARBAGE_COLLECT"_L1, isc_dpb_no_garbage_collect, DpbInt },
{ "ISC_DPB_NO_DB_TRIGGERS"_L1, isc_dpb_no_db_triggers, DpbInt },
};
/*! \internal
Options that map to real DPB tags but which the driver sets itself and will
not let the caller override: the connection charset is fixed to UTF-8 and the
SQL dialect to 3, because results are decoded on that basis. Recognized here
so they get an accurate message instead of being reported as "unknown".
*/
constexpr QLatin1StringView driverManagedKeys[] = {
"ISC_DPB_LC_CTYPE"_L1,
"ISC_DPB_SQL_DIALECT"_L1,
};
} // namespace
bool QFirebirdDriver::open(const QString &db,
const QString &user,
const QString &password,
const QString &host,
int port,
const QString &connOpts)
{
Q_D(QFirebirdDriver);
close();
// Build the connection string: host/port:database (Firebird uses / between host and port)
QString connStr;
if (!host.isEmpty()) {
connStr = host;
if (port > 0)
connStr += u'/' + QString::number(port);
connStr += u':';
}
connStr += db;
// Build DPB using IXpbBuilder
IUtil *util = d->master->getUtilInterface();
ThrowStatusWrapper st(d->iStatus);
try {
// Disposed by its guard on scope exit (normal return or the catch below).
FbGuard<IXpbBuilder> dpb(util->getXpbBuilder(&st, IXpbBuilder::DPB, nullptr, 0),
fbDispose<IXpbBuilder>);
dpb->insertString(&st, isc_dpb_user_name,
user.toUtf8().constData());
dpb->insertString(&st, isc_dpb_password,
password.toUtf8().constData());
// UTF-8 connection charset
dpb->insertString(&st, isc_dpb_lc_ctype, "UTF8");
/* Apply recognized connection options (semicolon-separated key=value).
Unknown or malformed options are warned about rather than silently
ignored. */
for (const auto &opt : QStringView(connOpts).split(u';', Qt::SkipEmptyParts)) {
const auto kv = opt.trimmed();
const auto eqIdx = kv.indexOf(u'=');
if (eqIdx < 0) {
qCWarning(lcFirebird) << "QFirebirdDriver: ignoring malformed connection option"
<< kv.toString();
continue;
}
const QString key = kv.left(eqIdx).trimmed().toString().toUpper();
const QString value = kv.mid(eqIdx + 1).trimmed().toString();
/* Driver-level option (not a DPB tag): enable client-side row
caching for scrollable results. Handled before the DPB lookup so
it isn't reported as "unknown". */
if (key == "FB_SCROLLABLE_CACHE"_L1) {
d->cacheScrollableResults = (value != "0"_L1)
&& (value.compare("false"_L1, Qt::CaseInsensitive) != 0);
continue;
}
/* Driver-managed options: silently accept a value that matches what
the driver already enforces (e.g. ISC_DPB_LC_CTYPE=UTF8); warn
only when the caller asks for something the driver won't honor. */
bool managed = false;
for (const auto &k : driverManagedKeys) {
if (key == k) {
managed = true;
break;
}
}
if (managed) {
const bool isLcCtype = (key == "ISC_DPB_LC_CTYPE"_L1);
const bool matchesDefault = isLcCtype
? (value.compare("UTF8"_L1, Qt::CaseInsensitive) == 0
|| value.compare("UTF-8"_L1, Qt::CaseInsensitive) == 0)
: (value == "3"_L1);
if (!matchesDefault) {
qCWarning(lcFirebird) << "QFirebirdDriver: connection option" << key
<< "is managed by the driver and cannot be overridden"
" (charset is fixed to UTF-8, dialect to 3); ignoring"
<< value;
}
continue;
}
const DpbOption *match = nullptr;
for (const auto &o : dpbOptionTable) {
if (key == o.key) {
match = &o;
break;
}
}
if (!match) {
qCWarning(lcFirebird) << "QFirebirdDriver: ignoring unknown connection option" << key;
continue;
}
if (match->kind == DpbString) {
QByteArray s = value.toUtf8();
if (match->tag == isc_dpb_sql_role_name)
s.truncate(255);
dpb->insertString(&st, match->tag, s.constData());
} else {
bool ok = false;
const int n = value.toInt(&ok);
if (!ok) {
qCWarning(lcFirebird) << "QFirebirdDriver: non-integer value for connection option"
<< key << ':' << value;
continue;
}
dpb->insertInt(&st, match->tag, n);
}
}
const unsigned char *dpbData = dpb->getBuffer(&st);
unsigned dpbLen = dpb->getBufferLength(&st);
IAttachment *att = d->master->getDispatcher()->attachDatabase(
&st, connStr.toUtf8().constData(), dpbLen, dpbData);
/* Publish under the mutex so a concurrent cancelQuery() never sees a
half-initialised attachment. */
{
const std::lock_guard<std::mutex> lock(d->attMutex);
d->iAtt = att;
}
} catch (const FbException &e) {
setLastError(fbError(d->master, e.getStatus(), QSqlError::ConnectionError));
d->iStatus->init();
setOpenError(true);
return false;
}
setOpen(true);
setOpenError(false);
return true;
}
void QFirebirdDriver::close()
{
Q_D(QFirebirdDriver);
if (!isOpen())
return;
CheckStatusWrapper st(d->iStatus);
// Cancel all event subscriptions before detaching
for (auto *sub : std::as_const(d->eventSubscriptions)) {
sub->stop();
sub->release();
}
d->eventSubscriptions.clear();
if (d->iTrans) {
try {
ThrowStatusWrapper tsw(d->iStatus);
d->iTrans->rollback(&tsw);
} catch (...) {
d->iTrans->release();
}
d->iTrans = nullptr;
}
if (d->iAtt) {
/* Withdraw the attachment from cancelQuery()'s reach before detaching:
once the lock is dropped, a concurrent cancelQuery() sees nullptr,
and one already inside cancelOperation() has finished (it holds the
mutex for the duration of the call). */
IAttachment *att;
{
const std::lock_guard<std::mutex> lock(d->attMutex);
att = d->iAtt;
d->iAtt = nullptr;
}
try {
ThrowStatusWrapper tsw(d->iStatus);
att->detach(&tsw);
} catch (...) {
att->release();
}
}
d->iStatus->init();
setOpen(false);
setOpenError(false);
}
QSqlResult *QFirebirdDriver::createResult() const
{
return new QFirebirdResult(this);
}
/*! \internal
Cross-thread cancellation (QSqlDriver::CancelQuery). This runs on a
DIFFERENT thread than the one executing the query, so it must not touch any
driver state beyond the mutex-guarded attachment: no setLastError, and not
iStatus (the executing thread owns it) — a private status object is used
instead. fb_cancel_raise asks the engine to abort the current operation at
its next cancellation point; the executing call then fails with
isc_cancelled, which the normal FbException -> QSqlError path reports on the
executing thread. The attachment itself stays open and usable.
*/
bool QFirebirdDriver::cancelQuery()
{
Q_D(QFirebirdDriver);
const std::lock_guard<std::mutex> lock(d->attMutex);
if (!d->iAtt)
return false;
FbGuard<IStatus> status(d->master->getStatus(), fbDispose<IStatus>);
try {
ThrowStatusWrapper st(status.get());
d->iAtt->cancelOperation(&st, fb_cancel_raise);
} catch (const FbException &e) {
const auto err = fbError(d->master, e.getStatus(), QSqlError::UnknownError);
qCWarning(lcFirebird) << "cancelQuery:" << fbErrorLog(err);
return false;
}
return true;
}
bool QFirebirdDriver::beginTransaction()
{
Q_D(QFirebirdDriver);
/* QSqlDatabase::transaction() forwards here after only a feature check, so
guard against a closed (or failed-to-open) database: without it the
start call below would dereference a null attachment. */
if (!isOpen() || isOpenError()) {
setLastError(QSqlError(u"Database not open"_s, {},
QSqlError::TransactionError));
return false;
}
if (d->iTrans) {
setLastError(QSqlError(u"Transaction already active"_s, {},
QSqlError::TransactionError));
return false;
}
try {
ThrowStatusWrapper st(d->iStatus);
d->iTrans = startDefaultTransaction(d->iAtt, st, TxnWait::NoWait);
} catch (const FbException &e) {
setLastError(fbError(d->master, e.getStatus(), QSqlError::TransactionError));
d->iStatus->init();
return false;
}
return true;
}
bool QFirebirdDriver::commitTransaction()
{
Q_D(QFirebirdDriver);
return d->finishTransaction(TxnEnd::Commit);
}
bool QFirebirdDriver::rollbackTransaction()
{
Q_D(QFirebirdDriver);
return d->finishTransaction(TxnEnd::Rollback);
}
QVariant QFirebirdDriver::handle() const
{
Q_D(const QFirebirdDriver);
return QVariant::fromValue(d->iAtt);
}
QString QFirebirdDriver::escapeIdentifier(const QString &identifier,
IdentifierType /*type*/) const
{
QString res = identifier;
if (!identifier.isEmpty() && !identifier.startsWith(u'"') && !identifier.endsWith(u'"')) {
res.replace(u'"', u"\"\""_s);
res.replace(u'.', u"\".\""_s);
res = u'"' + res + u'"';
}
return res;
}
QString QFirebirdDriver::formatValue(const QSqlField &field, bool trimStrings) const
{
switch (field.metaType().id()) {
case QMetaType::QDateTime: {
/* A plain TIMESTAMP is naive: emit the QDateTime's own wall-clock
date/time components verbatim (no conversion), matching the
bound-parameter path (encodeQDateTime). */
const QDateTime dt = field.value().toDateTime();
if (dt.isValid())
return dt.toString(u"''yyyy-MM-dd HH:mm:ss.zzz''");
return u"NULL"_s;
}
case QMetaType::QTime: {
const QTime t = field.value().toTime();
if (t.isValid())
return t.toString(u"''HH:mm:ss.zzz''");
return u"NULL"_s;
}
case QMetaType::QDate: {
const QDate d = field.value().toDate();
if (d.isValid())
return d.toString(u"''yyyy-MM-dd''");
return u"NULL"_s;
}
default:
return QSqlDriver::formatValue(field, trimStrings);
}
}
int QFirebirdDriver::maximumIdentifierLength(IdentifierType /*type*/) const
{
// Firebird 4.0+ raised the maximum identifier length to 63 characters
return 63;
}
// Schema introspection helpers
/*! \internal
setLastError only mutates the driver's error state, which is logically
mutable from the const introspection methods — hence the const_cast.
*/
QSqlQuery QFirebirdDriver::execMetadataQuery(const QString &sql,
const QVariantList &binds) const
{
QSqlQuery q(createResult());
q.prepare(sql);
for (const QVariant &v : binds)
q.addBindValue(v);
if (!q.exec()) {
qCWarning(lcFirebird) << "metadata query failed:"
<< fbErrorLog(q.lastError()) << "SQL:" << sql;
const_cast<QFirebirdDriver *>(this)->setLastError(q.lastError());
}
return q;
}
QStringList QFirebirdDriver::tables(QSql::TableType type) const
{
QStringList result;
if (!isOpen())
return result;
QString filter;
if (type == QSql::SystemTables) {
filter = u"WHERE RDB$SYSTEM_FLAG != 0"_s;
} else if (type == (QSql::SystemTables | QSql::Views)) {
filter = u"WHERE RDB$SYSTEM_FLAG != 0 OR RDB$VIEW_SOURCE IS NOT NULL"_s;
} else {
QStringList conditions;
if (!(type & QSql::SystemTables))
conditions << u"RDB$SYSTEM_FLAG = 0"_s;
if (!(type & QSql::Views))
conditions << u"RDB$VIEW_SOURCE IS NULL"_s;
if (!(type & QSql::Tables))
conditions << u"RDB$VIEW_SOURCE IS NOT NULL"_s;
if (!conditions.isEmpty())
filter = u"WHERE "_s + conditions.join(u" AND "_s);
}
QSqlQuery q = execMetadataQuery(
u"SELECT TRIM(RDB$RELATION_NAME) FROM RDB$RELATIONS "_s
+ filter + u" ORDER BY RDB$RELATION_NAME"_s);
while (q.next())
result.append(q.value(0).toString());
return result;
}
QSqlRecord QFirebirdDriver::record(const QString &tableName) const
{
QSqlRecord rec;
if (!isOpen())
return rec;
/* A quoted (delimited) identifier is case-sensitive: strip its delimiters and
match RDB$RELATION_NAME verbatim. An unquoted name is passed through as-is
(stripDelimiters() is a no-op for it); the caller is responsible for the
upper-case folding Firebird applies to unquoted identifiers. This mirrors
the QIBASE driver's behaviour. */
const QString table = stripDelimiters(tableName, QSqlDriver::TableName);
/* RDB$FIELDS.RDB$FIELD_TYPE stores the BLR type codes (blr_short, blr_long, …).
Map them to Qt types. */
const QString sql =
u"SELECT TRIM(f.RDB$FIELD_NAME), fld.RDB$FIELD_TYPE, fld.RDB$FIELD_SUB_TYPE,"
u" fld.RDB$FIELD_SCALE, fld.RDB$CHARACTER_LENGTH, f.RDB$NULL_FLAG,"
u" fld.RDB$FIELD_PRECISION, fld.RDB$FIELD_LENGTH"
u" FROM RDB$RELATION_FIELDS f"
u" JOIN RDB$FIELDS fld ON fld.RDB$FIELD_NAME = f.RDB$FIELD_SOURCE"
u" WHERE TRIM(f.RDB$RELATION_NAME) = ?"
u" ORDER BY f.RDB$FIELD_POSITION"_s;
QSqlQuery q = execMetadataQuery(sql, {table});
while (q.next()) {
QString name = q.value(0).toString().trimmed();
int rdbType = q.value(1).toInt();
int subType = q.value(2).toInt();
int scale = q.value(3).toInt(); // negative for NUMERIC/DECIMAL
int charLen = q.value(4).toInt();
bool notNull = (q.value(5).toInt() == 1);
int precision = q.value(6).toInt(); // total digits for NUMERIC
int byteLen = q.value(7).toInt();
QMetaType::Type qtType = blrTypeToQt(static_cast<unsigned char>(rdbType), scale < 0);
QSqlField fld(name, QMetaType(qtType));
fld.setRequired(notNull);
// Set length and precision for NUMERIC/DECIMAL; character length for text types
if (scale < 0 && precision > 0) {
fld.setLength(precision);
fld.setPrecision(-scale);
} else if (rdbType == blr_text || rdbType == blr_varying) { // CHAR / VARCHAR
fld.setLength(charLen > 0 ? charLen : byteLen);
}
Q_UNUSED(subType)
rec.append(fld);
}
return rec;
}
QSqlIndex QFirebirdDriver::primaryIndex(const QString &tableName) const
{
QSqlIndex index;
if (!isOpen())
return index;
// See record(): strip a quoted identifier and match RDB$RELATION_NAME verbatim.
const QString table = stripDelimiters(tableName, QSqlDriver::TableName);
const QString sql =
u"SELECT TRIM(s.RDB$FIELD_NAME)"
u" FROM RDB$RELATION_CONSTRAINTS c"
u" JOIN RDB$INDEX_SEGMENTS s ON s.RDB$INDEX_NAME = c.RDB$INDEX_NAME"
u" WHERE c.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY'"
u" AND TRIM(c.RDB$RELATION_NAME) = ?"
u" ORDER BY s.RDB$FIELD_POSITION"_s;
QSqlQuery q = execMetadataQuery(sql, {table});
QSqlRecord rec = record(tableName);
while (q.next()) {
QString col = q.value(0).toString().trimmed();
index.append(rec.field(col));
}
return index;
}
// Event notification API
bool QFirebirdDriver::subscribeToNotification(const QString &name)
{
Q_D(QFirebirdDriver);
if (!isOpen()) {
qCWarning(lcFirebird, "QFirebirdDriver::subscribeToNotification: database not open.");
return false;
}
if (d->eventSubscriptions.contains(name)) {
qCWarning(lcFirebird,
"QFirebirdDriver::subscribeToNotification: already subscribed to '%ls'.",
qUtf16Printable(name));
return false;
}
auto *sub = new QFirebirdEventSubscription(this, d->iAtt, name);
sub->addRef(); // our reference
try {
ThrowStatusWrapper csw(d->iStatus);
sub->events = d->iAtt->queEvents(&csw, sub,
sub->bufferLength, sub->eventBuffer);
} catch (const FbException &e) {
sub->release();
auto err = fbError(d->master, e.getStatus(), QSqlError::ConnectionError);
setLastError(QSqlError(
tr("Could not subscribe to event notifications for %1.").arg(name),
err.databaseText(), err.type(), err.nativeErrorCode()));
return false;
}
d->eventSubscriptions.insert(name, sub);
return true;
}
bool QFirebirdDriver::unsubscribeFromNotification(const QString &name)
{
Q_D(QFirebirdDriver);
if (!isOpen()) {
qCWarning(lcFirebird, "QFirebirdDriver::unsubscribeFromNotification: database not open.");
return false;
}
if (!d->eventSubscriptions.contains(name)) {
qCWarning(lcFirebird,
"QFirebirdDriver::unsubscribeFromNotification: not subscribed to '%ls'.",
qUtf16Printable(name));
return false;
}
QFirebirdEventSubscription *sub = d->eventSubscriptions.take(name);
sub->stop();
sub->release();
return true;
}
QStringList QFirebirdDriver::subscribedToNotifications() const
{
Q_D(const QFirebirdDriver);
return QStringList(d->eventSubscriptions.keys());
}
void QFirebirdDriver::qHandleEventNotification(const QString &name)
{
Q_D(QFirebirdDriver);
QFirebirdEventSubscription *sub = d->eventSubscriptions.value(name, nullptr);
if (!sub || sub->counter.load(std::memory_order_relaxed) == 0)
return; // already unsubscribed or spurious call
/* isc_event_counts writes one counter per event registered with isc_event_block.
Each QFirebirdEventSubscription registers exactly one event name. */
static constexpr int maxEventNamesPerSubscription = 1;
ISC_ULONG counts[maxEventNamesPerSubscription] = {};
{
/* Serialise the resultBuffer read against the Firebird event thread's
memcpy in eventCallbackFunction — the only cross-thread buffer access. */
std::lock_guard<std::mutex> lock(sub->mutex);
isc_event_counts(counts, static_cast<ISC_USHORT>(sub->bufferLength),
sub->eventBuffer, sub->resultBuffer);
sub->counter.store(0, std::memory_order_relaxed);
}
/* Re-arm: queEvents is one-shot. Release the old IEvents handle and
re-register using the updated eventBuffer as the new baseline. This runs
OUTSIDE sub->mutex on purpose: queEvents takes Firebird's internal event
lock, which the event thread also holds while calling back into us, so
holding our mutex across queEvents could deadlock. No callback can write
resultBuffer between the read above and this re-arm (queEvents is
one-shot), so the buffer stays stable in the gap. */
IEvents *old = sub->events;
sub->events = nullptr;
IStatus *s = d->master->getStatus();
ThrowStatusWrapper csw(s);
try {
sub->events = sub->attachment->queEvents(&csw, sub,
sub->bufferLength, sub->eventBuffer);
} catch (const FbException &e) {
const auto err = fbError(d->master, e.getStatus(), QSqlError::ConnectionError);
qCWarning(lcFirebird) << "qHandleEventNotification: re-arm failed for"
<< name << ':' << fbErrorLog(err);
} catch (...) {
qCWarning(lcFirebird, "qHandleEventNotification: unexpected exception re-arming '%ls'",
qUtf16Printable(name));
}
if (old)
old->release();
s->dispose();
/* Suppress the first callback (initial registration baseline). Update the
subscription state BEFORE emitting: a directly-connected slot may
unsubscribe, releasing the subscription, so sub must not be touched
after the emit. */
const bool suppress = sub->first;
sub->first = false;
if (counts[0] > 0 && !suppress)
emit notification(name, QSqlDriver::UnknownSource, QVariant());
}
QT_END_NAMESPACE