Public Functions
void	cleanup ()

bool	fetchNext (QSqlCachedResult::ValueCache &values, int idx, bool initialFetch)

void	finalize ()

void	initColumns (bool emptyResultset)

	QSQLiteResultPrivate (QSQLiteResult *res)

Public Variables
sqlite3 *	access

QVector< QVariant >	firstRow

QSQLiteResult *	q

QSqlRecord	rInf

bool	skippedStatus

bool	skipRow

sqlite3_stmt *	stmt

Detailed Description

Definition at line 112 of file qsql_sqlite.cpp.

Constructors and Destructors

◆ QSQLiteResultPrivate()

QSQLiteResultPrivate::QSQLiteResultPrivate ( QSQLiteResult * res )

Definition at line 133 of file qsql_sqlite.cpp.

                                                              : q(res), access(0),
     stmt(0), skippedStatus(false), skipRow(false)
 {
 }

Functions

◆ cleanup()

void QSQLiteResultPrivate::cleanup ( )

Definition at line 138 of file qsql_sqlite.cpp.

Referenced by QSQLiteResult::prepare(), and QSQLiteResult::~QSQLiteResult().

 {
     finalize();
     rInf.clear();
     skippedStatus = false;
     skipRow = false;
     q->setAt(QSql::BeforeFirstRow);
     q->setActive(false);
     q->cleanup();
 }

◆ fetchNext()

bool QSQLiteResultPrivate::fetchNext	(	QSqlCachedResult::ValueCache &	values,
		int	idx,
		bool	initialFetch
	)

Definition at line 209 of file qsql_sqlite.cpp.

Referenced by QSQLiteResult::exec(), and QSQLiteResult::gotoNext().

 {
     int res;
     int i;
 
     if (skipRow) {
         // already fetched
         Q_ASSERT(!initialFetch);
         skipRow = false;
         for(int i=0;i<firstRow.count();i++)
             values[i]=firstRow[i];
         return skippedStatus;
     }
     skipRow = initialFetch;
 
     if(initialFetch) {
         firstRow.clear();
         firstRow.resize(sqlite3_column_count(stmt));
     }
 
     if (!stmt) {
         q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"),
                                   QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));
         q->setAt(QSql::AfterLastRow);
         return false;
     }
     res = sqlite3_step(stmt);
 
     switch(res) {
     case SQLITE_ROW:
         // check to see if should fill out columns
         if (rInf.isEmpty())
             // must be first call.
             initColumns(false);
         if (idx < 0 && !initialFetch)
             return true;
         for (i = 0; i < rInf.count(); ++i) {
             switch (sqlite3_column_type(stmt, i)) {
             case SQLITE_BLOB:
                 values[i + idx] = QByteArray(static_cast<const char *>(
                             sqlite3_column_blob(stmt, i)),
                             sqlite3_column_bytes(stmt, i));
                 break;
             case SQLITE_INTEGER:
                 values[i + idx] = sqlite3_column_int64(stmt, i);
                 break;
             case SQLITE_FLOAT:
                 switch(q->numericalPrecisionPolicy()) {
                     case QSql::LowPrecisionInt32:
                         values[i + idx] = sqlite3_column_int(stmt, i);
                         break;
                     case QSql::LowPrecisionInt64:
                         values[i + idx] = sqlite3_column_int64(stmt, i);
                         break;
                     case QSql::LowPrecisionDouble:
                     case QSql::HighPrecision:
                     default:
                         values[i + idx] = sqlite3_column_double(stmt, i);
                         break;
                 };
                 break;
             case SQLITE_NULL:
                 values[i + idx] = QVariant(QVariant::String);
                 break;
             default:
                 values[i + idx] = QString(reinterpret_cast<const QChar *>(
                             sqlite3_column_text16(stmt, i)),
                             sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
                 break;
             }
         }
         return true;
     case SQLITE_DONE:
         if (rInf.isEmpty())
             // must be first call.
             initColumns(true);
         q->setAt(QSql::AfterLastRow);
         sqlite3_reset(stmt);
         return false;
     case SQLITE_CONSTRAINT:
     case SQLITE_ERROR:
         // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()
         // to get the specific error message.
         res = sqlite3_reset(stmt);
         q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
                         "Unable to fetch row"), QSqlError::ConnectionError, res));
         q->setAt(QSql::AfterLastRow);
         return false;
     case SQLITE_MISUSE:
     case SQLITE_BUSY:
     default:
         // something wrong, don't get col info, but still return false
         q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
                         "Unable to fetch row"), QSqlError::ConnectionError, res));
         sqlite3_reset(stmt);
         q->setAt(QSql::AfterLastRow);
         return false;
     }
     return false;
 }

◆ finalize()

void QSQLiteResultPrivate::finalize ( )

Definition at line 149 of file qsql_sqlite.cpp.

Referenced by cleanup(), QSQLiteDriver::close(), QSQLiteResult::exec(), and QSQLiteResult::prepare().

 {
     if (!stmt)
         return;
 
     sqlite3_finalize(stmt);
     stmt = 0;
 }

◆ initColumns()

void QSQLiteResultPrivate::initColumns ( bool emptyResultset )

Definition at line 158 of file qsql_sqlite.cpp.

Referenced by fetchNext().

 {
     int nCols = sqlite3_column_count(stmt);
     if (nCols <= 0)
         return;
 
     q->init(nCols);
 
     for (int i = 0; i < nCols; ++i) {
         QString colName = QString(reinterpret_cast<const QChar *>(
                     sqlite3_column_name16(stmt, i))
                     ).remove(QLatin1Char('"'));
 
         // must use typeName for resolving the type to match QSqliteDriver::record
         QString typeName = QString(reinterpret_cast<const QChar *>(
                     sqlite3_column_decltype16(stmt, i)));
         // sqlite3_column_type is documented to have undefined behavior if the result set is empty
         int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
 
         QVariant::Type fieldType;
 
         if (!typeName.isEmpty()) {
             fieldType = qGetColumnType(typeName);
         } else {
             // Get the proper type for the field based on stp value
             switch (stp) {
             case SQLITE_INTEGER:
                 fieldType = QVariant::Int;
                 break;
             case SQLITE_FLOAT:
                 fieldType = QVariant::Double;
                 break;
             case SQLITE_BLOB:
                 fieldType = QVariant::ByteArray;
                 break;
             case SQLITE_TEXT:
                 fieldType = QVariant::String;
                 break;
             case SQLITE_NULL:
             default:
                 fieldType = QVariant::Invalid;
                 break;
             }
         }
 
         QSqlField fld(colName, fieldType);
         fld.setSqlType(stp);
         rInf.append(fld);
     }
 }