void operator*=(ValueMap& map, SqlSelect select)
{
map.Clear();
Sql sql;
sql * select;
while(sql.Fetch())
map.Add(sql[0], sql[1]);
}
Value SqlStatement::Fetch(Sql& cursor) const {
ASSERT(text.GetCount());
if(!Execute(cursor))
return ErrorValue(SqlExc(cursor.GetSession()));
if(!cursor.Fetch())
return Null;
return cursor[0];
}
String ForceInsertRowid(const String& insert, Sql& cursor)
{
if(!cursor.Execute(insert + " returning ROWID into ?%s"))
throw SqlExc(cursor.GetSession());
if(!cursor.Fetch())
throw Exc(t_("FETCH internal error (ForceInsertRowid)"));
ASSERT(!IsNull(cursor[0]));
return cursor[0];
}
VectorMap<String, SqlColumnInfo> Describe(const SqlVal& table, Sql& cursor)
{
VectorMap<String, SqlColumnInfo> map;
if(cursor * SelectAll().From(table).Where(SqlBool::False()))
for(int i = 0, n = cursor.GetColumns(); i < n; i++)
{
const SqlColumnInfo& sci = cursor.GetColumnInfo(i);
map.Add(sci.name, sci);
}
return map;
}
virtual void Field(const char *name, Ref f) {
if(i) {
clist += ", ";
qlist += ", ";
}
clist += name;
qlist += "? ";
sql->SetParam(i++, f);
}
int SqlError(
#ifdef PLATFORM_WIN32
HWND parent,
#endif
const char *text, const Sql& sql, bool retry) {
return SqlError(
#ifdef PLATFORM_WIN32
parent,
#endif
text, sql.GetSession(), retry);
}
virtual void Field(const char *name, Ref f) {
if(!f.IsNull()) {
if(clist.GetCount()) {
clist += ", ";
qlist += ", ";
}
clist << name;
qlist << "? ";
sql->SetParam(i++, f);
}
}
virtual void Field(const char *name, Ref f) {
if(clist.GetCount()) {
clist += ", ";
qlist += ", ";
}
if(i) {
clist += name;
qlist += "? ";
sql->SetParam(i - 1, f);
}
i++;
}
virtual void Field(const char *name, Ref f) {
if(i == 0) {
key = name;
keyval = f;
}
else {
if(i > 1)
list += ", ";
list << name << " = ?";
sql->SetParam(i - 1, f);
}
i++;
}
bool OkCommit(Sql& sql, const char *emsg) {
return OkCommit(sql.GetSession(), emsg);
}
bool ErrorRollback(Sql& sql, const char *emsg) {
return ErrorRollback(sql.GetSession(), emsg);
}
bool IsNotEmpty(const SqlSelect& select, Sql& cursor)
{
return cursor * select && cursor.Fetch();
}
void SqlStatement::Force(Sql& cursor) const {
ASSERT(text.GetCount());
if(!cursor.Execute(*this))
throw SqlExc(cursor.GetSession());
}
void threadHandler(char driveLtr)
{
/* Lock the mutex so we don't try and access the database at the same time */
gMutex.lock();
bool authorized = false;
/* Lock the USB drive */
UsbOps ops;
ops.lockUSB(driveLtr);
/* Query authorized devices */
Sql sql;
if (!sql.dbConnect((char*)Paths::getDatabasePath().c_str(), false))
{
ErrorLog::logErrorToFile("*CRITICAL*", "Unable to open authorized drives database!");
ops.ejectUSB();
gMutex.unlock();
return;
}
std::vector<authedDrive> drvs;
sql.queryAuthedDrives(&drvs);
/* Get the serial key of the device */
UsbKey usbKey;
UsbKeyhdr hdr;
ops.unlockUSB();
usbKey.getUsbKeyHdr(&hdr, driveLtr);
ops.lockUSB(driveLtr);
/* Check if the serial exists in the database */
for (std::vector<authedDrive>::iterator it = drvs.begin(); it != drvs.end(); it++)
{
std::cout << it->serial.c_str() << " " << hdr.serialkey.c_str() << std::endl;
if (it->serial.compare(hdr.serialkey) == 0)
{
authorized = true;
break;
}
}
ops.unlockUSB();
/* Log media insertion event */
AccessLog *log = new AccessLog();
log->createLogStruct(&log->logUSBStruct, driveLtr, (char*)hdr.serialkey.c_str());
log->logUSBStruct.accepted = authorized;
/* Get config settings, check if remote SQL is enabled */
ConfigParser configParser((char*)Paths::getConfigPath().c_str());
if (configParser.getValue("SQLenabled") == "1")
{
/* SQL enabled = true */
log->logUsbDrive(log->logUSBStruct, true);
}
else
log->logUsbDrive(log->logUSBStruct, false);
/* If not authorized, eject it! */
if (!authorized)
{
ops.lockUSB(driveLtr);
ops.ejectUSB();
}
/* Check for viruses here... */
gMutex.unlock();
delete log;
}
bool DisplayError(const Sql& sql, const char *msg) {
return DisplayError(sql.GetSession(), msg);
}
void DlgSqlExport::Run(Sql& cursor, String command, String tablename)
{
Title(Nvl(tablename, t_("SQL query")) + t_(" export"));
object_name <<= tablename;
if(!cursor.Execute(command)) {
Exclamation(NFormat(t_("Error executing [* \1%s\1]: \1%s"), command, cursor.GetLastError()));
return;
}
for(int i = 0; i < cursor.GetColumns(); i++) {
const SqlColumnInfo& sci = cursor.GetColumnInfo(i);
String type;
switch(sci.valuetype) {
case BOOL_V:
case INT_V: type = t_("integer"); break;
case DOUBLE_V: type = t_("real number"); break;
case STRING_V:
case WSTRING_V: type = t_("string"); break;
case DATE_V: type = t_("date"); break;
case TIME_V: type = t_("date/time"); break;
case /*ORA_BLOB_V*/-1: type = t_("BLOB"); break;
case /*ORA_CLOB_V*/-2: type = t_("CLOB"); break;
default: type = FormatInt(sci.valuetype); break;
}
columns.Add(sci.name, sci.valuetype, sci.width, 1);
}
static String cfg;
LoadFromString(*this, cfg);
SyncUI();
while(TopWindow::Run() == IDOK)
try {
String out_table = ~object_name;
String delim;
switch((int)~delimiters) {
case DELIM_TAB: delim = "\t"; break;
case DELIM_SEMICOLON: delim = ";"; break;
}
Vector<int> out;
String colstr;
String title;
for(int i = 0; i < columns.GetCount(); i++)
if(columns.Get(i, 3)) {
out.Add(i);
String cname = cursor.GetColumnInfo(i).name;
colstr << (i ? ", " : "") << cname;
if(i) title << delim;
title << cname;
}
if(out.IsEmpty()) {
throw Exc(t_("No columns selected!"));
continue;
}
String rowbegin, rowend;
int fmt = ~format;
FileSel fsel;
String ext;
switch(fmt) {
case FMT_TEXT: {
rowend = "";
ext = ".txt";
fsel.Type(t_("Text files (*.txt)"), "*.txt");
break;
}
case FMT_SQL: {
if(identity_insert)
rowbegin << "set identity_insert " << out_table << " on ";
rowbegin << "insert into " << out_table << "(" << colstr << ") values (";
rowend = ");";
ext = ".sql";
fsel.Type(t_("SQL scripts (*.sql)"), "*.sql");
break;
}
}
fsel.AllFilesType().DefaultExt(ext.Mid(1));
if(!IsNull(recent_file))
fsel <<= ForceExt(recent_file, ext);
if(!fsel.ExecuteSaveAs(t_("Save export as")))
continue;
recent_file = ~fsel;
FileOut fo;
if(!fo.Open(recent_file)) {
Exclamation(NFormat(t_("Error creating file [* \1%s\1]."), recent_file));
continue;
}
if(fmt == FMT_TEXT)
fo.PutLine(title);
Progress progress(t_("Exporting row %d"));
while(cursor.Fetch()) {
String script = rowbegin;
for(int i = 0; i < out.GetCount(); i++) {
Value v = cursor[out[i]];
switch(fmt) {
case FMT_TEXT: {
if(i)
script.Cat(delim);
if(IsString(v) && quote) {
String s = v;
script << '\"';
for(const char *p = s, *e = s.End(); p < e; p++)
if(*p == '\"')
script.Cat("\"\"");
else
script.Cat(*p);
script << '\"';
}
else
script << StdFormat(v);
break;
}
case FMT_SQL: {
if(i) script.Cat(", ");
// script << SqlCompile(SQLD_ORACLE, SqlFormat(v));
break;
}
}
}
script << rowend;
fo.PutLine(script);
/*
if(autocommit && --left <= 0) {
fo.PutLine("commit;");
left = autocommit;
}
*/
if(progress.StepCanceled()) {
Exclamation(t_("Export aborted!"));
return;
}
}
fo.Close();
if(fo.IsError())
throw Exc(NFormat(t_("Error writing file %s."), recent_file));
break;
}
catch(Exc e) {
ShowExc(e);
}
cfg = StoreAsString(*this);
}
void SqlConnection::Attach(Sql& sql, SqlConnection *con)
{
sql.Attach(con); // Duck tape to fix Oci8
}
SqlExc::SqlExc(const Sql& sql) : Exc(sql_error) {
SetSessionError(sql.GetSession());
}
bool ShowError(Sql& sql, const char *msg) {
return ShowError(sql.GetSession(), msg);
}
String ForceInsertRowid(const SqlInsert& insert, Sql& cursor)
{
return ForceInsertRowid(SqlStatement(insert).Get(cursor.GetDialect()), cursor);
}
bool SqlStatement::Execute(Sql& cursor) const {
ASSERT(text.GetCount());
return cursor.Execute(*this);
}
void ForceDelete(SqlId table, SqlId key, const Value& keyval, Sql& cursor)
{
if(!cursor.Delete(table, key, keyval))
throw SqlExc(cursor);
}
void ForceExecute(const String& s, Sql& cursor)
{
if(!cursor.Execute(s))
throw SqlExc(cursor);
}
void Field(const char *name, Ref f) {
sql->GetColumn(SqlId(name), f);
}