void CMUSHclientApp::SaveGlobalsToDatabase (void)
{
// close and re-open database, in case they somehow lost connection to it
if (db)
sqlite3_close(db);
int db_rc = sqlite3_open(m_PreferencesDatabaseName.c_str (), &db);
if( db_rc )
{
::AfxMessageBox ((LPCTSTR) CFormat ("Can't open global preferences database at: %s"
"\r\n(Error was: \"%s\")"
"\r\nCheck you have write-access to that file.",
m_PreferencesDatabaseName.c_str (),
sqlite3_errmsg(db)));
sqlite3_close(db);
db = NULL;
return;
}
db_rc = db_execute ("BEGIN TRANSACTION", true);
int i;
for (i = 0; GlobalOptionsTable [i].pName; i++)
{
const char * p = (const char *) this + GlobalOptionsTable [i].iOffset;
const int Value = * (const long *) p;
db_rc = db_execute ((LPCTSTR) CFormat ("UPDATE prefs SET value = %i WHERE name = '%s'",
Value, GlobalOptionsTable [i].pName), true);
if (db_rc != SQLITE_OK)
break;
};
if (db_rc == SQLITE_OK)
for (i = 0; AlphaGlobalOptionsTable [i].pName; i++)
{
const char * p = (const char *) this + AlphaGlobalOptionsTable [i].iOffset;
CString strValue = * (CString *) p;
strValue.Replace ("'", "''"); // fix up quotes
db_rc = db_execute ((LPCTSTR) CFormat ("UPDATE prefs SET value = '%s' WHERE name = '%s'",
(LPCTSTR) strValue, AlphaGlobalOptionsTable [i].pName), true);
if (db_rc != SQLITE_OK)
break;
};
db_execute ("COMMIT", true);
} // end of CMUSHclientApp::SaveGlobalsToDatabase
static void *worker_bee(void *pArg){
const char *zFilename = (char*)pArg;
char *azErr;
int i, cnt;
int t = atoi(zFilename);
char **az;
sqlite *db;
pthread_mutex_lock(&lock);
thread_cnt++;
pthread_mutex_unlock(&lock);
printf("%s: START\n", zFilename);
fflush(stdout);
for(cnt=0; cnt<10; cnt++){
db = sqlite_open(&zFilename[2], 0, &azErr);
if( db==0 ){
fprintf(stdout,"%s: can't open\n", zFilename);
Exit(1);
}
sqlite_busy_handler(db, db_is_locked, zFilename);
db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);
for(i=1; i<=100; i++){
db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",
t, i, i*2, i*i);
}
az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);
db_check(zFilename, "tX size", az, "100", 0);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg", az, "101", 0);
db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg2", az, "51", 0);
for(i=1; i<=50; i++){
char z1[30], z2[30];
az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);
sprintf(z1, "%d", i*2);
sprintf(z2, "%d", i*i);
db_check(zFilename, "readback", az, z1, z2, 0);
}
db_execute(db, zFilename, "DROP TABLE t%d;", t);
sqlite_close(db);
}
printf("%s: END\n", zFilename);
/* unlink(zFilename); */
fflush(stdout);
pthread_mutex_lock(&lock);
thread_cnt--;
if( thread_cnt<=0 ){
pthread_cond_signal(&sig);
}
pthread_mutex_unlock(&lock);
return 0;
}
// copy the registry prefs into the SQLite database into table 'prefs'
int CMUSHclientApp::PopulateDatabase (void)
{
SetRegistryKey ("Gammon Software Solutions");
int i;
int db_rc = SQLITE_OK;
for (i = 0; GlobalOptionsTable [i].pName; i++)
{
const char * p = (const char *) this + GlobalOptionsTable [i].iOffset;
const int Value = GetProfileInt ("Global prefs",
GlobalOptionsTable [i].pName,
GlobalOptionsTable [i].iDefault);
db_rc = db_execute ((LPCTSTR) CFormat ("INSERT INTO prefs (name, value) VALUES ('%s', %i)",
GlobalOptionsTable [i].pName, Value), true);
if (db_rc != SQLITE_OK)
return db_rc;
};
for (i = 0; AlphaGlobalOptionsTable [i].pName; i++)
{
const char * p = (const char *) this + AlphaGlobalOptionsTable [i].iOffset;
// fix up the fixed-pitch font
if (strcmp (AlphaGlobalOptionsTable [i].pName, "DefaultInputFont") == 0 ||
strcmp (AlphaGlobalOptionsTable [i].pName, "DefaultOutputFont") == 0 ||
strcmp (AlphaGlobalOptionsTable [i].pName, "FixedPitchFont") == 0)
AlphaGlobalOptionsTable [i].sDefault = (LPCTSTR) m_strFixedPitchFont;
CString strValue = GetProfileString ("Global prefs",
AlphaGlobalOptionsTable [i].pName,
AlphaGlobalOptionsTable [i].sDefault);
strValue.Replace ("'", "''"); // fix up quotes
db_rc = db_execute ((LPCTSTR) CFormat ("INSERT INTO prefs (name, value) VALUES ('%s', '%s')",
AlphaGlobalOptionsTable [i].pName, (LPCTSTR) strValue), true);
if (db_rc != SQLITE_OK)
return db_rc;
};
return SQLITE_OK;
} // end of CMUSHclientApp::PopulateDatabase
static void *download_entry(void *arg)
{
d_task_t *d_task = (d_task_t *)arg;
file_info_t file;
char sql_buf[1024];
char real_url[MAX_URL_LEN];
char tmp_file_name_fmt[PATH_MAX];
int ret, i;
char *ptr;
if (d_task->request_file_info(d_task->url, &file, real_url) == 0)
{
int i = 0;
int parts = 0, per_part_len = 0, last_part_len = 0;
if (MIN_PART_SIZE * MAX_PART_NUMBER >= file.length)
{
per_part_len = MIN_PART_SIZE;
parts = file.length / MIN_PART_SIZE;
last_part_len = file.length - parts * MIN_PART_SIZE;
if (last_part_len > 0)
parts++;
}
else
{
parts = MAX_PART_NUMBER;
per_part_len = file.length / parts;
last_part_len = file.length - parts * per_part_len;
if (last_part_len > 0)
last_part_len += per_part_len;
}
DEBUG_OUTPUT("parts is %d\n", parts);
// create unique downloading file
if (_create_unique_file(d_task, &file) != 0)
{
fprintf(stderr, "error when create download file\n");
return ERR_RET_VAL;
}
// create unique tmp file dir
strcpy(tmp_file_name_fmt, file.filename);
ptr = tmp_file_name_fmt + strlen(tmp_file_name_fmt);
i = 0;
while (1)
{
ret = mkdir(tmp_file_name_fmt, S_IRWXU);
if (ret != 0 && errno == EEXIST)
sprintf(ptr, "(%d)", ++i);
else if (ret != 0)
return ERR_RET_VAL;
else
break;
}
snprintf(d_task->tmp_file_name_fmt, PATH_MAX, "%s/%s", tmp_file_name_fmt, TMP_FILE_SUFFIX_FMT); // filename.ext(n)/._tmp_%d
// save this task to db file
snprintf(sql_buf, sizeof(sql_buf), SQL_INSERT_VALUES, file.filename,
real_url, d_task->file_saved_path, file.length, d_task->tmp_file_name_fmt, parts,
per_part_len, last_part_len);
db_execute(d_task->dm->db_key, sql_buf, NULL);
dispatch_part_download(d_task, &file, per_part_len, last_part_len, parts);
}
}
static void *dispatch_part_download(d_task_t *d_task, file_info_t *file,
int per_part_len, int last_part_len, int parts)
{
int i;
int offset = 0;
// allocate on stack
task_desc descs[MAX_PART_NUMBER];
part_info_t parts_info[MAX_PART_NUMBER];
char tmp_files_name[MAX_PART_NUMBER][PATH_MAX];
int part_lens[MAX_PART_NUMBER];
int part_downloaded_len = 0;
struct stat sb;
int ret;
char sql_buf[256];
for (i = 0; i < parts; i++)
{
descs[i].arg = &parts_info[i];
descs[i].fire_task_over = NULL;
parts_info[i].beg_pos = offset;
if (i == parts - 1 && last_part_len > 0)
offset += last_part_len;
else
offset += per_part_len;
parts_info[i].end_pos = offset - 1;
parts_info[i].d_task = d_task;
parts_info[i].file = file;
parts_info[i].id = i;
part_lens[i] = parts_info[i].end_pos - parts_info[i].beg_pos + 1;
snprintf(tmp_files_name[i], PATH_MAX, d_task->tmp_file_name_fmt, i);
ret = stat(tmp_files_name[i], &sb);
if (ret != 0 && errno != ENOENT)
{
perror("stat file size failed:");
return;
}
if (ret == 0)
{
parts_info[i].beg_pos += sb.st_size;
d_task->len_downloaded += sb.st_size;
}
if (parts_info[i].end_pos - parts_info[i].beg_pos + 1 > 0)
easy_thread_pool_add_task(d_task->dm->tp, download_part_entry, &descs[i]);
}
pthread_mutex_lock(d_task->part_mutex);
while (d_task->parts_exit < parts)
pthread_cond_wait(d_task->part_cond, d_task->part_mutex);
pthread_mutex_unlock(d_task->part_mutex);
if (d_task->len_downloaded < file->length)
{
for (i = 0; i < parts; i++)
{
if (!parts_info[i].finished)
d_task->request_part_file(&parts_info[i]);
}
}
if (d_task->len_downloaded < file->length)
fprintf(stderr, "download failed\n");
else // save downloaded file
{
char file_full_path[PATH_MAX];
char *p;
snprintf(file_full_path, PATH_MAX, "%s/%s", d_task->file_saved_path, file->filename);
if(merge_files(file_full_path, file->length, tmp_files_name, part_lens, parts) < 0)
{
fprintf(stderr, "merge files failed\n");
unlink(file_full_path);
}
if(p = strrchr(tmp_files_name[0], '/'))
{
*++p = 0;
rmdir(tmp_files_name[0]);
}
// delete file record from db
snprintf(sql_buf, sizeof(sql_buf), SQL_DEL_FILE, file->filename, d_task->file_saved_path);
db_execute(d_task->dm->db_key, sql_buf, NULL);
}
}
int sb_lua_db_execute(lua_State *L)
{
sb_lua_ctxt_t *ctxt;
sb_lua_db_stmt_t *stmt;
db_result_set_t *ptr;
sb_lua_db_rs_t *rs;
unsigned int i;
char needs_rebind = 0;
db_bind_t *binds;
size_t length;
const char *str;
sb_lua_bind_t *param;
ctxt = sb_lua_get_context(L);
CHECK_CONNECTION(L, ctxt);
stmt = (sb_lua_db_stmt_t *)luaL_checkudata(L, 1, "sysbench.stmt");
luaL_argcheck(L, stmt != NULL, 1, "prepared statement expected");
/* Get params table */
lua_rawgeti(L, LUA_REGISTRYINDEX, stmt->param_ref);
if (!lua_isnil(L, -1) && !lua_istable(L, -1))
luaL_error(L, "table expected");
for (i = 0; i < stmt->nparams; lua_pop(L, 1), i++)
{
param = stmt->params + i;
lua_pushnumber(L, param->id);
lua_gettable(L, -2);
if (lua_isnil(L, -1))
{
param->is_null = 1;
continue;
}
param->is_null = 0;
switch (param->type)
{
case DB_TYPE_INT:
*((int *)param->buf) = luaL_checknumber(L, -1);
break;
case DB_TYPE_CHAR:
str = luaL_checkstring(L, -1);
length = lua_objlen(L, -1);
if (length > param->buflen)
{
param->buf = realloc(param->buf, length);
needs_rebind = 1;
}
strncpy(param->buf, str, length);
param->buflen = length;
break;
default:
luaL_error(L, "Unsupported variable type: %s",
lua_typename(L, lua_type(L, -1)));
}
}
/* Rebind if needed */
if (needs_rebind)
{
binds = (db_bind_t *)calloc(stmt->nparams, sizeof(db_bind_t));
if (binds == NULL)
luaL_error(L, "Memory allocation failure");
for (i = 0; i < stmt->nparams; i++)
{
param = stmt->params + i;
binds[i].type = param->type;
binds[i].is_null = ¶m->is_null;
if (*binds[i].is_null != 0)
continue;
switch (param->type)
{
case DB_TYPE_INT:
binds[i].buffer = param->buf;
break;
case DB_TYPE_CHAR:
binds[i].buffer = param->buf;
binds[i].data_len = &stmt->params[i].buflen;
binds[i].is_null = 0;
break;
default:
luaL_error(L, "Unsupported variable type");
}
}
if (db_bind_param(stmt->ptr, binds, stmt->nparams))
luaL_error(L, "db_bind_param() failed");
free(binds);
}
ptr = db_execute(stmt->ptr);
if (ptr == NULL)
{
stmt->rs = NULL;
lua_pushnumber(L, ctxt->con->db_errno);
lua_error(L);
}
else
{
rs = (sb_lua_db_rs_t *)lua_newuserdata(L, sizeof(sb_lua_db_rs_t));
rs->ptr = ptr;
luaL_getmetatable(L, "sysbench.rs");
lua_setmetatable(L, -2);
stmt->rs = rs;
}
return 1;
}
int
main (int argc, char *argv[])
{
float disk_compat_level = 0.0f;
char *prog_name;
const char *qp1 = "select db_user, password.password from db_user";
DB_VALUE user_val, password_val;
MOP user_class;
MOP user;
char *db_name;
char *password;
char *decoded_str;
char *encoded_str;
int retval, error;
DB_QUERY_RESULT *query_result;
DB_QUERY_ERROR query_error;
char out_buf[128];
if (argc < 2)
{
printf ("usage : %s databasename\n", argv[0]);
return 1;
}
prog_name = argv[0];
db_name = argv[1];
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
db_login ("dba", NULL);
db_restart (prog_name, 0, db_name);
error = db_execute (qp1, &query_result, &query_error);
if (error > 0)
{
error = db_query_first_tuple (query_result);
while (error == NO_ERROR)
{
retval = db_query_get_tuple_value (query_result, 0, &user_val);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
retval = db_query_get_tuple_value (query_result, 1, &password_val);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
if (DB_IS_NULL (&user_val) || DB_IS_NULL (&password_val))
{
error = db_query_next_tuple (query_result);
continue;
}
user = db_get_object (&user_val);
password = db_get_string (&password_val);
retval = io_relseek_old (password, 1, out_buf);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
retval = au_set_password (user, out_buf);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
error = db_query_next_tuple (query_result);
}
db_query_end (query_result);
}
db_commit_transaction ();
db_shutdown ();
return 0;
}
