bool TSqlObject::remove()
{
syncToSqlRecord();
QString del = TActionContext::currentDatabase().driver()->sqlStatement(QSqlDriver::DeleteStatement, tableName(), *static_cast<QSqlRecord *>(this), false);
if (del.isEmpty()) {
sqlError = QSqlError(QLatin1String("Unable to delete row"),
QString(), QSqlError::StatementError);
return false;
}
del.append(" WHERE ");
int revIndex = metaObject()->indexOfProperty(REVISION_PROPERTY_NAME);
if (revIndex >= 0) {
bool ok;
int revsion = property(REVISION_PROPERTY_NAME).toInt(&ok);
if (!ok || revsion <= 0) {
sqlError = QSqlError(QLatin1String("Unable to convert the 'revision' property to an int"),
QString(), QSqlError::UnknownError);
tError("Unable to convert the 'revsion' property to an int, %s", qPrintable(objectName()));
return false;
}
del.append(TSqlQuery::escapeIdentifier(REVISION_PROPERTY_NAME));
del.append("=").append(TSqlQuery::formatValue(revsion));
del.append(" AND ");
}
const char *pkName = metaObject()->property(metaObject()->propertyOffset() + primaryKeyIndex()).name();
if (primaryKeyIndex() < 0 || !pkName) {
QString msg = QString("Not found the primary key for table ") + tableName();
sqlError = QSqlError(msg, QString(), QSqlError::StatementError);
tError("%s", qPrintable(msg));
return false;
}
del.append(TSqlQuery::escapeIdentifier(pkName));
del.append("=").append(TSqlQuery::formatValue(property(pkName)));
tSystemDebug("SQL statement: %s", qPrintable(del));
QSqlQuery query(TActionContext::currentDatabase());
bool res = query.exec(del);
sqlError = query.lastError();
if (!res) {
tSystemError("SQL delete error: %s", qPrintable(sqlError.text()));
return false;
}
// Optimistic lock check
if (query.numRowsAffected() != 1) {
if (revIndex >= 0) {
QString msg = QString("Row was updated or deleted from table ") + tableName() + QLatin1String(" by another transaction");
sqlError = QSqlError(msg, QString(), QSqlError::UnknownError);
throw SqlException(msg, __FILE__, __LINE__);
}
tWarn("Row was deleted by another transaction, %s", qPrintable(tableName()));
}
clear();
return true;
}
void
QueryBuilder::addReturnFunctionValue( int function, int table, int value)
{
if ( !m_values.isEmpty() && m_values != "DISTINCT " ) m_values += ",";
m_values += functionName( function ) + "(";
m_values += tableName( table ) + ".";
m_values += valueName( value )+ ")";
m_values += " AS ";
m_values += functionName( function )+tableName( table )+valueName( value );
m_linkTables |= table;
m_returnValues++;
}
/* forwardPacket()
*
* Forwards a packet from the source to destination
*/
void forwardPacket(struct packet *p, struct router** network) {
char src = p->srcNode;
char dst = p->dstNode;
int index = 0;
int i;
int destIndex;
int outgoing;
char nextRouter;
struct router* curr = malloc(NUMROUTERS * sizeof(struct router));
curr = routerToTable(network, src);
p->arrivalPort = routerToPort(tableName(curr));
while (tableName(curr) != dst) {
destIndex = getDestPortIndex(curr, routerToPort(dst));
outgoing = curr->outgoingPorts[destIndex];
p->forwardingPort = outgoing;
outputPacket(curr, p, false);
if (outgoing == routerToPort(tableName(curr))) {
// next router is going to be destination router
break;
}
nextRouter = portToRouter(outgoing);
curr = routerToTable(network, nextRouter);
index++;
}
// Reached destination router
struct router* dstRouter = malloc(NUMROUTERS * sizeof(struct router));
dstRouter = routerToTable(network, dst);
outputPacket(dstRouter, p, true);
return;
// while current router is not destination router
// get index of destination port
// use index to get outgoing port
// write to output timestamp, src node, dst node, arrival UDP port, and outgoing UDP port
// assign arrival port and forwarding port
// if outgoing port is same as current port (next router is dst router)
// break;
// at destination router...
// output data (message)
// output src and dst router
// output each arrival and outgoing port that isn't equal to 0
}
bool GameLibraryModel::select()
{
const QString query = selectStatement();
if (query.isEmpty())
return false;
beginResetModel();
// d->clearCache();
QSqlQuery qu(database());
qu.prepare(query);
for (auto &val : params) {
qu.addBindValue(val);
}
qu.exec();
setQuery(qu);
if (!qu.isActive() || lastError().isValid()) {
setTable(tableName()); // resets the record & index
endResetModel();
return false;
}
endResetModel();
return true;
}
void PlayListDb::shuffle(QString playListName) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QString tn = tableName(playListName);
QStringList sl;
QSqlQuery findQuery(QString("select FileName from %1 order by RAND()").arg(tableName(playListName)));
if (!findQuery.isActive()) {
qDebug() << db.lastError().text();
qDebug() << "Unable to execute: " << findQuery.lastQuery();
}
while (findQuery.next()) {
sl << findQuery.value(0).toString();
}
clear(playListName);
foreach (const QString& fn, sl) {
addFile(playListName, fn);
}
MStudy::MStudy(const MStudy& cpy) :
mPatientID(cpy.mPatientID),
mStudyInstanceUID(cpy.mStudyInstanceUID),
mConceptualStudyUID(cpy.mConceptualStudyUID),
mStudyID(cpy.mStudyID),
mStudyDate(cpy.mStudyDate),
mStudyTime(cpy.mStudyTime),
mAccessionNumber(cpy.mAccessionNumber),
mReferringPhysicianName(cpy.mReferringPhysicianName),
mStudyDescription(cpy.mStudyDescription),
mPatientAge(cpy.mPatientAge),
mPatientSize(cpy.mPatientSize),
mModalitiesInStudy(cpy.mModalitiesInStudy),
mNumberStudyRelatedSeries(cpy.mNumberStudyRelatedSeries),
mNumberStudyRelatedInstances(cpy.mNumberStudyRelatedInstances)
{
tableName("study");
insert("patid", mPatientID);
insert("stuinsuid", mStudyInstanceUID);
insert("constuuid", mConceptualStudyUID);
insert("stuid", mStudyID);
insert("studat", mStudyDate);
insert("stutim", mStudyTime);
insert("accnum", mAccessionNumber);
insert("refphynam", mReferringPhysicianName);
insert("studes", mStudyDescription);
insert("patage", mPatientAge);
insert("patsiz", mPatientSize);
insert("modinstu", mModalitiesInStudy);
insert("numser", mNumberStudyRelatedSeries);
insert("numins", mNumberStudyRelatedInstances);
//insert("patsex", mPatientSex);
}
void
QueryBuilder::addMatch( int tables, int value, const QString& match )
{
if ( !match.isEmpty() )
{
m_where += "AND ( true ";
m_where += QString( "OR %1.%2 LIKE '" ).arg( tableName( tables ) ).arg( valueName( value ) ) + escapeString( match ) + "' ";
if ( ( value & valName ) && match == i18n( "Unknown" ) )
m_where += QString( "OR %1.%2 = '' " ).arg( tableName( tables ) ).arg( valueName( value ) );
m_where += " ) ";
}
m_linkTables |= tables;
}
MSOPInstance::MSOPInstance(const MSOPInstance& cpy) :
mSeriesInstanceUID(cpy.mSeriesInstanceUID),
mClassUID(cpy.mClassUID),
mInstanceUID(cpy.mInstanceUID),
mInstanceNumber(cpy.mInstanceNumber),
mRows(cpy.mRows),
mColumns(cpy.mColumns),
mBitsAllocated(cpy.mBitsAllocated),
mNumberOfFrames(cpy.mNumberOfFrames),
mPresentationLabel(cpy.mPresentationLabel),
mPresentationDescription(cpy.mPresentationDescription),
mPresentationCreationDate(cpy.mPresentationCreationDate),
mPresentationCreationTime(cpy.mPresentationCreationTime),
mPresentationCreatorsName(cpy.mPresentationCreatorsName),
mCompletionFlag(cpy.mCompletionFlag),
mVerificationFlag(cpy.mVerificationFlag),
mContentDate(cpy.mContentDate),
mContentTime(cpy.mContentTime),
mObservationDateTime(cpy.mObservationDateTime),
mConceptNameCodeValue(cpy.mConceptNameCodeValue),
mConceptNameCodeScheme(cpy.mConceptNameCodeScheme),
mConceptNameCodeVersion(cpy.mConceptNameCodeVersion),
mConceptNameCodeMeaning(cpy.mConceptNameCodeMeaning),
mFileName(cpy.mFileName),
mDocTitle(cpy.mDocTitle)
{
tableName("sopins");
this->fillMap();
}
void DDLIndexPopulator::makeCsep(erydbSelectExecutionPlan& csep)
{
csep.sessionID(fSessionID);
csep.txnID(fTxnID);
csep.verID(fSessionManager->verID());
erydbSelectExecutionPlan::ReturnedColumnList colList;
erydbSelectExecutionPlan::ColumnMap colMap;
erydbSystemCatalog::TableColName tableColName;
erydbSystemCatalog::OID oid;
tableColName.schema = fTable.fSchema;
tableColName.table = fTable.fName;
boost::shared_ptr<erydbSystemCatalog> csc = erydbSystemCatalog::makeerydbSystemCatalog( fSessionID );
string tableName(fTable.fSchema + "." + fTable.fName + ".");
ColumnNameList::const_iterator cend = fColNames.end();
for (ColumnNameList::const_iterator cname = fColNames.begin(); cname != cend; ++cname)
{
string fullColName(tableName + *cname);
SRCP srcp(new SimpleColumn (fullColName, fSessionID));
colList.push_back(srcp);
tableColName.column = *cname;
oid = csc->lookupOID( tableColName );
fOidList.push_back( oid );
colMap.insert(erydbSelectExecutionPlan::ColumnMap::value_type(fullColName, srcp));
}
csep.columnMap (colMap);
csep.returnedCols (colList);
}
/*!
Inserts new record into the database, based on the current properties
of the object.
*/
bool TSqlObject::create()
{
// Sets the values of 'created_at', 'updated_at' or 'modified_at' properties
for (int i = metaObject()->propertyOffset(); i < metaObject()->propertyCount(); ++i) {
const char *propName = metaObject()->property(i).name();
QByteArray prop = QByteArray(propName).toLower();
if (prop == CreatedAt || prop == UpdatedAt || prop == ModifiedAt) {
setProperty(propName, QDateTime::currentDateTime());
} else if (prop == LockRevision) {
// Sets the default value of 'revision' property
setProperty(propName, 1); // 1 : default value
} else {
// do nothing
}
}
syncToSqlRecord();
QString autoValName;
QSqlRecord record = *this;
if (autoValueIndex() >= 0) {
autoValName = field(autoValueIndex()).name();
record.remove(autoValueIndex()); // not insert the value of auto-value field
}
QSqlDatabase &database = Tf::currentSqlDatabase(databaseId());
QString ins = database.driver()->sqlStatement(QSqlDriver::InsertStatement, tableName(), record, false);
if (Q_UNLIKELY(ins.isEmpty())) {
sqlError = QSqlError(QLatin1String("No fields to insert"),
QString(), QSqlError::StatementError);
tWarn("SQL statement error, no fields to insert");
return false;
}
TSqlQuery query(database);
bool ret = query.exec(ins);
sqlError = query.lastError();
if (Q_LIKELY(ret)) {
// Gets the last inserted value of auto-value field
if (autoValueIndex() >= 0) {
QVariant lastid = query.lastInsertId();
if (!lastid.isValid() && database.driverName().toUpper() == QLatin1String("QPSQL")) {
// For PostgreSQL without OIDS
ret = query.exec("SELECT LASTVAL()");
sqlError = query.lastError();
if (Q_LIKELY(ret)) {
lastid = query.getNextValue();
}
}
if (lastid.isValid()) {
QObject::setProperty(autoValName.toLatin1().constData(), lastid);
QSqlRecord::setValue(autoValueIndex(), lastid);
}
}
}
return ret;
}
MSOPInstance::MSOPInstance() :
mSeriesInstanceUID(""),
mClassUID(""),
mInstanceUID(""),
mInstanceNumber(""),
mRows(""),
mColumns(""),
mBitsAllocated(""),
mNumberOfFrames(""),
mPresentationLabel(""),
mPresentationDescription(""),
mPresentationCreationDate(""),
mPresentationCreationTime(""),
mPresentationCreatorsName(""),
mCompletionFlag(""),
mVerificationFlag(""),
mContentDate(""),
mContentTime(""),
mObservationDateTime(""),
mConceptNameCodeValue(""),
mConceptNameCodeScheme(""),
mConceptNameCodeVersion(""),
mConceptNameCodeMeaning(""),
mFileName(""),
mDocTitle("")
{
tableName("sopins");
this->fillMap();
}
MGPWorkitem::MGPWorkitem()
{
tableName("gpworkitem");
insert("sopinsuid");
insert("sopclassuid");
insert("status");
insert("inputavailflag");
insert("priority");
insert("procstepid");
insert("startdattim");
insert("enddattim");
insert("resultstuinsuid");
insert("inputstuinsuid");
insert("multcopyflag");
insert("description");
insert("patientid");
insert("patientname");
insert("birthdate");
insert("sex");
insert("workitemcodevalue");
insert("workitemcodescheme");
insert("workitemcodemeaning");
insert("reqprocAccessionNum");
insert("reqprocID");
insert("reqprocDesc");
insert("reqprocCodevalue");
insert("reqprocCodemeaning");
insert("reqprocCodescheme");
insert("requestingPhys");
insert("transactionUID");
}
void synaxErrorJudger::generateTableInfo()
{
int begin = sqlExp.indexOf("table") + 5;
int end = sqlExp.indexOf('(') - 1;
string tableName(sqlExp.mid(begin, end - begin + 1).trimmed().toStdString());
set<string> indexSet;
set<string> uniqueAttribute;
vector<string> attributeNameList;
vector<pair<int, size_t>> dataTypeInfo;
getAttributeInfo(attributeNameList, dataTypeInfo, uniqueAttribute);
int posOfPrimaryKey = getPosOfPrimarykey(attributeNameList), totalOfRecord = 0;
auto it = uniqueAttribute.find(attributeNameList[posOfPrimaryKey]);
if (it == uniqueAttribute.end()) {
uniqueAttribute.insert(it, attributeNameList[posOfPrimaryKey]);
}
indexSet.insert(uniqueAttribute.begin(), uniqueAttribute.end());
if (tInfo == 0) {
tInfo = new tableInfo(tableName, attributeNameList, dataTypeInfo,
posOfPrimaryKey, indexSet, totalOfRecord, uniqueAttribute);
}
else {
*tInfo = tableInfo(tableName, attributeNameList, dataTypeInfo,
posOfPrimaryKey, indexSet, totalOfRecord, uniqueAttribute);
}
}
void
QueryBuilder::sortByFunction( int function, int table, int value, bool descending )
{
// This function should be used with the equivalent addReturnFunctionValue (with the same function on same values)
// since it uses the "func(table.value) AS functablevalue" definition.
//shall we sort case-sensitively? (not for integer columns!)
bool b = true;
if ( value & valID || value & valTrack || value & valScore || value & valLength || value & valBitrate ||
value & valSamplerate || value & valPlayCounter || value & valAccessDate || value & valCreateDate || value & valPercentage ||
table & tabYear )
b = false;
if ( !m_sort.isEmpty() ) m_sort += ",";
//m_sort += functionName( function ) + "(";
if ( b ) m_sort += "LOWER( ";
if ( table & tabYear ) m_sort += "(";
QString columnName = functionName( function )+tableName( table )+valueName( value );
m_sort += columnName;
if ( table & tabYear ) m_sort += "+0)";
if ( b ) m_sort += " ) ";
//m_sort += " ) ";
if ( descending ) m_sort += " DESC ";
m_linkTables |= table;
}
void MissingTableModel::setTableModel(int id) {
Q_UNUSED(id);
QSqlQuery query(m_database);
//query.prepare("DROP VIEW " + playlistTableName);
//query.exec();
QString tableName("missing_songs");
QStringList columns;
columns << "library." + LIBRARYTABLE_ID;
query.prepare("CREATE TEMPORARY VIEW IF NOT EXISTS " + tableName + " AS "
"SELECT "
+ columns.join(",") +
" FROM library "
"INNER JOIN track_locations "
"ON library.location=track_locations.id "
"WHERE " + MissingTableModel::MISSINGFILTER);
if (!query.exec()) {
qDebug() << query.executedQuery() << query.lastError();
}
//Print out any SQL error, if there was one.
if (query.lastError().isValid()) {
qDebug() << __FILE__ << __LINE__ << query.lastError();
}
QStringList tableColumns;
tableColumns << LIBRARYTABLE_ID;
setTable(tableName, LIBRARYTABLE_ID, tableColumns,
m_pTrackCollection->getTrackSource());
setDefaultSort(fieldIndex("artist"), Qt::AscendingOrder);
setSearch("");
}
MCodeItem::MCodeItem()
{
tableName("codeitem");
insert("codval");
insert("codschdes");
insert("codmea");
insert("reqproid");
}
MPerfStationLocation::MPerfStationLocation()
{
tableName("perfstationlocation");
insert("codval");
insert("codschdes");
insert("codmea");
insert("workitemkey");
}
QString PlayListDb::last(QString playListName) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QSqlQuery findQuery(QString("select FileName from %1 order by pid DESC limit 1")
.arg(tableName(playListName)));
if (!findQuery.isActive()) return QString();
findQuery.next();
return findQuery.value(0).toString();
}
MGPWorkitem::MGPWorkitem(const MGPWorkitem& cpy) :
mSOPInstanceUID(cpy.mSOPInstanceUID),
mSOPClassUID(cpy.mSOPClassUID),
mStatus(cpy.mStatus),
mInputAvailabilityFlag(cpy.mInputAvailabilityFlag),
mPriority(cpy.mPriority),
mProcedureStepID(cpy.mProcedureStepID),
mStartDateTime(cpy.mStartDateTime),
mEndDateTime(cpy.mEndDateTime),
mResultStudyInstanceUID(cpy.mResultStudyInstanceUID),
mInputStudyInstanceUID(cpy.mInputStudyInstanceUID),
mMultipleCopiesFlag(cpy.mMultipleCopiesFlag),
mDescription(cpy.mDescription),
mPatientID(cpy.mPatientID),
mPatientName(cpy.mPatientName),
mPatientBirthDate(cpy.mPatientBirthDate),
mPatientSex(cpy.mPatientSex),
mWorkItemCodeValue(cpy.mWorkItemCodeValue),
mWorkItemCodeScheme(cpy.mWorkItemCodeScheme),
mWorkItemCodeMeaning(cpy.mWorkItemCodeMeaning),
mRequestedProcAccessionNum(cpy.mRequestedProcAccessionNum),
mRequestedProcID(cpy.mRequestedProcID),
mRequestedProcDesc(cpy.mRequestedProcDesc),
mRequestedProcCodevalue(cpy.mRequestedProcCodevalue),
mRequestedProcCodemeaning(cpy.mRequestedProcCodemeaning),
mRequestedProcCodescheme(cpy.mRequestedProcCodescheme),
mRequestingPhysician(cpy.mRequestingPhysician),
mTransactionUID(cpy.mTransactionUID)
{
tableName("gpworkitem");
insert("sopinsuid", mSOPInstanceUID);
insert("sopclassuid", mSOPClassUID);
insert("status", mStatus);
insert("inputavailflag", mInputAvailabilityFlag);
insert("priority", mPriority);
insert("procstepid", mProcedureStepID);
insert("startdattim", mStartDateTime);
insert("enddattim", mEndDateTime);
insert("resultstuinsuid", mResultStudyInstanceUID);
insert("inputstuinsuid", mInputStudyInstanceUID);
insert("multcopyflag", mMultipleCopiesFlag);
insert("description", mDescription);
insert("patientid", mPatientID);
insert("patientname", mPatientName);
insert("birthdate", mPatientBirthDate);
insert("sex", mPatientSex);
insert("workitemcodevalue", mWorkItemCodeValue);
insert("workitemcodescheme", mWorkItemCodeScheme);
insert("workitemcodemeaning", mWorkItemCodeMeaning);
insert("reqprocAccessionNum", mRequestedProcAccessionNum);
insert("reqprocID", mRequestedProcID);
insert("reqprocDesc", mRequestedProcDesc);
insert("reqprocCodevalue", mRequestedProcCodevalue);
insert("reqprocCodemeaning", mRequestedProcCodemeaning);
insert("reqprocCodescheme", mRequestedProcCodescheme);
insert("requestingPhys", mRequestingPhysician);
insert("transactionUID", mTransactionUID);
}
void
QueryBuilder::linkTables( int tables )
{
m_tables = tableName( tabSong );
if ( !(tables & tabSong ) )
{
// check if only one table is selected (does somebody know a better way to check that?)
if (tables == tabAlbum || tables==tabArtist || tables==tabGenre || tables == tabYear || tables == tabStats)
m_tables = tableName(tables);
else
tables |= tabSong;
}
if ( tables & tabSong )
{
if ( tables & tabAlbum )
m_tables += " INNER JOIN " + tableName( tabAlbum) + " ON album.id=tags.album";
if ( tables & tabArtist )
m_tables += " INNER JOIN " + tableName( tabArtist) + " ON artist.id=tags.artist";
if ( tables & tabGenre )
m_tables += " INNER JOIN " + tableName( tabGenre) + " ON genre.id=tags.genre";
if ( tables & tabYear )
m_tables += " INNER JOIN " + tableName( tabYear) + " ON year.id=tags.year";
if ( tables & tabStats )
m_tables += " INNER JOIN " + tableName( tabStats) + " ON statistics.url=tags.url";
}
}
MDICOMApp::MDICOMApp()
{
tableName("dicomapp");
insert("aet");
insert("host");
insert("port");
insert("org");
insert("com");
}
void
QueryBuilder::exclusiveFilter( int tableMatching, int tableNotMatching, int value )
{
m_join += " LEFT JOIN ";
m_join += tableName( tableNotMatching );
m_join += " ON ";
m_join += tableName( tableMatching ) + ".";
m_join += valueName( value );
m_join+= " = ";
m_join += tableName( tableNotMatching ) + ".";
m_join += valueName( value );
m_where += " AND ";
m_where += tableName( tableNotMatching ) + ".";
m_where += valueName( value );
m_where += " IS null ";
}
void
QueryBuilder::groupBy( int table, int value )
{
if ( !m_group.isEmpty() ) m_group += ",";
m_group += tableName( table ) + ".";
m_group += valueName( value );
m_linkTables |= table;
}
MCodeItem::MCodeItem(const MCodeItem& cpy) :
mCodeValue(cpy.mCodeValue),
mCodeMeaning(cpy.mCodeMeaning),
mCodeSchemeDesignator(cpy.mCodeSchemeDesignator)
{
tableName("codeitem");
insert("codval", cpy.mCodeValue);
insert("codmea", cpy.mCodeMeaning);
insert("codschdes", cpy.mCodeSchemeDesignator);
}
bool PlayListDb::clear(QString playListName) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QSqlQuery drop(QString("delete from %1").arg(tableName(playListName)));
// QSqlQuery drop(QString("drop table %1").arg(tableName(playListName)));
if (!drop.isActive()) {
qDebug() << "Failed: " << drop.lastError().text();
qDebug() << " " << drop.lastQuery();
return false;
}
return true;
}
void KData::serializeToDB(DBWrapper& db){
std::string tableName(m_InstrumentID);
tableName += "_1m";
KData::CreateKDataTableIfNotExists(Config::Instance()->DBName(), tableName);
std::stringstream sql;
sql << "INSERT INTO `" << tableName << "` (`";
sql << "Time" << "`,`";
sql << "InstrumentID" << "`,`";
sql << "LastPrice" << "`,`";
sql << "PreSettlementPrice" << "`,`";
sql << "PreClosePrice" << "`,`";
sql << "OpenPrice" << "`,`";
sql << "HighestPrice" << "`,`";
sql << "LowestPrice" << "`,`";
sql << "Volume" << "`,`";
sql << "Turnover" << "`,`";
sql << "ClosePrice" << "`,`";
sql << "SettlementPrice" << "`,`";
sql << "UpperLimitPrice" << "`,`";
sql << "LowerLimitPrice" << "`,`";
sql << "BidPrice1" << "`,`";
sql << "BidVolume1" << "`,`";
sql << "AskPrice1" << "`,`";
sql << "AskVolume1" << "`,`";
sql << "AveragePrice" << "`,`";
sql << "uuid" << "`";
sql << ") VALUES(\"";
sql << m_time << "\", \"";
sql << m_InstrumentID << "\", ";
sql << m_LastPrice << ", ";
sql << m_PreSettlementPrice << ", ";
sql << m_PreClosePrice << ", ";
sql << m_OpenPrice << ", ";
sql << m_HighestPrice << ", ";
sql << m_LowestPrice << ", ";
sql << m_volume << ", ";
sql << m_Turnover << ", ";
sql << m_ClosePrice << ", ";
sql << m_SettlementPrice << ", ";
sql << m_UpperLimitPrice << ", ";
sql << m_LowerLimitPrice << ", ";
sql << m_BidPrice1 << ", ";
sql << m_BidVolume1 << ", ";
sql << m_AskPrice1 << ", ";
sql << m_AskVolume1 << ", ";
sql << m_averagePrice << ", ";
sql << m_timestamp << ")";
//"INSERT INTO `test` (`name`) VALUES (1234)
//std::cerr << sql.str() << std::endl;
db.ExecuteNoResult(sql.str());
}
bool PlayListDb::removeEntry(QString playList, int pid) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QString tn = tableName(playList);
QSqlRecord record = db.record(tn);
Q_ASSERT(!record.isEmpty());
QString queryString=QString("delete from %1 where pid=%2")
.arg(tn).arg(pid);
QSqlQuery q(queryString);
qDebug() << queryString;
return q.isActive();
}
MPerfStationLocation::MPerfStationLocation(const MPerfStationLocation& cpy) :
mCodeValue(cpy.mCodeValue),
mCodeMeaning(cpy.mCodeMeaning),
mCodeSchemeDesignator(cpy.mCodeSchemeDesignator),
mWorkitemkey(cpy.mWorkitemkey)
{
tableName("perfstationlocation");
insert("codval", cpy.mCodeValue);
insert("codmea", cpy.mCodeMeaning);
insert("codschdes", cpy.mCodeSchemeDesignator);
insert("workitemkey", cpy.mWorkitemkey);
}
QStringList PlayListDb::playList(QString playListName) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QStringList sl;
QSqlQuery findQuery(QString("select FileName from %1 order by pid").arg(tableName(playListName)));
if (!findQuery.isActive()) {
qDebug() << db.lastError().text();
qDebug() << "Unable to execute: " << findQuery.lastQuery();
}
while (findQuery.next()) {
sl << findQuery.value(0).toString();
}
return sl;
}
/*!
Synchronizes the properties to the internal record data.
This function is for internal use only.
*/
void TSqlObject::syncToSqlRecord()
{
QSqlRecord::operator=(Tf::currentSqlDatabase(databaseId()).record(tableName()));
const QMetaObject *metaObj = metaObject();
for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
const char *propName = metaObj->property(i).name();
int idx = indexOf(propName);
if (idx >= 0) {
QSqlRecord::setValue(idx, QObject::property(propName));
} else {
tWarn("invalid name: %s", propName);
}
}
}
