QVariant QSymSQLResult::data(int idx)
{
QVariant r;
switch (d->stmt.ColumnType(idx)) {
case ESqlBinary:
{
TPtrC8 data;
d->stmt.ColumnBinary(idx, data);
return QByteArray(reinterpret_cast<const char *>(data.Ptr()), data.Length());
break;
}
case ESqlInt:
r = QVariant(d->stmt.ColumnInt(idx));
break;
case ESqlInt64:
r = QVariant(d->stmt.ColumnInt64(idx));
break;
case ESqlReal:
switch(numericalPrecisionPolicy()) {
case QSql::LowPrecisionInt32:
r = QVariant(d->stmt.ColumnInt(idx));
break;
case QSql::LowPrecisionInt64:
r = QVariant(d->stmt.ColumnInt64(idx));
break;
case QSql::LowPrecisionDouble:
r = QVariant(d->stmt.ColumnReal(idx));
break;
case QSql::HighPrecision:
default:
TPtrC res;
d->stmt.ColumnText(idx, res);
r = QVariant(qt_TDesC2QString(res));
break;
};
break;
case ESqlNull:
r = QVariant(QVariant::String);
break;
default:
TPtrC res;
d->stmt.ColumnText(idx, res);
r = QVariant(qt_TDesC2QString(res));
break;
}
return r;
}
QVariant embeddedResult::data(int field)
{
if (!isSelect() || field >= d->fields.count()) {
printf("embeddedResult::data: column %d out of range", field);
return QVariant();
}
if (!d->driver)
return QVariant();
int fieldLength = 0;
const embeddedResultPrivate::QMyField &f = d->fields.at(field);
QString val;
if (d->preparedQuery) {
if (f.nullIndicator)
return QVariant(f.type);
if (f.type != QVariant::ByteArray)
val = toUnicode(d->driver->d->tc, f.outField, f.bufLength);
} else {
if (d->row[field] == NULL) {
// NULL value
return QVariant(f.type);
}
fieldLength = mysql_fetch_lengths(d->result)[field];
if (f.type != QVariant::ByteArray)
val = toUnicode(d->driver->d->tc, d->row[field], fieldLength);
}
switch(f.type) {
case QVariant::LongLong:
return QVariant(val.toLongLong());
case QVariant::ULongLong:
return QVariant(val.toULongLong());
case QVariant::Int:
return QVariant(val.toInt());
case QVariant::UInt:
return QVariant(val.toUInt());
case QVariant::Double: {
QVariant v;
bool ok=false;
double dbl = val.toDouble(&ok);
switch(numericalPrecisionPolicy()) {
case QSql::LowPrecisionInt32:
v=QVariant(dbl).toInt();
break;
case QSql::LowPrecisionInt64:
v = QVariant(dbl).toLongLong();
break;
case QSql::LowPrecisionDouble:
v = QVariant(dbl);
break;
case QSql::HighPrecision:
default:
v = val;
ok = true;
break;
}
if(ok)
return v;
else
return QVariant();
}
return QVariant(val.toDouble());
case QVariant::Date:
return qDateFromString(val);
case QVariant::Time:
return qTimeFromString(val);
case QVariant::DateTime:
return qDateTimeFromString(val);
case QVariant::ByteArray: {
QByteArray ba;
if (d->preparedQuery) {
ba = QByteArray(f.outField, f.bufLength);
} else {
ba = QByteArray(d->row[field], fieldLength);
}
return QVariant(ba);
}
default:
case QVariant::String:
return QVariant(val);
}
printf("embeddedResult::data: unknown data type");
return QVariant();
}
QVariant QPSQLResult::data(int i)
{
if (i >= PQnfields(d->result)) {
qWarning("QPSQLResult::data: column %d out of range", i);
return QVariant();
}
int ptype = PQftype(d->result, i);
QVariant::Type type = qDecodePSQLType(ptype);
const char *val = PQgetvalue(d->result, at(), i);
if (PQgetisnull(d->result, at(), i))
return QVariant(type);
switch (type) {
case QVariant::Bool:
return QVariant((bool)(val[0] == 't'));
case QVariant::String:
return d->driver->isUtf8 ? QString::fromUtf8(val) : QString::fromAscii(val);
case QVariant::LongLong:
if (val[0] == '-')
return QString::fromLatin1(val).toLongLong();
else
return QString::fromLatin1(val).toULongLong();
case QVariant::Int:
return atoi(val);
case QVariant::Double:
if (ptype == QNUMERICOID) {
if (numericalPrecisionPolicy() != QSql::HighPrecision) {
QVariant retval;
bool convert;
double dbl=QString::fromAscii(val).toDouble(&convert);
if (numericalPrecisionPolicy() == QSql::LowPrecisionInt64)
retval = (qlonglong)dbl;
else if (numericalPrecisionPolicy() == QSql::LowPrecisionInt32)
retval = (int)dbl;
else if (numericalPrecisionPolicy() == QSql::LowPrecisionDouble)
retval = dbl;
if (!convert)
return QVariant();
return retval;
}
return QString::fromAscii(val);
}
return QString::fromAscii(val).toDouble();
case QVariant::Date:
if (val[0] == '\0') {
return QVariant(QDate());
} else {
#ifndef QT_NO_DATESTRING
return QVariant(QDate::fromString(QString::fromLatin1(val), Qt::ISODate));
#else
return QVariant(QString::fromLatin1(val));
#endif
}
case QVariant::Time: {
const QString str = QString::fromLatin1(val);
#ifndef QT_NO_DATESTRING
if (str.isEmpty())
return QVariant(QTime());
if (str.at(str.length() - 3) == QLatin1Char('+') || str.at(str.length() - 3) == QLatin1Char('-'))
// strip the timezone
// TODO: fix this when timestamp support comes into QDateTime
return QVariant(QTime::fromString(str.left(str.length() - 3), Qt::ISODate));
return QVariant(QTime::fromString(str, Qt::ISODate));
#else
return QVariant(str);
#endif
}
case QVariant::DateTime: {
QString dtval = QString::fromLatin1(val);
#ifndef QT_NO_DATESTRING
if (dtval.length() < 10)
return QVariant(QDateTime());
// remove the timezone
// TODO: fix this when timestamp support comes into QDateTime
if (dtval.at(dtval.length() - 3) == QLatin1Char('+') || dtval.at(dtval.length() - 3) == QLatin1Char('-'))
dtval.chop(3);
// milliseconds are sometimes returned with 2 digits only
if (dtval.at(dtval.length() - 3).isPunct())
dtval += QLatin1Char('0');
if (dtval.isEmpty())
return QVariant(QDateTime());
else
return QVariant(QDateTime::fromString(dtval, Qt::ISODate));
#else
return QVariant(dtval);
#endif
}
case QVariant::ByteArray: {
size_t len;
unsigned char *data = PQunescapeBytea((unsigned char*)val, &len);
QByteArray ba((const char*)data, len);
qPQfreemem(data);
return QVariant(ba);
}
default:
case QVariant::Invalid:
qWarning("QPSQLResult::data: unknown data type");
}
return QVariant();
}
