UnipaxId UniPAX::mysql::MySQLManager::getRelationshipXrefId(std::string db, std::string id)
{
if (initDatabase())
{
try
{
odb::session s;
odb::transaction t (odb_db->begin ());
odb::result< ::UniPAX::RelationshipXref> rx (odb_db->query< ::UniPAX::RelationshipXref> (odb::query< ::UniPAX::RelationshipXref>::db == odb::query< ::UniPAX::RelationshipXref>::_val(db)
&& odb::query< ::UniPAX::RelationshipXref>::id == odb::query< ::UniPAX::RelationshipXref>::_val(id)));
for (odb::result< ::UniPAX::RelationshipXref>::iterator rx_it (rx.begin ()); rx_it != rx.end (); ++rx_it)
{
return rx_it->getUnipaxId();
}
}
catch (const odb::exception& e)
{
std::cerr << "MySQLManager::getRelationshipXrefId: odb_exception - " << e.what() << std::endl;
return 0;
}
}
return 0;
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QApplication app(argc, argv);
app.setOrganizationName("HildonEvents");
app.setApplicationName("Event Feed");
app.setApplicationVersion("0.5.0");
app.setQuitOnLastWindowClosed(false);
initDatabase();
QScopedPointer<EventFeed> feed(EventFeed::instance());
QScopedPointer<EventFeedUi> ui(EventFeedUi::instance());
QScopedPointer<Settings> settings(Settings::instance());
const QStringList args = app.arguments();
if (args.contains("--window")) {
ui.data()->showWindow();
}
if (args.contains("--widget")) {
ui.data()->showWidget();
}
return app.exec();
}
bool UniPAX::mysql::MySQLManager::getProteinReferenceIds(std::map<UnipaxId, std::string>& proteinref_ids)
{
if (initDatabase())
{
try
{
odb::session s;
odb::transaction t (odb_db->begin ());
std::vector<boost::shared_ptr<Xref> >::iterator xref_it;
odb::result< ::UniPAX::ProteinReference> r (odb_db->query< ::UniPAX::ProteinReference> ());
for (odb::result< ::UniPAX::ProteinReference>::iterator prot_it (r.begin ()); prot_it != r.end (); ++prot_it)
{
for (xref_it = prot_it->getXrefs().begin(); (xref_it != prot_it->getXrefs().end()); xref_it++)
{
if (((*xref_it)->getDb() == "UniProt") || ((*xref_it)->getDb() == "UniProtKB"))
{
proteinref_ids[prot_it->getUnipaxId()] = (*xref_it)->getId();
}
}
}
return true;
}
catch (const odb::exception& e)
{
std::cerr << "MySQLManager::getProteinReferenceIds: odb_exception - " << e.what() << std::endl;
return false;
}
}
return false;
}
bool UniPAX::mysql::MySQLManager::getObjectsByType(std::vector<boost::shared_ptr<UniPAX::UPBase> > & result, std::string type, bool recursive)
{
if (initDatabase())
{
std::set<std::string> children = UniPAX::Kernel::children(type, recursive);
children.insert(type);
std::vector<UnipaxId> ids;
for (std::set<std::string>::iterator it = children.begin(); it != children.end(); ++it)
{
QSqlQuery query = exec(QString("SELECT unipaxId FROM `%1`").arg(QString::fromStdString(*it)), QString("Unable to get objects of type %1").arg(QString::fromStdString(*it)));
while (query.next())
{
UnipaxId id = query.value(0).toULongLong();
ids.push_back(id);
}
}
return getObjectsByIDs(result, ids);
}
return false;
}
void QuranDbHelper::loadTranslationLanguages(){
QString query = "SELECT * from translations";
if (!mDb.isOpen()){
if (!initDatabase()) {
qDebug() << "fail to open database " << AyatDataModel::mQuranDatabase;
} else {
qDebug() << "succes open database " << AyatDataModel::mQuranDatabase;
}
}
// Execute the query.
QSqlQuery sqlQuery(query, mDb);
QSqlError err = sqlQuery.lastError();
if (err.isValid()) {
qWarning() << "SQL reported an error for query: " << query << " error: "
<< mDb.lastError().text();
return;
}else{ // tidak ada error
while(sqlQuery.next()){
qDebug() << "Result: " << sqlQuery.value(0).toString() << sqlQuery.value(1).toString();
}
}
}
bool UniPAX::mysql::MySQLManager::getIdsByType(std::vector<UnipaxId> & ids, std::string type, bool recursive)
{
if (initDatabase())
{
std::set<std::string> children = UniPAX::Kernel::children(type, recursive);
children.insert(type);
ids.clear();
for (std::set<std::string>::iterator it = children.begin(); it != children.end(); ++it)
{
QSqlQuery query = exec(QString("SELECT unipaxId FROM `%1`").arg(QString::fromStdString(*it)), QString("Unable to get ids by type for %1").arg(QString::fromStdString(*it)));
while (query.next())
{
UnipaxId id = query.value(0).toULongLong();
ids.push_back(id);
}
}
return true;
}
return false;
}
SQLiteTestDatabaseInitializer( const SQLiteTestConfig* config)
:m_db_filename(config->filename())
,m_input_filename(config->input_filename())
,m_dump_filename(config->dump_filename())
{
initDatabase();
}
void DatabaseManager::openDatabase()
{
bool db_exists = databaseExists();
//if already open
if (QSqlDatabase::database("main").isValid())
return;
QSqlDatabase database = QSqlDatabase::addDatabase("QSQLITE", "main");
database.setDatabaseName(m_databasePath);
bool open = database.open();
if (!open) {
QString err = database.lastError().text();
QMessageBox::critical(0, QObject::tr("Database Error"),
QObject::tr("Failed to open the database file: %1")
.arg(err));
return;
}
if (!db_exists && open) {
initDatabase(database);
}
//TODO: on next db version
//on open database check db version, if higher don't open it
//and how error message
}
static int iocBuild_2(void)
{
initHookAnnounce(initHookAfterCaLinkInit);
initDrvSup();
initHookAnnounce(initHookAfterInitDrvSup);
initRecSup();
initHookAnnounce(initHookAfterInitRecSup);
initDevSup();
initHookAnnounce(initHookAfterInitDevSup);
dbLockInitRecords(pdbbase);
initDatabase();
dbBkptInit();
initHookAnnounce(initHookAfterInitDatabase);
finishDevSup();
initHookAnnounce(initHookAfterFinishDevSup);
scanInit();
if (asInit()) {
errlogPrintf("iocBuild: asInit Failed.\n");
return -1;
}
dbProcessNotifyInit();
epicsThreadSleep(.5);
initHookAnnounce(initHookAfterScanInit);
initialProcess();
initHookAnnounce(initHookAfterInitialProcess);
return 0;
}
DatabaseController::DatabaseController(QObject *parent)
: QObject(parent)
{
if (!initDatabase())
return;
// fillDatabase();
}
PostgreSQLTestDatabaseInitializer( const PostgreSQLTestConfig* config)
:m_host(config->host())
,m_port(config->port())
,m_dbname(config->dbName())
,m_user(config->user())
,m_password(config->password())
,m_dump_filename(config->dump_filename())
,m_input_filename(config->input_filename())
{
initDatabase();
}
OracleTestDatabaseInitializer( const OracleTestConfig& config)
:m_host(config.host())
,m_port(config.port())
,m_dbname(config.dbName())
,m_user(config.user())
,m_password(config.password())
,m_dump_filename(config.dump_filename())
,m_input_filename(config.input_filename())
{
initDatabase();
}
DatabaseManager::DatabaseManager(const QString& filename) :
__dbFile(filename) {
SDPASSERT(Logger::instancePtr());
Logger* log = Logger::instancePtr();
log->addMessage(Logger::DEBUG, __func__, QString("Initiating application database from file %1...").arg(filename));
if ( openDatabase(filename) ) {
log->addMessage(Logger::INFO, __func__, "Database found and opened.");
if ( __db.tables().isEmpty() ) {
log->addMessage(Logger::INFO, __func__, "Database appears to be empty, setting up entities.");
initDatabase();
}
}
else {
log->addMessage(Logger::CRITICAL, __func__, QString("Failed to open database (%1).").arg(filename));
log->addMessage(Logger::WARNING, __func__, "Initiating new database for application.");
initDatabase();
}
}
HistorySqlStorage::HistorySqlStorage(QObject *parent) :
HistoryStorage(parent), DatabaseMutex(QMutex::NonRecursive)
{
kdebugf();
DatabaseMutex.lock();
initDatabase();
initQueries();
DatabaseMutex.unlock();
}
int main()
{
/*
ofstream out("out.rtf");
out << "Work please!!";
out.close();
*/
Employee base[MAX_SIZE];
initDatabase(base);
startMenuLoop(base);
}
EventReservation::EventReservation(QObject* parent, const QVariantList& args)
: AbstractReservationPlugin(parent, args)
{
new EventAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus();
dbus.registerObject("/Event", this);
dbus.registerService("org.kde.kdenow.event");
m_pluginName = "eventDataExtractor";
connect(this, &EventReservation::extractedData, this, &EventReservation::cacheData);
connect(this, &EventReservation::extractedData, this, &EventReservation::sendDataOverDBus);
initDatabase();
recordsInDatabase();
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QApplication app(argc, argv);
app.setOrganizationName("cuteTube2");
app.setApplicationName("cuteTube2");
Settings settings;
Clipboard clipboard;
Dailymotion dailymotion;
DBusService dbus;
NetworkAccessManagerFactory factory;
Resources resources;
ResourcesPlugins plugins;
Transfers transfers;
Utils utils;
VideoLauncher launcher;
Vimeo vimeo;
YouTube youtube;
initDatabase();
registerTypes();
plugins.load();
settings.setNetworkProxy();
QQmlApplicationEngine engine;
QQmlContext *context = engine.rootContext();
context->setContextProperty("Clipboard", &clipboard);
context->setContextProperty("CookieJar", factory.cookieJar());
context->setContextProperty("Dailymotion", &dailymotion);
context->setContextProperty("DBus", &dbus);
context->setContextProperty("Plugins", &plugins);
context->setContextProperty("Resources", &resources);
context->setContextProperty("Settings", &settings);
context->setContextProperty("Transfers", &transfers);
context->setContextProperty("Utils", &utils);
context->setContextProperty("VideoLauncher", &launcher);
context->setContextProperty("Vimeo", &vimeo);
context->setContextProperty("YouTube", &youtube);
context->setContextProperty("AUDIO_CONVERTOR_ENABLED", (QFile::exists("/usr/bin/ffmpeg"))
|| (QFile::exists("/usr/bin/avconv")));
context->setContextProperty("MAX_RESULTS", MAX_RESULTS);
context->setContextProperty("VERSION_NUMBER", VERSION_NUMBER);
engine.setNetworkAccessManagerFactory(&factory);
engine.load("/opt/cutetube2/qml/main.qml");
return app.exec();
}
Calendar::Calendar(QWidget *parent) : QWidget(parent), m_dateFormat("yyyy-MM-dd HH:mm:ss")
{
initDatabase();
m_listView = new QListView(this);
m_listView->setModel(m_sqlTableModel);
m_listView->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_listDelegate = new ListDelegate();
m_listView->setItemDelegate(m_listDelegate);
m_layout = new QHBoxLayout();
m_layout->addWidget(m_listView);
connect(m_listView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(editEventIndex(QModelIndex)));
this->setLayout(m_layout);
}
bool UniPAX::mysql::MySQLManager::isValid(UnipaxId id)
{
std::string type = DBManager::getType(id, "");
if (type.length() > 0)
{
if (initDatabase())
{
QSqlQuery q = exec(QString("SELECT * FROM %1 WHERE unipaxId = %2 LIMIT 1 ").arg(QString::fromStdString(type), QString::number(id)), QString("Unable to check if %1 is of type %2").arg(id).arg(QString::fromStdString(type)));
if (q.next()) {
return true;
}
}
}
return false;
}
void SqliteWorkHorse::run()
{
initDatabase();
std::stringstream sql_stream;
DM::Logger(DM::Debug) << "running chunk " << id << "/" << this->plow->getTotalChunks();
sql_stream.str("");
sql_stream.clear();
sql_stream << this->plow->GetWorkerQuery() << " limit " << start << "," << end;
this->execute_query(sql_stream.str().c_str(), true);
sqlite3_close_v2(db);
this->plow->register_results(result_vector);
DM::Logger(DM::Debug) << "done chunk " << id << "/" << this->plow->getTotalChunks();
}
DataStorage::DataStorage() :
isRunning_(false)
{
//create a new database for each session
std::string dbName = "session_" + getCurrentDateStr() + ".db";
bool isInitNeeded = !boost::filesystem::exists(dbName);
connection_.reset(new sqlite::connection(dbName));
//NOTE: Init is always needed, because we're creating a new database at each startup
// Perhaps we should treat it like an error if there is no init needed...
if (isInitNeeded)
{
initDatabase(dbName);
}
//start the storagethread
storageThread_.reset(new boost::thread(boost::bind(&DataStorage::storageLoop, this)));
}
void pgGetLastTemperature(int modul, int sensor, int16_t *temp)
{
float temperature;
char query[255];
PGresult *pgres;
if(!config.database_pg_activated)
return;
if(!pgconn)
{
initDatabase();
}
*temp = 0;
if(!pgconn)
return;
sprintf(query,"SELECT value FROM modul_%02d%02d ORDER BY date DESC LIMIT 1",modul,sensor);
g_debug(query);
pgres = PQexec(pgconn, query);
if (PQresultStatus(pgres) != PGRES_TUPLES_OK)
{
g_warning("failed: %s", PQerrorMessage(pgconn));
PQclear(pgres);
PQfinish(pgconn);
pgconn = NULL;
return;
}
if(PQntuples(pgres) != 1)
return;
temperature = atof(PQgetvalue(pgres,0,0));
g_debug("temperature = %f",temperature);
*temp = (int16_t)(temperature*10.0);
PQclear(pgres);
}
static void getMinMaxTemp(int modul, int sensor, float *max, float *min)
{
char query[255];
char *c;
PGresult *res;
*min = 0.0;
*max = 0.0;
if(!pgconn)
{
initDatabase();
}
if(!pgconn)
return;
sprintf(query,"SELECT MAX(value), MIN(value) FROM modul_%02d%02d WHERE date>current_date",modul,sensor);
res = PQexec(pgconn, query);
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
fprintf(stderr, "FETCH ALL failed: %s", PQerrorMessage(pgconn));
PQclear(res);
return;
}
if(PQntuples(res) != 1)
{
g_debug("Keine Daten fuer den Graphen vorhanden!");
*max = -1000.0;
*min = -1000.0;
PQclear(res);
return;
}
c = PQgetvalue(res,0,0);
*max = atof(c);
c = PQgetvalue(res,0,1);
*min = atof(c);
PQclear(res);
}
bool UniPAX::mysql::MySQLManager::listPathwaysById(std::map<UnipaxId, std::vector<UnipaxId> >& pathways)
{
if (initDatabase())
{
QSqlQuery query = exec("SELECT dataSource, unipaxId FROM Entity WHERE typeid='UniPAX::Pathway' AND dataSource IS NOT NULL", "Unable to list pathways by id");
while (query.next())
{
if (pathways.find(query.value(0).toULongLong()) != pathways.end())
pathways[query.value(0).toULongLong()].push_back(query.value(1).toULongLong());
else
{
std::vector<UnipaxId> tmp;
pathways[query.value(0).toULongLong()] = tmp;
pathways[query.value(0).toULongLong()].push_back(query.value(1).toULongLong());
}
}
return true;
}
return false;
}
RollbackManager::RollbackManager(const std::string & world_path,
IGameDef * gamedef_) :
gamedef(gamedef_)
{
verbosestream << "RollbackManager::RollbackManager(" << world_path
<< ")" << std::endl;
std::string txt_filename = world_path + DIR_DELIM "rollback.txt";
std::string migrating_flag = txt_filename + ".migrating";
database_path = world_path + DIR_DELIM "rollback.sqlite";
bool created = initDatabase();
if (fs::PathExists(txt_filename) && (created ||
fs::PathExists(migrating_flag))) {
std::ofstream of(migrating_flag.c_str());
of.close();
migrate(txt_filename);
fs::DeleteSingleFileOrEmptyDirectory(migrating_flag);
}
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QApplication app(argc, argv);
app.setOrganizationName("MusiKloud2");
app.setApplicationName("MusiKloud2");
app.setApplicationVersion(VERSION_NUMBER);
app.setWindowIcon(QIcon::fromTheme("musikloud2"));
const QStringList args = app.arguments();
const int verbosity = args.indexOf("-v") + 1;
if ((verbosity > 1) && (verbosity < args.size())) {
Logger::setVerbosity(qMax(1, args.at(verbosity).toInt()));
}
else {
Logger::setFileName(Settings::loggerFileName());
Logger::setVerbosity(Settings::loggerVerbosity());
}
QScopedPointer<AudioPlayer> player(AudioPlayer::instance());
QScopedPointer<Settings> settings(Settings::instance());
QScopedPointer<PluginManager> plugins(PluginManager::instance());
QScopedPointer<SoundCloud> soundcloud(SoundCloud::instance());
QScopedPointer<Transfers> transfers(Transfers::instance());
initDatabase();
Settings::setNetworkProxy();
SoundCloud::init();
plugins.data()->load();
transfers.data()->restore();
if (Settings::restorePlaybackQueueOnStartup()) {
player.data()->restoreQueue();
}
MainWindow window;
window.show();
return app.exec();
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QApplication app(argc, argv);
app.setOrganizationName("MusiKloud2");
app.setApplicationName("MusiKloud2");
app.setApplicationVersion(VERSION_NUMBER);
app.setWindowIcon(QIcon::fromTheme("musikloud2"));
Settings settings;
Clipboard clipboard;
DBusService dbus;
Resources resources;
ResourcesPlugins plugins;
SoundCloud soundcloud;
Transfers transfers;
Utils utils;
initDatabase();
registerTypes();
plugins.load();
settings.setNetworkProxy();
QQmlApplicationEngine engine;
QQmlContext *context = engine.rootContext();
context->setContextProperty("Clipboard", &clipboard);
context->setContextProperty("DBus", &dbus);
context->setContextProperty("Plugins", &plugins);
context->setContextProperty("Resources", &resources);
context->setContextProperty("Settings", &settings);
context->setContextProperty("SoundCloud", &soundcloud);
context->setContextProperty("Transfers", &transfers);
context->setContextProperty("Utils", &utils);
context->setContextProperty("MAX_RESULTS", MAX_RESULTS);
context->setContextProperty("VERSION_NUMBER", VERSION_NUMBER);
engine.load("/opt/musikloud2/qml/main.qml");
return app.exec();
}
bool QuranDbHelper::queryDatabase(const QString query) {
if (!mDb.isOpen()){
if (!initDatabase()) {
qDebug() << "fail to open database " << AyatDataModel::mQuranDatabase;
} else {
qDebug() << "succes open database " << AyatDataModel::mQuranDatabase;
}
}
// Execute the query.
QSqlQuery sqlQuery(query, mDb);
QSqlError err = sqlQuery.lastError();
if (err.isValid()) {
qWarning() << "SQL reported an error for query: " << query << " error: "
<< mDb.lastError().text();
return false;
}
return true;
}
bool UniPAX::mysql::MySQLManager::listPathways(std::multimap<std::string, std::string>& pathways)
{
if (initDatabase())
{
QSqlQuery query = exec("SELECT pn.value, p.standardName, p.displayName FROM Entity p, Provenance_name pn WHERE p.typeid='UniPAX::Pathway' AND p.dataSource = pn.object_id AND pn.index = 0", "Unable to list pathways from database.");
while (query.next())
{
// if (query.value(1).isNull() || query.value(1).toString().isEmpty())
// {
// pathways.insert(std::pair<std::string, std::string>(query.value(0).toString().toStdString(),query.value(2).toString().toStdString()));
// }
// else
// {
pathways.insert(std::pair<std::string, std::string>(query.value(0).toString().toStdString(),query.value(1).toString().toStdString()));
// }
}
return true;
}
return false;
}
DBAccess::DBAccess(QDir home)
{
initDatabase(home);
}
