Public Functions
void	cleanup ()

bool	commit ()

QVariant	fetchArray (int pos, ISC_QUAD *arr)

QVariant	fetchBlob (ISC_QUAD *bId)

bool	isError (const char *msg, QSqlError::ErrorType typ=QSqlError::UnknownError)

bool	isSelect ()

	QIBaseResultPrivate (QIBaseResult d, const QIBaseDriver ddb)

bool	transaction ()

bool	writeArray (int i, const QList< QVariant > &list)

bool	writeBlob (int i, const QByteArray &ba)

	~QIBaseResultPrivate ()

Public Variables
const QIBaseDriver *	db

isc_db_handle	ibase

XSQLDA *	inda

bool	localTransaction

QIBaseResult *	q

int	queryType

XSQLDA *	sqlda

ISC_STATUS	status [20]

isc_stmt_handle	stmt

QTextCodec *	tc

isc_tr_handle	trans

Detailed Description

Definition at line 349 of file qsql_ibase.cpp.

Constructors and Destructors

◆ QIBaseResultPrivate()

QIBaseResultPrivate::QIBaseResultPrivate	(	QIBaseResult *	d,
		const QIBaseDriver *	ddb
	)

Definition at line 393 of file qsql_ibase.cpp.

                                                                                 :
     q(d), db(ddb), trans(0), stmt(0), ibase(ddb->d->ibase), sqlda(0), inda(0), queryType(-1), tc(ddb->d->tc)
 {
     localTransaction = (ddb->d->ibase == 0);
 }

◆ ~QIBaseResultPrivate()

QIBaseResultPrivate::~QIBaseResultPrivate ( )

inline

Definition at line 353 of file qsql_ibase.cpp.

353 { cleanup(); }

QIBaseResultPrivate::cleanup

void cleanup()

Definition: qsql_ibase.cpp:399

Functions

◆ cleanup()

void QIBaseResultPrivate::cleanup ( )

Definition at line 399 of file qsql_ibase.cpp.

Referenced by QIBaseResult::prepare().

 {
     commit();
     if (!localTransaction)
         trans = 0;
 
     if (stmt) {
         isc_dsql_free_statement(status, &stmt, DSQL_drop);
         stmt = 0;
     }
 
     delDA(sqlda);
     delDA(inda);
 
     queryType = -1;
     q->cleanup();
 }

◆ commit()

bool QIBaseResultPrivate::commit ( )

Definition at line 854 of file qsql_ibase.cpp.

Referenced by cleanup(), and QIBaseResult::exec().

 {
     if (!trans)
         return false;
     // don't commit driver's transaction, the driver will do it for us
     if (!localTransaction)
         return true;
 
     isc_commit_transaction(status, &trans);
     trans = 0;
     return !isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to commit transaction"),
                     QSqlError::TransactionError);
 }

◆ fetchArray()

QVariant QIBaseResultPrivate::fetchArray	(	int	pos,
		ISC_QUAD *	arr
	)

Definition at line 571 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext().

 {
     QList<QVariant> list;
     ISC_ARRAY_DESC desc;
 
     if (!arr)
         return list;
 
     QByteArray relname(sqlda->sqlvar[pos].relname, sqlda->sqlvar[pos].relname_length);
     QByteArray sqlname(sqlda->sqlvar[pos].aliasname, sqlda->sqlvar[pos].aliasname_length);
 
     isc_array_lookup_bounds(status, &ibase, &trans, relname.data(), sqlname.data(), &desc);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not find array"),
                 QSqlError::StatementError))
         return list;
 
 
     int arraySize = 1, subArraySize;
     short dimensions = desc.array_desc_dimensions;
     QVarLengthArray<short> numElements(dimensions);
 
     for(int i = 0; i < dimensions; ++i) {
         subArraySize = (desc.array_desc_bounds[i].array_bound_upper -
                       desc.array_desc_bounds[i].array_bound_lower + 1);
         numElements[i] = subArraySize;
         arraySize = subArraySize * arraySize;
     }
 
     ISC_LONG bufLen;
     QByteArray ba;
     /* varying arrayelements are stored with 2 trailing null bytes
        indicating the length of the string
      */
     if (desc.array_desc_dtype == blr_varying
         || desc.array_desc_dtype == blr_varying2) {
         desc.array_desc_length += 2;
         bufLen = desc.array_desc_length * arraySize * sizeof(short);
     } else {
         bufLen = desc.array_desc_length *  arraySize;
     }
 
 
     ba.resize(int(bufLen));
     isc_array_get_slice(status, &ibase, &trans, arr, &desc, ba.data(), &bufLen);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not get array data"),
                 QSqlError::StatementError))
         return list;
 
     readArrayBuffer(list, ba.data(), 0, numElements.data(), &desc, tc);
 
     return QVariant(list);
 }

◆ fetchBlob()

QVariant QIBaseResultPrivate::fetchBlob ( ISC_QUAD * bId )

Definition at line 437 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext().

 {
     isc_blob_handle handle = 0;
 
     isc_open_blob2(status, &ibase, &trans, &handle, bId, 0, 0);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to open BLOB"),
                 QSqlError::StatementError))
         return QVariant();
 
     unsigned short len = 0;
     QByteArray ba;
     int chunkSize = QIBaseChunkSize;
     ba.resize(chunkSize);
     int read = 0;
     while (isc_get_segment(status, &handle, &len, chunkSize, ba.data() + read) == 0 || status[1] == isc_segment) {
         read += len;
         ba.resize(read + chunkSize);
     }
     ba.resize(read);
 
     bool isErr = (status[1] == isc_segstr_eof ? false :
                     isError(QT_TRANSLATE_NOOP("QIBaseResult",
                                                 "Unable to read BLOB"),
                                                 QSqlError::StatementError));
 
     isc_close_blob(status, &handle);
 
     if (isErr)
         return QVariant();
 
     ba.resize(read);
     return ba;
 }

◆ isError()

bool QIBaseResultPrivate::isError	(	const char *	msg,
		QSqlError::ErrorType	typ = `QSqlError::UnknownError`
	)

inline

Definition at line 356 of file qsql_ibase.cpp.

Referenced by commit(), QIBaseResult::exec(), fetchArray(), fetchBlob(), QIBaseResult::gotoNext(), isSelect(), QIBaseResult::numRowsAffected(), QIBaseResult::prepare(), transaction(), writeArray(), and writeBlob().

     {
         QString imsg;
         ISC_LONG sqlcode;
         if (!getIBaseError(imsg, status, sqlcode, tc))
             return false;
 
         q->setLastError(QSqlError(QCoreApplication::translate("QIBaseResult", msg),
                         imsg, typ, int(sqlcode)));
         return true;
     }

◆ isSelect()

bool QIBaseResultPrivate::isSelect ( )

Definition at line 820 of file qsql_ibase.cpp.

Referenced by QIBaseResult::prepare().

 {
     char acBuffer[9];
     char qType = isc_info_sql_stmt_type;
     isc_dsql_sql_info(status, &stmt, 1, &qType, sizeof(acBuffer), acBuffer);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not get query info"),
                 QSqlError::StatementError))
         return false;
     int iLength = isc_vax_integer(&acBuffer[1], 2);
     queryType = isc_vax_integer(&acBuffer[3], iLength);
     return (queryType == isc_info_sql_stmt_select || queryType == isc_info_sql_stmt_exec_procedure);
 }

◆ transaction()

bool QIBaseResultPrivate::transaction ( )

Definition at line 833 of file qsql_ibase.cpp.

Referenced by QIBaseResult::exec(), and QIBaseResult::prepare().

 {
     if (trans)
         return true;
     if (db->d->trans) {
         localTransaction = false;
         trans = db->d->trans;
         return true;
     }
     localTransaction = true;
 
     isc_start_transaction(status, &trans, 1, &ibase, 0, NULL);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not start transaction"),
                 QSqlError::TransactionError))
         return false;
 
     return true;
 }

◆ writeArray()

bool QIBaseResultPrivate::writeArray	(	int	i,
		const QList< QVariant > &	list
	)

Definition at line 760 of file qsql_ibase.cpp.

Referenced by QIBaseResult::exec().

 {
     QString error;
     ISC_QUAD *arrayId = (ISC_QUAD*) inda->sqlvar[column].sqldata;
     ISC_ARRAY_DESC desc;
 
     QByteArray relname(inda->sqlvar[column].relname, inda->sqlvar[column].relname_length);
     QByteArray sqlname(inda->sqlvar[column].aliasname, inda->sqlvar[column].aliasname_length);
 
     isc_array_lookup_bounds(status, &ibase, &trans, relname.data(), sqlname.data(), &desc);
     if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not find array"),
                 QSqlError::StatementError))
         return false;
 
     short arraySize = 1;
     ISC_LONG bufLen;
     QList<QVariant> subList = list;
 
     short dimensions = desc.array_desc_dimensions;
     for(int i = 0; i < dimensions; ++i) {
         arraySize *= (desc.array_desc_bounds[i].array_bound_upper -
                       desc.array_desc_bounds[i].array_bound_lower + 1);
     }
 
     /* varying arrayelements are stored with 2 trailing null bytes
        indicating the length of the string
      */
     if (desc.array_desc_dtype == blr_varying ||
        desc.array_desc_dtype == blr_varying2)
         desc.array_desc_length += 2;
 
     bufLen = desc.array_desc_length * arraySize;
     QByteArray ba;
     ba.resize(int(bufLen));
 
     if (list.size() > arraySize) {
         error = QLatin1String("Array size missmatch: size of %1 is %2, size of provided list is %3");
         error = error.arg(QLatin1String(sqlname)).arg(arraySize).arg(list.size());
         q->setLastError(QSqlError(error, QLatin1String(""), QSqlError::StatementError));
         return false;
     }
 
     if (!createArrayBuffer(ba.data(), list,
                            qIBaseTypeName(desc.array_desc_dtype, inda->sqlvar[column].sqlscale < 0),
                            0, &desc, error, tc)) {
         q->setLastError(QSqlError(error.arg(QLatin1String(sqlname)), QLatin1String(""),
                         QSqlError::StatementError));
         return false;
     }
 
     /* readjust the buffer size*/
     if (desc.array_desc_dtype == blr_varying
         || desc.array_desc_dtype == blr_varying2)
         desc.array_desc_length -= 2;
 
     isc_array_put_slice(status, &ibase, &trans, arrayId, &desc, ba.data(), &bufLen);
     return true;
 }

◆ writeBlob()

bool QIBaseResultPrivate::writeBlob	(	int	i,
		const QByteArray &	ba
	)

Definition at line 417 of file qsql_ibase.cpp.

Referenced by QIBaseResult::exec().

 {
     isc_blob_handle handle = 0;
     ISC_QUAD *bId = (ISC_QUAD*)inda->sqlvar[i].sqldata;
     isc_create_blob2(status, &ibase, &trans, &handle, bId, 0, 0);
     if (!isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to create BLOB"),
                  QSqlError::StatementError)) {
         int i = 0;
         while (i < ba.size()) {
             isc_put_segment(status, &handle, qMin(ba.size() - i, int(QIBaseChunkSize)),
                             const_cast<char*>(ba.data()) + i);
             if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to write BLOB")))
                 return false;
             i += qMin(ba.size() - i, int(QIBaseChunkSize));
         }
     }
     isc_close_blob(status, &handle);
     return true;
 }