qsql_firebird_result.cpp

Go to the documentation of this file.

// 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_result_p.h"
 
#include "qsql_firebird_array_p.h"
#include "qsql_firebird_helpers_p.h"
 
#include <QtCore/qvarlengtharray.h>
#include <QtSql/qsqlfield.h>
 
#include <algorithm>
#include <cstring>
#include <limits>
 
QT_BEGIN_NAMESPACE
 
// Firebird OO API types are used throughout; avoid full Firebird:: qualification.
using namespace Firebird;
 
using namespace Qt::StringLiterals;
 
//  Helpers used only by the result implementation
 
// Build columns metadata from IMessageMetadata
static QList<ColumnInfo> buildColumns(IMessageMetadata *meta, ThrowStatusWrapper &st)
{
    QList<ColumnInfo> cols;
    unsigned count = meta->getCount(&st);
    cols.reserve(count);
    for (unsigned i = 0; i < count; ++i) {
        ColumnInfo ci;
        ci.name       = QString::fromUtf8(meta->getAlias(&st, i));
        if (ci.name.isEmpty())
            ci.name   = QString::fromUtf8(meta->getField(&st, i));
        ci.relation   = QString::fromUtf8(meta->getRelation(&st, i));
        ci.field      = QString::fromUtf8(meta->getField(&st, i));
        ci.fbType     = static_cast<int>(meta->getType(&st, i));
        ci.fbSubType  = meta->getSubType(&st, i);
        ci.scale      = meta->getScale(&st, i);
        ci.length     = meta->getLength(&st, i);
        ci.offset     = meta->getOffset(&st, i);
        ci.nullOffset = meta->getNullOffset(&st, i);
        ci.nullable   = (meta->isNullable(&st, i) != FB_FALSE);
        ci.qtType     = fbTypeToQt(ci.fbType, ci.scale);
        cols.append(ci);
    }
    return cols;
}
 
/*! \internal
    Read a BLOB into QByteArray. Uses ThrowStatusWrapper so a read error throws
    FbException (caught by QFirebirdResult::data) instead of being swallowed and
    returning a silently truncated buffer.
*/
static QByteArray readBlob(IAttachment *att, ITransaction *tra, IStatus *st,
                           const ISC_QUAD &blobId)
{
    ThrowStatusWrapper tsw(st);
    FbGuard<IBlob> blob(att->openBlob(&tsw, tra, const_cast<ISC_QUAD *>(&blobId), 0, nullptr),
                        fbRelease<IBlob>);
    if (!blob)
        return {};
 
    QByteArray result;
    unsigned char seg[16384];
    result.reserve(sizeof(seg)); // avoid reallocations for the common small-BLOB case
    unsigned segLen = 0;
    int code;
    /* A getSegment or close failure throws; FbGuard releases the handle on the
       way out (and closeWith rethrows after releasing on a failed close). */
    do {
        code = blob->getSegment(&tsw, sizeof(seg), seg, &segLen);
        result.append(reinterpret_cast<const char *>(seg), segLen);
    } while (code == IStatus::RESULT_OK || code == IStatus::RESULT_SEGMENT);
    blob.closeWith([&](IBlob *b) { b->close(&tsw); });
    return result;
}
 
//  QFirebirdResultPrivate implementation
 
void QFirebirdResultPrivate::cleanup()
{
    /* Only touch the Firebird handles while the driver is alive AND its
       attachment is still open. If the connection was closed while this result
       was still around (QSqlDatabase::close() with a QSqlQuery in scope),
       detach() has already invalidated the statement/cursor/transaction; if the
       driver object itself was destroyed (driverAlive == false), the driver
       private is freed and must not be dereferenced at all. In either case just
       drop the now-dangling pointers. driverAlive is checked first so att()
       (which reads the driver private) is never called on a freed driver. */
    const bool attached = driverAlive && att() != nullptr;
 
    /* Close a handle gracefully while the attachment is alive (release it if the
       close throws); when detached, the engine has already invalidated it, so
       just drop the now-dangling pointer. closeFn performs the type's graceful
       shutdown (IResultSet::close, IStatement::free, ITransaction::commit). */
    auto closeHandle = [&](auto *&handle, auto closeFn) {
        if (!handle)
            return;
        if (attached) {
            try {
                ThrowStatusWrapper tsw(status());
                closeFn(handle, tsw);
            } catch (...) {
                handle->release();
            }
        }
        handle = nullptr;
    };
 
    closeHandle(cursor, [](IResultSet *c, ThrowStatusWrapper &st) { c->close(&st); });
    closeHandle(stmt, [](IStatement *s, ThrowStatusWrapper &st) { s->free(&st); });
    closeHandle(autoTrans, [](ITransaction *t, ThrowStatusWrapper &st) { t->commit(&st); });
 
    if (outMeta) {
        if (attached)
            outMeta->release();
        outMeta = nullptr;
    }
    if (inMeta) {
        if (attached)
            inMeta->release();
        inMeta = nullptr;
    }
    outBuffer.clear();
    inBuffer.clear();
    cols.clear();
    inCols.clear();
    arrayDescCache.clear();
    cachedRecord.clear();
    recordCached    = false;
    affectedRows    = -1;
    isSelect        = false;
    isProcExec      = false;
    procRowFetched  = false;
    txnOp           = TxnOp::None;
    useRowCache     = false;
    cacheComplete   = false;
    rowCache.clear();
}
 
void QFirebirdResultPrivate::closeCursor()
{
    if (!cursor)
        return;
    try {
        ThrowStatusWrapper tsw(status());
        cursor->close(&tsw);
    } catch (...) {
        cursor->release();
    }
    cursor = nullptr;
}
 
bool QFirebirdResultPrivate::ensureCachedRow(int index)
{
    if (index < 0)
        return false;
    while (!cacheComplete && rowCache.size() <= index) {
        ThrowStatusWrapper st(status());
        /* fetchNext writes into outBuffer; detaching it (COW) on the next
           iteration keeps the snapshot just appended to rowCache intact. */
        const int code = cursor->fetchNext(&st, outBuffer.data());
        if (code == IStatus::RESULT_OK)
            rowCache.append(outBuffer);
        else
            cacheComplete = true; // RESULT_NO_DATA (or non-OK): end of set
    }
    return index < rowCache.size();
}
 
QString QFirebirdResultPrivate::formatFbError(const QString &ctx)
{
    QString msg = ctx + u": " + fbErrorString(master(), status());
    status()->init();
    return msg;
}
 
ITransaction *QFirebirdResultPrivate::ensureTransaction()
{
    // User-managed transaction takes priority.
    if (drv_d_func()->iTrans)
        return drv_d_func()->iTrans;
    if (!autoTrans) {
        ThrowStatusWrapper st(status());
        autoTrans = startDefaultTransaction(att(), st, TxnWait::Wait);
    }
    return autoTrans;
}
 
//  QFirebirdResult
 
QFirebirdResult::QFirebirdResult(const QFirebirdDriver *driver)
    : QSqlResult(*new QFirebirdResultPrivate(this, driver))
{
    /* Register with the driver so it can neutralise this result if it is
       destroyed while the result is still alive (see ~QFirebirdDriver). */
    Q_D(QFirebirdResult);
    d->drv_d_func()->activeResults.append(d);
}
 
QFirebirdResult::~QFirebirdResult()
{
    Q_D(QFirebirdResult);
    d->cleanup();
}
 
void QFirebirdResult::cleanup()
{
    Q_D(QFirebirdResult);
    d->cleanup();
    setAt(QSql::BeforeFirstRow);
    setActive(false);
}
 
QVariant QFirebirdResult::handle() const
{
    Q_D(const QFirebirdResult);
    return QVariant::fromValue(d->stmt);
}
 
/*! \internal
    FinishQuery support: QSqlQuery::finish() routes here. Release the server
    cursor and the client-side row cache, but keep the prepared statement and
    its metadata caches so exec() can re-run the query without a new prepare().
    The auto transaction (if any) stays open on purpose: BLOB/array ids already
    handed to the application remain resolvable until the next exec()/cleanup().
*/
void QFirebirdResult::detachFromResultSet()
{
    Q_D(QFirebirdResult);
    d->closeCursor();
    d->rowCache.clear();
    d->cacheComplete = false;
}
 
/*! \internal
    Classify a bare transaction-control statement (COMMIT/ROLLBACK [WORK]). These
    appear in SQL scripts but cannot be executed as DSQL against the driver's
    managed transaction (Firebird rejects it with "invalid transaction handle");
    they are applied via the ITransaction API instead. COMMIT/ROLLBACK RETAIN
    are not treated specially.
*/
static TxnOp classifyTxnControl(const QString &query)
{
    QString s = query.trimmed();
    while (s.endsWith(u';'))
        s.chop(1);
    s = s.trimmed().toLower().simplified();
    if (s == "commit"_L1 || s == "commit work"_L1)
        return TxnOp::Commit;
    if (s == "rollback"_L1 || s == "rollback work"_L1)
        return TxnOp::Rollback;
    return TxnOp::None;
}
 
bool QFirebirdResult::prepare(const QString &query)
{
    Q_D(QFirebirdResult);
    cleanup();
 
    /* Bare COMMIT/ROLLBACK is handled in exec() via the transaction API; don't
       prepare it as a DSQL statement (the engine rejects executing it against a
       driver-managed transaction). */
    if (const TxnOp op = classifyTxnControl(query); op != TxnOp::None) {
        d->txnOp = op;
        setSelect(false);
        return true;
    }
 
    const QByteArray utf8 = query.toUtf8();
    try {
        ThrowStatusWrapper st(d->status());
        ITransaction *tr = d->ensureTransaction();
        d->stmt = d->att()->prepare(&st, tr, 0, utf8.constData(),
                                    SQL_DIALECT_V6,
                                    IStatement::PREPARE_PREFETCH_METADATA);
        unsigned flags = d->stmt->getFlags(&st);
        d->isSelect = (flags & IStatement::FLAG_HAS_CURSOR) != 0;
        setSelect(d->isSelect); // required: QSqlQuery::next() checks base-class isSelect()
 
        d->inMeta = d->stmt->getInputMetadata(&st);
        if (d->inMeta && d->inMeta->getCount(&st) == 0) {
            d->inMeta->release();
            d->inMeta = nullptr;
        }
        d->outMeta = d->stmt->getOutputMetadata(&st);
        if (d->outMeta) {
            if (d->outMeta->getCount(&st) == 0) {
                d->outMeta->release();
                d->outMeta = nullptr;
            } else {
                d->cols = buildColumns(d->outMeta, st);
                d->outBuffer.resize(static_cast<qsizetype>(d->outMeta->getAlignedLength(&st)));
            }
        }
        if (!d->isSelect && d->outMeta) {
            // EXECUTE PROCEDURE with RETURNS clause: expose as single-row result set
            d->isProcExec = true;
            setSelect(true);
        }
        if (d->inMeta) {
            d->inBuffer.resize(static_cast<qsizetype>(d->inMeta->getAlignedLength(&st)));
            d->inCols = buildColumns(d->inMeta, st);
        }
    } catch (const FbException &e) {
        const QSqlError err = fbError(d->master(), e.getStatus(), QSqlError::StatementError);
        qCInfo(lcFirebird) << "prepare:" << fbErrorLog(err);
        /* Release any partially-acquired statement/metadata so a failed prepare
           leaves the result non-executable (exec() guards on a null stmt) instead
           of running against a half-initialised statement. */
        d->cleanup();
        setSelect(false);
        setLastError(err);
        return false;
    }
    return true;
}
 
bool QFirebirdResultPrivate::buildInputMessage(QString &errorText)
{
    if (!inMeta)
        return true;
    inBuffer.fill(0);
    return fillInputBuffer(values, errorText);
}
 
bool QFirebirdResultPrivate::encodeScaledNumeric(char *data, int fbType, int scale,
                                                 const QVariant &val, QString &errorText)
{
    /* Numeric/decimal — store as INT64 scaled (or INT128 for very wide types).
       actual = stored * 10^scale, so stored = value / 10^scale. The scaled
       integer is derived exactly from the value's decimal-string form (see
       decimalToScaledInt64); out-of-range values are reported instead of
       silently wrapped. */
    if (fbBaseType(fbType) == SQL_INT128) {
        // Scale the string representation via IInt128::fromString with scale
        const QByteArray strVal = numericInputString(val);
        ThrowStatusWrapper innerSt(status());
        master()->getUtilInterface()->getInt128(&innerSt)->fromString(
            &innerSt, scale, strVal.constData(),
            reinterpret_cast<FB_I128 *>(data));
        return true;
    }
 
    const auto outOfRange = [&]() {
        errorText = u"Value '%1' out of range for NUMERIC/DECIMAL with scale %2"_s
                        .arg(val.toString(), QString::number(scale));
        return false;
    };
 
    qint64 iv = 0;
    const int t = val.typeId();
    if (scale < 0 && -scale < 19
        && (t == QMetaType::Int || t == QMetaType::UInt || t == QMetaType::LongLong)) {
        /* Fast path: an integral input scales with one checked multiply — no
           string round trip on the per-row bind path. */
        const qint64 v = val.toLongLong();
        const qint64 factor = pow10i(-scale);
        if (v == (std::numeric_limits<qint64>::min)()
            || qAbs(v) > (std::numeric_limits<qint64>::max)() / factor) {
            return outOfRange();
        }
        iv = v * factor;
    } else {
        const QByteArray strVal = numericInputString(val);
        if (!decimalToScaledInt64(strVal, scale, &iv)) {
            errorText = u"Cannot encode '%1' as NUMERIC/DECIMAL with scale %2"_s
                            .arg(QString::fromLatin1(strVal), QString::number(scale));
            return false;
        }
    }
 
    // One range check for the narrower targets, then a width-dispatched store.
    qint64 lo = (std::numeric_limits<qint64>::min)();
    qint64 hi = (std::numeric_limits<qint64>::max)();
    switch (fbBaseType(fbType)) {
    case SQL_SHORT:
        lo = (std::numeric_limits<qint16>::min)();
        hi = (std::numeric_limits<qint16>::max)();
        break;
    case SQL_LONG:
        lo = (std::numeric_limits<qint32>::min)();
        hi = (std::numeric_limits<qint32>::max)();
        break;
    default:
        break;
    }
    if (iv < lo || iv > hi)
        return outOfRange();
 
    switch (fbBaseType(fbType)) {
    case SQL_SHORT:
        *reinterpret_cast<qint16 *>(data) = static_cast<qint16>(iv);
        break;
    case SQL_LONG:
        *reinterpret_cast<qint32 *>(data) = static_cast<qint32>(iv);
        break;
    default:
        *reinterpret_cast<qint64 *>(data) = iv;
        break;
    }
    return true;
}
 
void QFirebirdResultPrivate::writeInlineBlob(ISC_QUAD &blobId, const QByteArray &blobData)
{
    /* Create the blob via IAttachment. On failure the handle is released and the
       exception propagates to exec()/execBatch, which report it — we never bind
       SQL NULL in place of the caller's data. */
    ThrowStatusWrapper bst(status());
    ITransaction *tr = ensureTransaction();
    FbGuard<IBlob> blob(att()->createBlob(&bst, tr, &blobId, 0, nullptr), fbRelease<IBlob>);
    const char *src = blobData.constData();
    qsizetype remaining = blobData.size();
    while (remaining > 0) {
        const unsigned segSize = static_cast<unsigned>(
            std::min(remaining, static_cast<qsizetype>(65535)));
        blob->putSegment(&bst, segSize, reinterpret_cast<const void *>(src));
        src += segSize;
        remaining -= segSize;
    }
    /* A putSegment or close failure throws; FbGuard frees the handle on the way
       out, so the caller's data is never silently replaced with SQL NULL. */
    blob.closeWith([&](IBlob *b) { b->close(&bst); });
}
 
void QFirebirdResultPrivate::adoptReplacementTransaction(ITransaction *executedTr,
                                                         ITransaction *newTr)
{
    if (!newTr || newTr == executedTr)
        return;
    /* Update whichever member actually held the executed transaction (it came
       from ensureTransaction(), so it is exactly one of these), releasing the
       old handle once and never touching the unrelated transaction — otherwise
       the stale, engine-invalidated handle would be left for a later
       double-release. */
    if (executedTr == drv_d_func()->iTrans) {
        drv_d_func()->iTrans->release();
        drv_d_func()->iTrans = newTr;
    } else if (executedTr == autoTrans) {
        autoTrans->release();
        autoTrans = newTr;
    }
}
 
bool QFirebirdResultPrivate::fillInputBuffer(const QList<QVariant> &vals,
                                             QString &errorText,
                                             BlobWriter blobWriter)
{
    if (!inMeta)
        return true;
 
    const qsizetype count = inCols.size();
 
    /* Reject under-binding instead of silently executing the missing
       parameters as zero-filled NOT NULL values (inBuffer is pre-zeroed, so an
       unwritten parameter would bind 0/''/epoch rather than fail). Matches the
       parameter-mismatch error other Qt SQL drivers report. */
    if (vals.size() < count) {
        errorText = u"Parameter count mismatch: statement expects %1, %2 bound"_s
                        .arg(count).arg(vals.size());
        return false;
    }
 
    for (qsizetype i = 0; i < count; ++i) {
        const ColumnInfo &ci = inCols.at(i);
        short *nullFlag = reinterpret_cast<short *>(inBuffer.data() + ci.nullOffset);
        const QVariant &val = vals[i];
 
        /* Decide whether the value is "null". In Qt 6, a QVariant holding a
           default-constructed value (e.g. QVariant(QString()), QVariant(QDate()))
           reports isNull()==false even though the contained value is null/invalid,
           so check the common types explicitly. */
        bool valueIsNull = val.isNull();
        if (!valueIsNull) {
            switch (val.metaType().id()) {
            case QMetaType::QString:    valueIsNull = val.toString().isNull();      break;
            case QMetaType::QByteArray: valueIsNull = val.toByteArray().isNull();   break;
            case QMetaType::QDateTime:  valueIsNull = !val.toDateTime().isValid();  break;
            case QMetaType::QDate:      valueIsNull = !val.toDate().isValid();      break;
            case QMetaType::QTime:      valueIsNull = !val.toTime().isValid();      break;
            default: break;
            }
        }
 
        /* Bind SQL NULL whenever the value is null, regardless of whether the
           target column is nullable. For a NOT NULL column this lets the engine
           raise its own constraint violation (surfaced as a QSqlError) instead
           of silently coercing the null to a default (0/''/epoch) and inserting
           a bogus row. The legacy QIBASE driver substituted the default here,
           which masked the constraint — see QTBUG-114683. */
        if (valueIsNull) {
            *nullFlag = -1; // SQL NULL
            continue;
        }
        *nullFlag = 0;
 
        char *data = inBuffer.data() + ci.offset;
 
        if (ci.scale != 0) {
            QString numError;
            if (!encodeScaledNumeric(data, ci.fbType, ci.scale, val, numError)) {
                errorText = u"Parameter %1: %2"_s.arg(QString::number(i + 1), numError);
                return false;
            }
            continue;
        }
 
        switch (fbBaseType(ci.fbType)) {
        case SQL_SHORT:
            *reinterpret_cast<qint16 *>(data) = static_cast<qint16>(val.toInt());
            break;
        case SQL_LONG:
            *reinterpret_cast<qint32 *>(data) = static_cast<qint32>(val.toInt());
            break;
        case SQL_INT64:
            *reinterpret_cast<qint64 *>(data) = val.toLongLong();
            break;
        case SQL_INT128: {
            // Accept string or numeric; use IInt128::fromString
            const QByteArray strVal = numericInputString(val);
            ThrowStatusWrapper innerSt(status());
            master()->getUtilInterface()->getInt128(&innerSt)->fromString(
                &innerSt, 0, strVal.constData(),
                reinterpret_cast<FB_I128 *>(data));
            break;
        }
        case SQL_FLOAT:
            *reinterpret_cast<float *>(data) = static_cast<float>(val.toDouble());
            break;
        case SQL_DOUBLE:
            *reinterpret_cast<double *>(data) = val.toDouble();
            break;
        case SQL_DEC16: {
            ThrowStatusWrapper innerSt(status());
            decFloatFromString(master()->getUtilInterface()->getDecFloat16(&innerSt), innerSt,
                               numericInputString(val), reinterpret_cast<FB_DEC16 *>(data));
            break;
        }
        case SQL_DEC34: {
            ThrowStatusWrapper innerSt(status());
            decFloatFromString(master()->getUtilInterface()->getDecFloat34(&innerSt), innerSt,
                               numericInputString(val), reinterpret_cast<FB_DEC34 *>(data));
            break;
        }
        case SQL_BOOLEAN:
            *reinterpret_cast<FB_BOOLEAN *>(data) =
                val.toBool() ? FB_TRUE : FB_FALSE;
            break;
        case SQL_TYPE_DATE:
            *reinterpret_cast<ISC_DATE *>(data) =
                encodeQDate(master()->getUtilInterface(), val.toDate());
            break;
        case SQL_TYPE_TIME:
            *reinterpret_cast<ISC_TIME *>(data) =
                encodeQTime(master()->getUtilInterface(), val.toTime());
            break;
        case SQL_TIMESTAMP:
            *reinterpret_cast<ISC_TIMESTAMP *>(data) =
                encodeQDateTime(master()->getUtilInterface(), val.toDateTime());
            break;
        case SQL_TIMESTAMP_TZ:
            *reinterpret_cast<ISC_TIMESTAMP_TZ *>(data) =
                encodeQDateTimeTz(status(), master()->getUtilInterface(), val.toDateTime());
            break;
        case SQL_TIME_TZ:
            *reinterpret_cast<ISC_TIME_TZ *>(data) =
                encodeQTimeTz(status(), master()->getUtilInterface(), val.toDateTime());
            break;
        case SQL_TEXT:
        case SQL_VARYING:
            encodeTextValue(data, ci.fbType, ci.length, val.toString().toUtf8());
            break;
        case SQL_BLOB: {
            const QByteArray blobData = val.toByteArray();
            ISC_QUAD &blobId = *reinterpret_cast<ISC_QUAD *>(data);
            if (blobWriter) {
                /* Batch mode: delegate blob creation to the caller (IBatch::addBlob).
                   A failure must abort the statement, not silently bind SQL NULL. */
                if (!blobWriter(blobId, blobData)) {
                    errorText = u"Failed to write BLOB for parameter %1"_s.arg(i + 1);
                    return false;
                }
            } else {
                writeInlineBlob(blobId, blobData);
            }
            break;
        }
        case SQL_ARRAY: {
            if (val.typeId() != QMetaType::QVariantList) {
                errorText = u"Cannot bind non-list value to ARRAY parameter %1"_s.arg(i + 1);
                return false;
            }
            ISC_QUAD &arrId = *reinterpret_cast<ISC_QUAD *>(data);
            ITransaction *tr = ensureTransaction();
            if (!writeArray(att(), tr, status(), master(), arrayDescCache,
                            &arrId, ci.relation, ci.field, val.toList())) {
                errorText = u"Failed to write ARRAY parameter %1"_s.arg(i + 1);
                return false;
            }
            break;
        }
        default:
            break;
        }
    }
    return true;
}
 
/*! \internal
    After an EXECUTE PROCEDURE, copy the procedure's output columns back into the
    bound QSql::Out / QSql::InOut parameters, mapped positionally in declaration
    order (output column 0 -> first OUT param, and so on). The single-row result
    set remains available via value(); this just additionally lets callers read
    the outputs through QSqlQuery::boundValue(). Bind the OUT parameters after
    the procedure's IN arguments.
*/
void QFirebirdResult::writeOutValues()
{
    Q_D(QFirebirdResult);
    if (!d->isProcExec)
        return;
    const int columnCount = d->cols.size();
    const int boundCount = boundValueCount();
    int outCol = 0;
    for (int p = 0; p < boundCount && outCol < columnCount; ++p) {
        const QSql::ParamType type = bindValueType(p);
        if (type.testFlag(QSql::Out)) {
            bindValue(p, data(outCol), type);
            ++outCol;
        }
    }
}
 
bool QFirebirdResult::exec()
{
    Q_D(QFirebirdResult);
 
    /* Bare COMMIT/ROLLBACK: finish the active transaction via the API. A user
       transaction (iTrans) takes priority; otherwise the auto-transaction. If
       none is open (e.g. the previous statement already auto-committed) this is
       a no-op success. The handle is reset so the next statement starts fresh. */
    if (d->txnOp != TxnOp::None) {
        ITransaction *&iTrans = d->drv_d_func()->iTrans;
        ITransaction *tr = iTrans ? iTrans : d->autoTrans;
        if (tr) {
            try {
                ThrowStatusWrapper st(d->status());
                if (d->txnOp == TxnOp::Commit)
                    tr->commit(&st);
                else
                    tr->rollback(&st);
            } catch (const FbException &e) {
                const QSqlError err = fbError(d->master(), e.getStatus(), QSqlError::TransactionError);
                qCInfo(lcFirebird) << "exec(txn):" << fbErrorLog(err);
                setLastError(err);
                return false;
            }
            if (tr == iTrans)
                iTrans = nullptr;
            else
                d->autoTrans = nullptr;
        }
        setActive(true);
        setAt(QSql::AfterLastRow);
        return true;
    }
 
    if (!d->stmt) {
        setLastError(QSqlError(u"Statement not prepared"_s, QString(), QSqlError::StatementError));
        return false;
    }
 
    /* Reject over-binding: more input values bound than the statement has
       parameters. OUT-only parameters of a stored procedure are returned in the
       output message and do not consume an input slot, so exclude them from the
       count. (Under-binding is rejected in fillInputBuffer.) */
    {
        const qsizetype paramCount = d->inMeta ? d->inCols.size() : 0;
        int inputCount = 0;
        for (int p = 0, bc = boundValueCount(); p < bc; ++p) {
            if (bindValueType(p).testFlag(QSql::In))
                ++inputCount;
        }
        if (inputCount > paramCount) {
            setLastError(QSqlError(
                u"Parameter count mismatch: statement expects %1 input parameter(s), %2 bound"_s
                    .arg(paramCount).arg(inputCount),
                QString(), QSqlError::StatementError));
            return false;
        }
    }
 
    // Close any open cursor from a previous execution
    d->closeCursor();
    d->affectedRows = -1;
 
    try {
        ThrowStatusWrapper st(d->status());
        ITransaction *tr = d->ensureTransaction();
        QString bindError;
        if (!d->buildInputMessage(bindError)) {
            setLastError(QSqlError(bindError, QString(), QSqlError::StatementError));
            return false;
        }
 
        if (d->isSelect) {
            d->cursor = d->stmt->openCursor(&st, tr,
                                            d->inMeta,
                                            d->inBuffer.isEmpty() ? nullptr : d->inBuffer.data(),
                                            d->outMeta,
                                            isForwardOnly() ? 0 : IStatement::CURSOR_TYPE_SCROLLABLE);
            // Opt-in client-side caching applies only to scrollable SELECTs.
            d->rowCache.clear();
            d->cacheComplete = false;
            d->useRowCache = d->drv_d_func()->cacheScrollableResults && !isForwardOnly();
            setAt(QSql::BeforeFirstRow);
            setActive(true);
        } else {
            d->isProcExec = false;
            d->procRowFetched = false;
            /* Zero the output buffer so stale null indicators from a previous
               execution (e.g. a prior call that returned NULL for a field) don't
               bleed through when Firebird only writes the value and not the flag. */
            if (!d->outBuffer.isEmpty())
                d->outBuffer.fill(0);
            ITransaction *newTr = d->stmt->execute(&st, tr,
                                                   d->inMeta,
                                                   d->inBuffer.isEmpty() ? nullptr : d->inBuffer.data(),
                                                   d->outMeta,
                                                   d->outBuffer.isEmpty() ? nullptr : d->outBuffer.data());
            /* execute() may return a transaction that replaces the one we ran
               under; adopt it, releasing the replaced handle exactly once. */
            d->adoptReplacementTransaction(tr, newTr);
            d->affectedRows = QFirebirdResultPrivate::AffectedPending;
            if (d->outMeta) {
                /* EXECUTE PROCEDURE output: expose the filled buffer as a single
                   row (read via value()) and also copy it back to any bound
                   QSql::Out/InOut parameters (read via boundValue()). */
                d->isProcExec = true;
                setAt(QSql::BeforeFirstRow);
                writeOutValues();
            } else {
                // Auto-commit non-SELECT statements that used an auto transaction
                if (d->autoTrans && !d->drv_d_func()->iTrans)
                    finishAndClear(st, d->autoTrans, TxnEnd::Commit);
                setAt(QSql::AfterLastRow);
            }
            setActive(true);
        }
    } catch (const FbException &e) {
        const QSqlError err = fbError(d->master(), e.getStatus(), QSqlError::StatementError);
        qCInfo(lcFirebird) << "exec:" << fbErrorLog(err);
        setLastError(err);
        return false;
    }
    return true;
}
 
bool QFirebirdResult::execBatch(bool arrayBind)
{
    Q_D(QFirebirdResult);
 
    if (!d->stmt || !d->inMeta) {
        // No prepared statement or no input parameters — fall back to default loop
        return QSqlResult::execBatch(arrayBind);
    }
 
    const QList<QVariant> &batchValues = d->values;
    if (batchValues.isEmpty()) {
        setLastError(QSqlError(u"No values bound for batch execution"_s,
                               QString(), QSqlError::StatementError));
        return false;
    }
 
    const qsizetype paramCount = batchValues.size();
    const QVariantList firstList = batchValues.at(0).toList();
    const qsizetype batchCount = firstList.size();
    if (batchCount == 0)
        return true;
 
    // Close any open cursor from a previous execution
    d->closeCursor();
    d->affectedRows = -1;
 
    IUtil *utl = d->master()->getUtilInterface();
 
    try {
        ThrowStatusWrapper st(d->status());
        ITransaction *tr = d->ensureTransaction();
 
        /* Build batch parameters block. The builder, batch and completion-state
           handles are freed by FbGuard on every path (including the FbException
           catch below), so no manual unwinding is needed. */
        FbGuard<IXpbBuilder> pb(utl->getXpbBuilder(&st, IXpbBuilder::BATCH, nullptr, 0),
                                fbDispose<IXpbBuilder>);
        pb->insertInt(&st, IBatch::TAG_RECORD_COUNTS, 1);
 
        // Check if any parameter is a BLOB — enable inline blob IDs
        bool hasBlobs = false;
        for (const ColumnInfo &ci : std::as_const(d->inCols)) {
            if (fbBaseType(ci.fbType) == SQL_BLOB) {
                hasBlobs = true;
                break;
            }
        }
        if (hasBlobs)
            pb->insertInt(&st, IBatch::TAG_BLOB_POLICY, IBatch::BLOB_ID_ENGINE);
 
        /* Create batch from the prepared statement (pb is disposed by its guard
           on scope exit; its buffer was already consumed by createBatch). */
        FbGuard<IBatch> batch(d->stmt->createBatch(&st, d->inMeta,
                                                   pb->getBufferLength(&st), pb->getBuffer(&st)),
                              fbRelease<IBatch>);
 
        /* Extract each parameter's value list once before the row loop —
           toList() per (row, param) would convert the same QVariant for every
           row of the batch. */
        QVarLengthArray<QVariantList, 16> paramLists;
        paramLists.reserve(paramCount);
        for (qsizetype p = 0; p < paramCount; ++p)
            paramLists.append(batchValues.at(p).toList());
 
        for (qsizetype row = 0; row < batchCount; ++row) {
            QList<QVariant> rowValues;
            rowValues.reserve(paramCount);
            for (qsizetype p = 0; p < paramCount; ++p) {
                const QVariantList &col = paramLists[p];
                rowValues.append(row < col.size() ? col.at(row) : QVariant());
            }
 
            d->inBuffer.fill(0);
 
            // BlobWriter lambda for batch mode: uses IBatch::addBlob
            auto blobWriter = [&](ISC_QUAD &blobId, const QByteArray &data) -> bool {
                try {
                    batch->addBlob(&st, static_cast<unsigned>(data.size()),
                                   data.constData(), &blobId, 0, nullptr);
                    return true;
                } catch (const FbException &e) {
                    const auto berr = fbError(d->master(), e.getStatus(), QSqlError::StatementError);
                    qCWarning(lcFirebird) << "batch addBlob:" << fbErrorLog(berr);
                    return false;
                }
            };
 
            QString bindError;
            if (!d->fillInputBuffer(rowValues, bindError,
                                    hasBlobs ? blobWriter : QFirebirdResultPrivate::BlobWriter{})) {
                setLastError(QSqlError(bindError, QString(), QSqlError::StatementError));
                return false; // batch guard releases the handle
            }
 
            batch->add(&st, 1, d->inBuffer.data());
        }
 
        FbGuard<IBatchCompletionState> cs(batch->execute(&st, tr),
                                          fbDispose<IBatchCompletionState>);
 
        unsigned total = cs->getSize(&st);
        int totalAffected = 0;
        bool hadError = false;
        for (unsigned p = 0; p < total; ++p) {
            int state = cs->getState(&st, p);
            if (state == IBatchCompletionState::EXECUTE_FAILED) {
                hadError = true;
            } else if (state != IBatchCompletionState::SUCCESS_NO_INFO) {
                totalAffected += state;
            } else {
                // SUCCESS_NO_INFO: count as 1 affected row
                totalAffected += 1;
            }
        }
        d->affectedRows = totalAffected;
 
        if (hadError) {
            unsigned errPos = cs->findError(&st, 0);
            if (errPos != IBatchCompletionState::NO_MORE_ERRORS) {
                IStatus *errStatus = d->master()->getStatus();
                try {
                    cs->getStatus(&st, errStatus, errPos);
                    setLastError(fbError(d->master(), errStatus, QSqlError::StatementError));
                } catch (...) {
                    setLastError(QSqlError(u"Batch execution failed at message %1"_s
                                               .arg(errPos),
                                           QString(), QSqlError::StatementError));
                }
                errStatus->dispose();
            } else {
                /* EXECUTE_FAILED was reported but findError returned no
                   position — should not happen, but never fail silently. */
                setLastError(QSqlError(u"Batch execution failed"_s,
                                       QString(), QSqlError::StatementError));
            }
        }
 
        /* Close the batch gracefully (its guard is dismissed on success, releases
           on a failed close); the completion state is disposed by its guard on
           scope exit. */
        batch.closeWith([&](IBatch *b) { b->close(&st); });
 
        // Auto-commit if using an auto-transaction
        if (d->autoTrans && !d->drv_d_func()->iTrans)
            finishAndClear(st, d->autoTrans, TxnEnd::Commit);
 
        setAt(QSql::AfterLastRow);
        setActive(true);
        return !hadError;
 
    } catch (const FbException &e) {
        const QSqlError err = fbError(d->master(), e.getStatus(), QSqlError::StatementError);
        qCInfo(lcFirebird) << "execBatch:" << fbErrorLog(err);
        setLastError(err);
        return false;
    }
}
 
bool QFirebirdResult::reset(const QString &query)
{
    if (!prepare(query))
        return false;
    return exec();
}
 
// ---------- Fetch helpers ----------
 
/*! \internal
    Largest non-negative row-position sentinel. Two uses, same value:
     - passed to ensureCachedRow() to force the cache to pull every remaining row;
     - the at() position set after fetchLast() on a server-side scrollable cursor,
       which exposes no row count so the true last index is unknown (QSqlQuery
       only needs a valid non-negative position; the row data comes from outBuffer).
*/
static constexpr int kMaxRowSentinel = 0x7FFFFFFE;
 
bool QFirebirdResult::fetchCached(int target)
{
    Q_D(QFirebirdResult);
    if (target < 0)
        return false;
    try {
        if (d->ensureCachedRow(target)) {
            /* Restore the snapshot so data()/isNull() read it unchanged. QByteArray
               assignment is a cheap COW share, not a copy. */
            d->outBuffer = d->rowCache.at(target);
            setAt(target);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
bool QFirebirdResult::fetchNext()
{
    Q_D(QFirebirdResult);
    if (d->isProcExec) {
        if (d->procRowFetched)
            return false;
        d->procRowFetched = true;
        setAt(0);
        return true;
    }
    if (!d->cursor)
        return false;
    if (d->useRowCache)
        return fetchCached(at() == QSql::BeforeFirstRow ? 0 : at() + 1);
    try {
        ThrowStatusWrapper st(d->status());
        int code = d->cursor->fetchNext(&st, d->outBuffer.data());
        if (code == IStatus::RESULT_OK) {
            setAt(at() == QSql::BeforeFirstRow ? 0 : at() + 1);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
bool QFirebirdResult::fetchFirst()
{
    Q_D(QFirebirdResult);
    if (d->isProcExec) {
        if (d->procRowFetched)
            return false;
        d->procRowFetched = true;
        setAt(0);
        return true;
    }
    if (!d->cursor)
        return false;
    if (d->useRowCache)
        return fetchCached(0);
    try {
        ThrowStatusWrapper st(d->status());
        int code;
        if (isForwardOnly())
            code = d->cursor->fetchNext(&st, d->outBuffer.data());
        else
            code = d->cursor->fetchFirst(&st, d->outBuffer.data());
        if (code == IStatus::RESULT_OK) {
            setAt(0);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
bool QFirebirdResult::fetchLast()
{
    Q_D(QFirebirdResult);
    if (d->isProcExec) {
        // EXECUTE PROCEDURE exposes a single output row at index 0.
        d->procRowFetched = true;
        setAt(0);
        return true;
    }
    if (!d->cursor)
        return false;
    if (d->useRowCache) {
        /* Pull the whole set, then position on the real last index. Unlike the
           server-cursor path below, cache mode therefore gives last() a genuine
           absolute at() (and lets size() report a row count). */
        try {
            d->ensureCachedRow(kMaxRowSentinel);
        } catch (const FbException &e) {
            setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
            return false;
        }
        if (d->rowCache.isEmpty())
            return false;
        return fetchCached(int(d->rowCache.size()) - 1);
    }
    if (isForwardOnly()) {
        /* Forward-only cursors cannot jump to the end, so walk there with
           fetchNext(): the last successful fetch leaves the final row in the
           buffer with at() at its index. Mirrors QSqlCachedResult. */
        if (at() == QSql::AfterLastRow)
            return false;
        if (!fetchNext())
            return false; // empty result set (or already exhausted)
        while (fetchNext())
            ;
        return true;
    }
    try {
        ThrowStatusWrapper st(d->status());
        int code = d->cursor->fetchLast(&st, d->outBuffer.data());
        if (code == IStatus::RESULT_OK) {
            /* The last row's absolute index is unknown (see kMaxRowSentinel), so
               use the sentinel as the position: QSqlQuery::value() treats it as
               valid and the row data (read from outBuffer) is correct. at() is
               therefore NOT a meaningful absolute index after last(); relative
               navigation from here (previous()) still returns correct row data
               but at() stays sentinel-relative. Use forward iteration from
               first()/next() if a true row index is required. */
            setAt(kMaxRowSentinel);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
bool QFirebirdResult::fetchPrevious()
{
    Q_D(QFirebirdResult);
    if (d->isProcExec)
        return false; // single-row proc result: nothing precedes the one row
    if (!d->cursor)
        return false;
    if (d->useRowCache) {
        if (at() <= 0) {
            setAt(QSql::BeforeFirstRow);
            return false;
        }
        return fetchCached(at() - 1);
    }
    if (isForwardOnly())
        return false; // cannot move backwards on a forward-only cursor
    try {
        ThrowStatusWrapper st(d->status());
        int code = d->cursor->fetchPrior(&st, d->outBuffer.data());
        if (code == IStatus::RESULT_OK) {
            /* The cursor moves correctly and the row data is valid; at() is
               decremented from the previous position. After last() the previous
               position is the sentinel (see fetchLast), so at() stays
               sentinel-relative rather than a true absolute index. */
            setAt(at() > 0 ? at() - 1 : QSql::BeforeFirstRow);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
bool QFirebirdResult::fetch(int i)
{
    Q_D(QFirebirdResult);
    if (i < 0)
        return false;
    if (d->isProcExec) {
        /* EXECUTE PROCEDURE exposes a single output row at index 0, so only
           seek(0) is valid — this makes QSqlQuery::seek()/first() work on
           procedure results, not just next(). */
        if (i != 0)
            return false;
        d->procRowFetched = true;
        setAt(0);
        return true;
    }
    if (!d->cursor)
        return false;
    if (d->useRowCache)
        return fetchCached(i);
    if (isForwardOnly()) {
        /* Forward-only cursors have no random access, but absolute *forward*
           seeks can be emulated by iterating with fetchNext(). Backward seeks
           are rejected by QSqlQuery before reaching here. Mirrors the
           forward-only behaviour of QSqlCachedResult. */
        if (i < at())
            return false;
        while (at() < i) {
            if (!fetchNext())
                return false;
        }
        return true;
    }
    // IResultSet supports absolute positioning
    try {
        ThrowStatusWrapper st(d->status());
        int code = d->cursor->fetchAbsolute(&st, i + 1, d->outBuffer.data());
        if (code == IStatus::RESULT_OK) {
            setAt(i);
            return true;
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
    }
    return false;
}
 
// ---------- Data access ----------
 
bool QFirebirdResult::isNull(int field)
{
    Q_D(const QFirebirdResult);
    if (field < 0 || field >= d->cols.size())
        return true;
    const ColumnInfo &ci = d->cols.at(field);
    const short *nullFlag =
        reinterpret_cast<const short *>(d->outBuffer.constData() + ci.nullOffset);
    qCDebug(lcFirebird, "isNull(%d): nullOffset=%u nullFlag=%d", field, ci.nullOffset, int(*nullFlag));
    return *nullFlag != 0;
}
 
QVariant QFirebirdResult::data(int field)
{
    Q_D(const QFirebirdResult);
 
    if (field < 0 || field >= d->cols.size()) {
        qCDebug(lcFirebird, "data(%d): out of range, cols.size()=%d", field, int(d->cols.size()));
        return {};
    }
 
    const ColumnInfo &ci = d->cols.at(field);
 
    /* SQL NULL: return a valid but null QVariant of the correct type.
       Returning {} (invalid QVariant) would violate Qt SQL conventions and
       break code that checks QVariant::isValid() to detect present-but-null values. */
    if (isNull(field)) {
        qCDebug(lcFirebird, "data(%d): SQL NULL, fbType=%d qtType=%d", field, ci.fbType, int(ci.qtType));
        return QVariant(QMetaType(ci.qtType));
    }
 
    qCDebug(lcFirebird, "data(%d): fbType=%d qtType=%d", field, ci.fbType, int(ci.qtType));
    const char *ptr = d->outBuffer.constData() + ci.offset;
 
    /* The Firebird OO-API conversions below (IInt128/IDecFloat, BLOB and array
       reads) use ThrowStatusWrapper, so any conversion or fetch failure raises
       FbException. Catch it here and surface a QSqlError instead of returning a
       silently corrupt or truncated value. */
    try {
        // Scaled numerics — honour numericalPrecisionPolicy (any non-zero scale)
        if (ci.scale != 0) {
            const auto policy = numericalPrecisionPolicy();
            switch (fbBaseType(ci.fbType)) {
            case SQL_SHORT:   return applyScale(*reinterpret_cast<const qint16 *>(ptr), ci.scale, policy);
            case SQL_LONG:    return applyScale(*reinterpret_cast<const qint32 *>(ptr), ci.scale, policy);
            case SQL_INT128: {
                // Use Firebird's IInt128 interface to format, then apply policy
                ThrowStatusWrapper st(d->status());
                const QString str = int128ToString(d->master()->getUtilInterface(), st,
                                                    reinterpret_cast<const FB_I128 *>(ptr),
                                                    ci.scale);
                if (policy == QSql::HighPrecision)
                    return str;
                if (policy == QSql::LowPrecisionDouble)
                    return QVariant(str.toDouble());
                /* LowPrecisionInt32/Int64: take the integer part straight from
                   the decimal string (truncating toward zero) rather than via
                   double, so 128-bit values keep full integer precision up to
                   the target type's range — a double round-trip would drop bits
                   above 2^53. */
                const qsizetype dot = str.indexOf(u'.');
                const QStringView intPart =
                    dot < 0 ? QStringView(str) : QStringView(str).first(dot);
                if (policy == QSql::LowPrecisionInt32)
                    return QVariant(intPart.toInt());
                return QVariant(intPart.toLongLong());
            }
            default:          return applyScale(*reinterpret_cast<const qint64 *>(ptr), ci.scale, policy);
            }
        }
 
        switch (fbBaseType(ci.fbType)) {
        case SQL_SHORT:
            return static_cast<int>(*reinterpret_cast<const qint16 *>(ptr));
        case SQL_LONG:
            return static_cast<int>(*reinterpret_cast<const qint32 *>(ptr));
        case SQL_INT64:
            return *reinterpret_cast<const qint64 *>(ptr);
        case SQL_INT128: {
            // 128-bit integer: use Firebird's IInt128 to convert to decimal string
            ThrowStatusWrapper st(d->status());
            return int128ToString(d->master()->getUtilInterface(), st,
                                  reinterpret_cast<const FB_I128 *>(ptr), 0);
        }
        case SQL_FLOAT:
            return static_cast<double>(*reinterpret_cast<const float *>(ptr));
        case SQL_DOUBLE:
            return *reinterpret_cast<const double *>(ptr);
        case SQL_DEC16: {
            ThrowStatusWrapper st(d->status());
            return decFloatToString(d->master()->getUtilInterface()->getDecFloat16(&st), st,
                                    reinterpret_cast<const FB_DEC16 *>(ptr));
        }
        case SQL_DEC34: {
            ThrowStatusWrapper st(d->status());
            return decFloatToString(d->master()->getUtilInterface()->getDecFloat34(&st), st,
                                    reinterpret_cast<const FB_DEC34 *>(ptr));
        }
        case SQL_BOOLEAN:
            return *reinterpret_cast<const FB_BOOLEAN *>(ptr) != FB_FALSE;
        case SQL_TYPE_DATE:
            return decodeFirebirdDate(d->master()->getUtilInterface(),
                                      *reinterpret_cast<const ISC_DATE *>(ptr));
        case SQL_TYPE_TIME:
            return decodeFirebirdTime(d->master()->getUtilInterface(),
                                      *reinterpret_cast<const ISC_TIME *>(ptr));
        case SQL_TIMESTAMP:
            return decodeFirebirdTimestamp(d->master()->getUtilInterface(),
                                          *reinterpret_cast<const ISC_TIMESTAMP *>(ptr));
        case SQL_TIMESTAMP_TZ:
            return decodeFirebirdTimestampTz(d->status(), d->master()->getUtilInterface(),
                                             *reinterpret_cast<const ISC_TIMESTAMP_TZ *>(ptr));
        case SQL_TIME_TZ:
            return decodeFirebirdTimeTz(d->status(), d->master()->getUtilInterface(),
                                        *reinterpret_cast<const ISC_TIME_TZ *>(ptr));
        case SQL_BLOB: {
            const ISC_QUAD &blobId = *reinterpret_cast<const ISC_QUAD *>(ptr);
            QByteArray ba = readBlob(d->att(), d->activeTransaction(),
                                     d->status(), blobId);
            // TEXT blob (sub_type 1) → return as QString
            if (ci.fbSubType == 1)
                return QString::fromUtf8(ba);
            return ba;
        }
        case SQL_ARRAY: {
            const ISC_QUAD &arrayId = *reinterpret_cast<const ISC_QUAD *>(ptr);
            ITransaction *tra = d->activeTransaction();
            return fetchArray(d->att(), tra, d->status(), d->master(),
                              d->arrayDescCache, arrayId, ci.relation, ci.field);
        }
        case SQL_VARYING: {
            /* First 2 bytes are the length. Clamp it to the field's data
               capacity (byte length minus the 2-byte prefix) so a corrupt or
               oversized length indicator cannot read past the row buffer. */
            const unsigned short len = *reinterpret_cast<const unsigned short *>(ptr);
            const qsizetype maxLen =
                std::max(qsizetype(0), static_cast<qsizetype>(ci.length) - 2);
            return QString::fromUtf8(ptr + 2, std::min(static_cast<qsizetype>(len), maxLen));
        }
        case SQL_TEXT: {
            /* ci.length is the byte length cached from the output metadata in
               buildColumns(); reuse it instead of a per-row getLength() call. */
            QString s = QString::fromUtf8(ptr, static_cast<qsizetype>(ci.length));
            while (s.endsWith(u' '))
                s.chop(1);
            return s;
        }
        default:
            qCWarning(lcFirebird, "data: unhandled Firebird type %d for field %d", ci.fbType, field);
            return QString::fromUtf8(ptr);
        }
    } catch (const FbException &e) {
        setLastError(fbError(d->master(), e.getStatus(), QSqlError::StatementError));
        return {};
    }
}
 
QSqlRecord QFirebirdResult::record() const
{
    Q_D(const QFirebirdResult);
    if (d->recordCached)
        return d->cachedRecord;
    QSqlRecord rec;
    for (const ColumnInfo &ci : d->cols) {
        /* Pass the source relation as the field's table name so table-qualified
           lookups (QSqlRecord::indexOf("TABLE.COLUMN")) can disambiguate columns
           that share a name across joined tables — matching the QIBASE driver. */
        QSqlField f(ci.name, QMetaType(ci.qtType), ci.relation);
        const int base = fbBaseType(ci.fbType);
        if (base == SQL_TEXT || base == SQL_VARYING) {
            /* ci.length is the UTF-8 byte length (the connection charset is
               UTF-8); report the declared character length instead. Integer
               division also absorbs the 2-byte VARYING prefix. */
            f.setLength(static_cast<int>(ci.length) / 4);
        } else {
            f.setLength(static_cast<int>(ci.length));
        }
        /* Precision (fractional digits) only applies to scaled numeric types;
           leave it unset (-1) for everything else. */
        if (ci.scale != 0)
            f.setPrecision(qAbs(ci.scale));
        f.setRequiredStatus(ci.nullable ? QSqlField::Optional : QSqlField::Required);
        rec.append(f);
    }
    d->cachedRecord = rec;
    d->recordCached = true;
    return rec;
}
 
int QFirebirdResult::size()
{
    Q_D(QFirebirdResult);
    /* The row count is only available in cache mode (FB_SCROLLABLE_CACHE=1),
       where the result buffers its rows client-side anyway: pull the remaining
       rows into the cache and report its size. Firebird cursors cannot report
       cardinality without fetching, so every other path returns -1. */
    if (!d->useRowCache)
        return -1;
    if (!d->cacheComplete) {
        if (!d->cursor) // e.g. after finish() released the cursor
            return -1;
        try {
            d->ensureCachedRow((std::numeric_limits<int>::max)());
        } catch (const FbException &e) {
            const QSqlError err = fbError(d->master(), e.getStatus(), QSqlError::StatementError);
            qCInfo(lcFirebird) << "size:" << fbErrorLog(err);
            setLastError(err);
            return -1;
        }
    }
    return int(d->rowCache.size());
}
 
int QFirebirdResult::numRowsAffected()
{
    Q_D(QFirebirdResult);
    if (d->affectedRows == QFirebirdResultPrivate::AffectedPending) {
        d->affectedRows = -1;
        if (d->stmt) {
            try {
                ThrowStatusWrapper st(d->status());
                d->affectedRows = static_cast<int>(d->stmt->getAffectedRecords(&st));
            } catch (const FbException &e) {
                qCInfo(lcFirebird) << "numRowsAffected:"
                                   << fbErrorLog(fbError(d->master(), e.getStatus(),
                                                         QSqlError::StatementError));
                d->status()->init();
            }
        }
    }
    return d->affectedRows;
}
 
QT_END_NAMESPACE