static MPlist *
lookup_ibus (TableContext *context, MPlist *args)
{
unsigned char buf[256];
char *word = NULL, *sql = NULL, *msql = NULL;
MPlist *candidates = mplist ();
int len, xlen, wlen, mlen;
int i, rc;
int *m = NULL;
sqlite3_stmt *stmt;
MText *mt;
if (!context->db)
goto out;
rc = mtext_to_utf8 (context, context->ic->preedit, buf, sizeof (buf));
if (rc < 0)
goto out;
word = strdup ((const char *)buf);
len = rc;
mlen = CLAMP(context->mlen, 0, 99);
rc = encode_phrase ((const unsigned char *)word, &m);
if (rc)
goto out;
/* strlen(" AND mXX = XX") = 13 */
if (len > mlen)
len = mlen;
msql = calloc (sizeof (char), 13 * len + 1);
if (!msql)
goto out;
for (i = 0; i < len; i++)
{
char s[14];
sqlite3_snprintf (13, s, " AND m%d = %d", i, m[i]);
strcat (msql, s);
}
sql = calloc (sizeof (char), 128 + strlen (msql) + 1);
if (!sql)
goto out;
/* issue query repeatedly until at least one candidates are found or
the key length is exceeds mlen */
xlen = context->xlen;
wlen = mlen - len + 1;
for (; xlen <= wlen + 1; xlen++)
{
sqlite3_snprintf (128,
sql,
"SELECT id, phrase FROM phrases WHERE mlen < %lu",
len + xlen);
strcat (sql, msql);
strcat (sql, " ORDER BY mlen ASC, user_freq DESC, freq DESC, id ASC");
if (context->max_candidates)
sqlite3_snprintf (128,
sql + strlen (sql),
" LIMIT %lu",
context->max_candidates);
#ifdef DEBUG
fprintf (stderr, "%s\n", sql);
#endif
rc = sqlite3_prepare (context->db, sql, strlen (sql), &stmt, NULL);
if (rc != SQLITE_OK)
{
sqlite3_finalize (stmt);
goto out;
}
while (sqlite3_step (stmt) == SQLITE_ROW)
{
const unsigned char *text;
text = sqlite3_column_text (stmt, 1);
#ifdef DEBUG
fprintf (stderr, " %s\n", text);
#endif
mt = mtext_from_utf8 (context, text, strlen ((const char *)text));
mplist_add (candidates, Mtext, mt);
m17n_object_unref (mt);
}
sqlite3_finalize (stmt);
if (mplist_length (candidates) > 0)
break;
}
out:
if (word)
free (word);
if (m)
free (m);
if (sql)
free (sql);
if (msql)
free (msql);
return candidates;
}
int rua_add_history(struct rua_rec *rec)
{
int r;
int cnt = 0;
char query[QUERY_MAXLEN];
sqlite3_stmt *stmt;
unsigned int timestamp;
timestamp = PERF_MEASURE_START("RUA");
LOGD("rua_add_history invoked");
if (_db == NULL) {
LOGE("rua is not inited.");
return -1;
}
if (rec == NULL) {
LOGE("rec is null");
return -1;
}
snprintf(query, QUERY_MAXLEN,
"select count(*) from %s where pkg_name = '%s';", RUA_HISTORY,
rec->pkg_name);
r = sqlite3_prepare(_db, query, sizeof(query), &stmt, NULL);
if (r != SQLITE_OK) {
LOGE("query prepare error(%d)", r);
return -1;
}
r = sqlite3_step(stmt);
if (r == SQLITE_ROW) {
cnt = sqlite3_column_int(stmt, 0);
}
sqlite3_finalize(stmt);
/****************************************************/
if (!flag) {
vconf_unset_recursive ("db/rua_data");
flag = 1;
}
if(strcmp(rec->pkg_name, "org.tizen.menu-screen") && strcmp(rec->pkg_name, "org.tizen.volume") && strcmp(rec->pkg_name, "org.tizen.lockscreen") && strcmp(rec->pkg_name, "org.tizen.pwlock")){
int total = 0;
int apps;
char key[255], *key2 = "db/rua_data/apps";
sprintf (key, "db/rua_data/%s", "tizen_total_cnt");
if (vconf_get_int (key, &total) < 0)
total = 0;
vconf_set_int (key, total + 1);
memset (key, 0, 255);
sprintf (key, "db/rua_data/%s", rec->pkg_name);
if (vconf_get_int (key, &total) < 0) {
total = 0;
if (vconf_get_int (key2, &apps) < 0)
apps = 0;
vconf_set_int (key2, apps + 1);
}
vconf_set_int (key, total + 1);
}
/****************************************************/
if (cnt == 0) {
/* insert */
snprintf(query, QUERY_MAXLEN,
"insert into %s ( pkg_name, app_path, arg, launch_time ) "
" values ( \"%s\", \"%s\", \"%s\", %d ) ",
RUA_HISTORY,
rec->pkg_name ? rec->pkg_name : "",
rec->app_path ? rec->app_path : "",
rec->arg ? rec->arg : "", (int)time(NULL));
}
else {
/* update */
snprintf(query, QUERY_MAXLEN,
"update %s set arg='%s', launch_time='%d' where pkg_name = '%s';",
RUA_HISTORY,
rec->arg ? rec->arg : "", (int)time(NULL), rec->pkg_name);
}
r = __exec(_db, query);
if (r == -1) {
LOGE("[RUA ADD HISTORY ERROR] %s\n", query);
return -1;
}
PERF_MEASURE_END("RUA", timestamp);
return r;
}
/*
* Find unchanged files from a specified time from the DB
* Input:
* query_callback : query callback fuction to handle
* result records from the query
* for_time : Time from where the file/s are not changed
* */
int
gf_sqlite3_find_unchanged_for_time (void *db_conn,
gf_query_callback_t query_callback,
void *query_cbk_args,
gfdb_time_t *for_time)
{
int ret = -1;
char *query_str = NULL;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *prep_stmt = NULL;
long int for_time_usec = 0;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
query_str = "select GF_FILE_TB.GF_ID,"
" (select group_concat( GF_PID || ',' || FNAME || ','"
" || FPATH || ',' || W_DEL_FLAG ||',' || LINK_UPDATE , '::')"
" from GF_FLINK_TB where GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID)"
" from GF_FILE_TB where "
/*First condition: For writes*/
"((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_WMSEC ") <= ? )"
" OR "
/*Second condition: For reads*/
"((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_RWMSEC ") <= ?)";
for_time_usec = gfdb_time_2_usec(for_time);
ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1,
&prep_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing statment %s :"
" %s", query_str,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write wind time*/
ret = sqlite3_bind_int64(prep_stmt, 1, for_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding for_time_usec "
"%ld : %s", for_time_usec,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read wind time*/
ret = sqlite3_bind_int64(prep_stmt, 2, for_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding for_time_usec "
"%ld : %s", for_time_usec,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the query*/
ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed Query %s", query_str);
goto out;
}
ret = 0;
out:
sqlite3_finalize(prep_stmt);
return ret;
}
static inline int
gf_sql_update_link (gf_sql_connection_t *sql_conn,
char *gfid,
char *pargfid,
char *basename,
char *basepath,
char *old_pargfid,
char *old_basename,
gf_boolean_t link_consistency)
{
int ret = -1;
sqlite3_stmt *insert_stmt = NULL;
char insert_str[GFDB_SQL_STMT_SIZE] = "";
sprintf (insert_str, "INSERT INTO "
GF_FILE_LINK_TABLE
" (GF_ID, GF_PID, FNAME, FPATH,"
" W_DEL_FLAG, LINK_UPDATE) "
" VALUES (? , ?, ?, ?, 0, %d);",
link_consistency);
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basepath, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_pargfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_basename, out);
/*
*
* Delete the old link
*
* */
ret = gf_sql_delete_link (sql_conn, gfid, old_pargfid,
old_basename);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_DELETE_FAILED, "Failed deleting old link");
goto out;
}
/*
*
* insert new link
*
* */
/*Prepare statement*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
&insert_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing insert "
"statment %s : %s", insert_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind new pargfid*/
ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
": %s", pargfid,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind new basename*/
ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
"%s", basename,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind new basepath*/
ret = sqlite3_bind_text (insert_stmt, 4, basepath, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
"%s", basepath,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
insert_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
/*Free prepared statement*/
sqlite3_finalize (insert_stmt);
return ret;
}
/*Update write/read times for both wind and unwind*/
static inline int
gf_update_time (gf_sql_connection_t *sql_conn,
char *gfid,
gfdb_time_t *update_time,
gf_boolean_t record_counter,
gf_boolean_t is_wind,
gf_boolean_t is_read)
{
int ret = -1;
sqlite3_stmt *update_stmt = NULL;
char update_str[1024] = "";
char *freq_cntr_str = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, update_time, out);
/*
* Constructing the prepare statment string.
*
* */
/*For write time*/
if (!is_read) {
if (is_wind) {
/*if record counter is on*/
freq_cntr_str = (record_counter) ?
", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" : "";
/*Prefectly safe as we will not go array of bound*/
sprintf (update_str, "UPDATE "
GF_FILE_TABLE
" SET W_SEC = ?, W_MSEC = ? "
" %s"/*place for read freq counters*/
" WHERE GF_ID = ? ;", freq_cntr_str);
} else {
/*Prefectly safe as we will not go array of bound*/
sprintf (update_str, "UPDATE "
GF_FILE_TABLE
" SET UW_SEC = ?, UW_MSEC = ? ;");
}
}
/*For Read Time update*/
else {
if (is_wind) {
/*if record counter is on*/
freq_cntr_str = (record_counter) ?
", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" : "";
/*Prefectly safe as we will not go array of bound*/
sprintf (update_str, "UPDATE "
GF_FILE_TABLE
" SET W_READ_SEC = ?, W_READ_MSEC = ? "
" %s"/*place for read freq counters*/
" WHERE GF_ID = ? ;", freq_cntr_str);
} else {
/*Prefectly safe as we will not go array of bound*/
sprintf (update_str, "UPDATE "
GF_FILE_TABLE
" SET UW_READ_SEC = ?, UW_READ_MSEC = ? ;");
}
}
/*Prepare statement*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
&update_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing insert "
"statment %s : %s", update_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind time secs*/
ret = sqlite3_bind_int (update_stmt, 1, update_time->tv_sec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent wind "
"secs %ld : %s", update_time->tv_sec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind time msecs*/
ret = sqlite3_bind_int (update_stmt, 2, update_time->tv_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent wind "
"msecs %ld : %s", update_time->tv_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (update_stmt, 3, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step (update_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
update_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
/*Free prepared statement*/
sqlite3_finalize (update_stmt);
return ret;
}
int remote_control()
{
ghttp_request *req;
char *http_body = NULL;
req = ghttp_request_new();
sqlite3 *db = NULL;
int rc = 0;
sqlite3_stmt *ppstmt = NULL;
char sql_cmd[100] ={0};
const char *box_id;
char box_id_tmp[10] = {0};
const char *wan_state;
char *errorMsg = NULL;
char request_url[200] = {0};
printf("****************************************\n");
printf("remote_control : start\n");
printf("****************************************\n");
rc = sqlite3_open(box_db, &db);
if(rc == SQLITE_ERROR)
{
printf("cannot open box.db!\n");
return 0;
}
strcpy(sql_cmd, "select box_id from box_info");
sqlite3_prepare(db, sql_cmd, -1, &ppstmt, 0);
rc = sqlite3_step(ppstmt);
if(rc == SQLITE_ROW)
{
box_id = sqlite3_column_text(ppstmt, 0);
strcpy(box_id_tmp, box_id);
printf("box_id : %s\n", box_id_tmp);
}
sqlite3_finalize(ppstmt);
sqlite3_close(db);
printf("send http request...\n");
sprintf(request_url, "http://www.ailvgobox.com/box_manage/remote_control.php?box_id=%s", box_id_tmp);
printf("request_url : %s\n", request_url);
http_body = send_http_request(req, request_url);
fprintf(stderr, "http_body : %s\n", http_body);
cJSON *node;
if(http_body)
{
printf("HTTP success!\n");
if(strcmp(http_body, "null") == 0)
printf("http_body : null, no remote_control!\n");
else
{
node = cJSON_Parse(http_body);
ParseJSON(node, box_id_tmp);
}
}
else
{
printf("HTTP failure!\n");
}
if(http_body)
free(http_body);
ghttp_request_destroy(req);
free(request_url);
printf("remote_control : complete!\n");
return 1;
}
static inline int
gf_sql_update_link_flags (gf_sql_connection_t *sql_conn,
char *gfid,
char *pargfid,
char *basename,
int update_flag,
gf_boolean_t is_update_or_delete)
{
int ret = -1;
sqlite3_stmt *update_stmt = NULL;
char *update_column = NULL;
char update_str[1024] = "";
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG";
sprintf (update_str, "UPDATE "
GF_FILE_LINK_TABLE
" SET %s = ?"
" WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;",
update_column);
/*Prepare statement*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
&update_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing update "
"statment %s : %s", update_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind link_update*/
ret = sqlite3_bind_int (update_stmt, 1, update_flag);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding update_flag %d "
": %s", update_flag,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (update_stmt, 2, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind pargfid*/
ret = sqlite3_bind_text (update_stmt, 3, pargfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
": %s", pargfid,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind basename*/
ret = sqlite3_bind_text (update_stmt, 4, basename, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
"%s", basename,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step(update_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
update_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
/*Free prepared statement*/
sqlite3_finalize (update_stmt);
return ret;
}
/* query the statedb, caller must free the memory */
c_strlist_t *csync_statedb_query(sqlite3 *db,
const char *statement) {
int err = SQLITE_OK;
int rc = SQLITE_OK;
size_t i = 0;
size_t busy_count = 0;
size_t retry_count = 0;
size_t column_count = 0;
sqlite3_stmt *stmt;
const char *tail = NULL;
const char *field = NULL;
c_strlist_t *result = NULL;
int row = 0;
do {
/* compile SQL program into a virtual machine, reattempteing if busy */
do {
if (busy_count) {
/* sleep 100 msec */
usleep(100000);
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "sqlite3_prepare: BUSY counter: %zu", busy_count);
}
err = sqlite3_prepare(db, statement, -1, &stmt, &tail);
} while (err == SQLITE_BUSY && busy_count ++ < 120);
if (err != SQLITE_OK) {
if (err == SQLITE_BUSY) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Gave up waiting for lock to clear");
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN,
"sqlite3_compile error: %s - on query %s",
sqlite3_errmsg(db), statement);
break;
} else {
busy_count = 0;
column_count = sqlite3_column_count(stmt);
/* execute virtual machine by iterating over rows */
for(;;) {
err = sqlite3_step(stmt);
if (err == SQLITE_BUSY) {
if (busy_count++ > 120) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Busy counter has reached its maximum. Aborting this sql statement");
break;
}
/* sleep 100 msec */
usleep(100000);
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "sqlite3_step: BUSY counter: %zu", busy_count);
continue;
}
if (err == SQLITE_MISUSE) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "sqlite3_step: MISUSE!!");
}
if (err == SQLITE_DONE) {
if (result == NULL) {
result = c_strlist_new(1);
}
break;
}
if (err == SQLITE_ERROR) {
break;
}
row++;
if( result ) {
result = c_strlist_expand(result, row*column_count);
} else {
result = c_strlist_new(column_count);
}
if (result == NULL) {
return NULL;
}
/* iterate over columns */
for (i = 0; i < column_count; i++) {
field = (const char *) sqlite3_column_text(stmt, i);
if (!field)
field = "";
// CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "sqlite3_column_text: %s", field);
if (c_strlist_add(result, field) < 0) {
c_strlist_destroy(result);
return NULL;
}
}
} /* end infinite for loop */
/* deallocate vm resources */
rc = sqlite3_finalize(stmt);
if (err != SQLITE_DONE && rc != SQLITE_SCHEMA) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "sqlite_step error: %s - on query: %s", sqlite3_errmsg(db), statement);
if (result != NULL) {
c_strlist_destroy(result);
}
return NULL;
}
if (rc == SQLITE_SCHEMA) {
retry_count ++;
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "SQLITE_SCHEMA error occurred on query: %s", statement);
if (retry_count < 10) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Retrying now.");
} else {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "RETRY count has reached its maximum. Aborting statement: %s", statement);
if (result != NULL) {
c_strlist_destroy(result);
}
result = c_strlist_new(1);
}
}
}
} while (rc == SQLITE_SCHEMA && retry_count < 10);
return result;
}
/*
** Execute SQL code. Return one of the SQLITE_ success/failure
** codes. Also write an error message into memory obtained from
** malloc() and make *pzErrMsg point to that message.
**
** If the SQL is a query, then for each row in the query result
** the xCallback() function is called. pArg becomes the first
** argument to xCallback(). If xCallback=NULL then no callback
** is invoked, even for queries.
*/
int sqlite3_exec(
sqlite3 *db, /* The database on which the SQL executes */
const char *zSql, /* The SQL to be executed */
sqlite3_callback xCallback, /* Invoke this callback routine */
void *pArg, /* First argument to xCallback() */
char **pzErrMsg /* Write error messages here */
){
int rc = SQLITE_OK;
const char *zLeftover;
sqlite3_stmt *pStmt = 0;
char **azCols = 0;
int nRetry = 0;
int nCallback;
if( zSql==0 ) return SQLITE_OK;
while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){
int nCol;
char **azVals = 0;
pStmt = 0;
rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);
assert( rc==SQLITE_OK || pStmt==0 );
if( rc!=SQLITE_OK ){
continue;
}
if( !pStmt ){
/* this happens for a comment or white-space */
zSql = zLeftover;
continue;
}
nCallback = 0;
nCol = sqlite3_column_count(pStmt);
azCols = sqliteMalloc(2*nCol*sizeof(const char *) + 1);
if( azCols==0 ){
goto exec_out;
}
while( 1 ){
int i;
rc = sqlite3_step(pStmt);
/* Invoke the callback function if required */
if( xCallback && (SQLITE_ROW==rc ||
(SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){
if( 0==nCallback ){
for(i=0; i<nCol; i++){
azCols[i] = (char *)sqlite3_column_name(pStmt, i);
}
nCallback++;
}
if( rc==SQLITE_ROW ){
azVals = &azCols[nCol];
for(i=0; i<nCol; i++){
azVals[i] = (char *)sqlite3_column_text(pStmt, i);
}
}
if( xCallback(pArg, nCol, azVals, azCols) ){
rc = SQLITE_ABORT;
goto exec_out;
}
}
if( rc!=SQLITE_ROW ){
rc = sqlite3_finalize(pStmt);
pStmt = 0;
if( rc!=SQLITE_SCHEMA ){
nRetry = 0;
zSql = zLeftover;
while( isspace((unsigned char)zSql[0]) ) zSql++;
}
break;
}
}
sqliteFree(azCols);
azCols = 0;
}
exec_out:
if( pStmt ) sqlite3_finalize(pStmt);
if( azCols ) sqliteFree(azCols);
rc = sqlite3ApiExit(0, rc);
if( rc!=SQLITE_OK && rc==sqlite3_errcode(db) && pzErrMsg ){
int nErrMsg = 1 + strlen(sqlite3_errmsg(db));
*pzErrMsg = sqlite3_malloc(nErrMsg);
if( *pzErrMsg ){
memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
}
}else if( pzErrMsg ){
*pzErrMsg = 0;
}
assert( (rc&db->errMask)==rc );
return rc;
}
static device_id_t
get_device_id(bool do_regist)
{
char device[PROP_VALUE_MAX];
char build_id[PROP_VALUE_MAX];
device_id_t device_id;
const char *check_name;
char name_buf[PROP_NAME_MAX];
sqlite3_stmt *st;
int rc;
int i;
if (!init_database()) {
return DEVICE_NOT_SUPPORTED;
}
__system_property_get("ro.product.model", device);
__system_property_get("ro.build.display.id", build_id);
device_id = DEVICE_NOT_SUPPORTED;
check_name = NULL;
rc = sqlite3_prepare(db, SQL_QUERY_DEVICE, -1, &st, NULL);
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_reset(st);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 1, device, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 2, build_id, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
for (rc = execute_sql(st); rc == SQLITE_ROW; rc = execute_sql(st)) {
const char *check_value;
device_id = sqlite3_column_int(st, 0);
check_name = sqlite3_column_text(st, 1);
check_value = sqlite3_column_text(st, 2);
if (!check_name && !check_value) {
break;
}
if (check_name && check_value) {
char property_value[PROP_VALUE_MAX];
__system_property_get(check_name, property_value);
if (strcmp(property_value, check_value) == 0) {
break;
}
strncpy(name_buf, check_name, sizeof (name_buf) - 1);
name_buf[sizeof (name_buf) - 1] = '\0';
check_name = name_buf;
}
device_id = DEVICE_NOT_SUPPORTED;
}
}
if (IS_SQL_ERROR(rc)) {
printf("%s(%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
sqlite3_finalize(st);
return device_id;
}
sqlite3_finalize(st);
if (!do_regist || device_id != DEVICE_NOT_SUPPORTED) {
return device_id;
}
return register_device_id(check_name);
}
bool QgsDistanceArea::setEllipsoid( const QString& ellipsoid )
{
QString radius, parameter2;
//
// SQLITE3 stuff - get parameters for selected ellipsoid
//
sqlite3 *myDatabase;
const char *myTail;
sqlite3_stmt *myPreparedStatement;
int myResult;
// Shortcut if ellipsoid is none.
if ( ellipsoid == GEO_NONE )
{
mEllipsoid = GEO_NONE;
return true;
}
// Check if we have a custom projection, and set from text string.
// Format is "PARAMETER:<semi-major axis>:<semi minor axis>
// Numbers must be with (optional) decimal point and no other separators (C locale)
// Distances in meters. Flattening is calculated.
if ( ellipsoid.startsWith( "PARAMETER" ) )
{
QStringList paramList = ellipsoid.split( ':' );
bool semiMajorOk, semiMinorOk;
double semiMajor = paramList[1].toDouble( & semiMajorOk );
double semiMinor = paramList[2].toDouble( & semiMinorOk );
if ( semiMajorOk && semiMinorOk )
{
return setEllipsoid( semiMajor, semiMinor );
}
else
{
return false;
}
}
// Continue with PROJ.4 list of ellipsoids.
//check the db is available
myResult = sqlite3_open_v2( QgsApplication::srsDbFilePath().toUtf8().data(), &myDatabase, SQLITE_OPEN_READONLY, nullptr );
if ( myResult )
{
QgsMessageLog::logMessage( QObject::tr( "Can't open database: %1" ).arg( sqlite3_errmsg( myDatabase ) ) );
// XXX This will likely never happen since on open, sqlite creates the
// database if it does not exist.
return false;
}
// Set up the query to retrieve the projection information needed to populate the ELLIPSOID list
QString mySql = "select radius, parameter2 from tbl_ellipsoid where acronym='" + ellipsoid + '\'';
myResult = sqlite3_prepare( myDatabase, mySql.toUtf8(), mySql.toUtf8().length(), &myPreparedStatement, &myTail );
// XXX Need to free memory from the error msg if one is set
if ( myResult == SQLITE_OK )
{
if ( sqlite3_step( myPreparedStatement ) == SQLITE_ROW )
{
radius = QString( reinterpret_cast< const char * >( sqlite3_column_text( myPreparedStatement, 0 ) ) );
parameter2 = QString( reinterpret_cast< const char * >( sqlite3_column_text( myPreparedStatement, 1 ) ) );
}
}
// close the sqlite3 statement
sqlite3_finalize( myPreparedStatement );
sqlite3_close( myDatabase );
// row for this ellipsoid wasn't found?
if ( radius.isEmpty() || parameter2.isEmpty() )
{
QgsDebugMsg( QString( "setEllipsoid: no row in tbl_ellipsoid for acronym '%1'" ).arg( ellipsoid ) );
return false;
}
// get major semiaxis
if ( radius.left( 2 ) == "a=" )
mSemiMajor = radius.mid( 2 ).toDouble();
else
{
QgsDebugMsg( QString( "setEllipsoid: wrong format of radius field: '%1'" ).arg( radius ) );
return false;
}
// get second parameter
// one of values 'b' or 'f' is in field parameter2
// second one must be computed using formula: invf = a/(a-b)
if ( parameter2.left( 2 ) == "b=" )
{
mSemiMinor = parameter2.mid( 2 ).toDouble();
mInvFlattening = mSemiMajor / ( mSemiMajor - mSemiMinor );
}
else if ( parameter2.left( 3 ) == "rf=" )
{
mInvFlattening = parameter2.mid( 3 ).toDouble();
mSemiMinor = mSemiMajor - ( mSemiMajor / mInvFlattening );
}
else
{
QgsDebugMsg( QString( "setEllipsoid: wrong format of parameter2 field: '%1'" ).arg( parameter2 ) );
return false;
}
QgsDebugMsg( QString( "setEllipsoid: a=%1, b=%2, 1/f=%3" ).arg( mSemiMajor ).arg( mSemiMinor ).arg( mInvFlattening ) );
// get spatial ref system for ellipsoid
QString proj4 = "+proj=longlat +ellps=" + ellipsoid + " +no_defs";
QgsCoordinateReferenceSystem destCRS;
destCRS.createFromProj4( proj4 );
//TODO: createFromProj4 used to save to the user database any new CRS
// this behavior was changed in order to separate creation and saving.
// Not sure if it necessary to save it here, should be checked by someone
// familiar with the code (should also give a more descriptive name to the generated CRS)
if ( destCRS.srsid() == 0 )
{
QString myName = QString( " * %1 (%2)" )
.arg( QObject::tr( "Generated CRS", "A CRS automatically generated from layer info get this prefix for description" ),
destCRS.toProj4() );
destCRS.saveAsUserCRS( myName );
}
//
// set transformation from project CRS to ellipsoid coordinates
mCoordTransform->setDestCRS( destCRS );
mEllipsoid = ellipsoid;
// precalculate some values for area calculations
computeAreaInit();
return true;
}
static device_id_t
register_device_id(const char *property_name)
{
char device[PROP_VALUE_MAX];
char build_id[PROP_VALUE_MAX];
char buf[PROP_VALUE_MAX];
const char *property_value;
sqlite3_stmt *st;
int rc;
device_id_t device_id;
if (!init_database()) {
return DEVICE_NOT_SUPPORTED;
}
__system_property_get("ro.product.model", device);
__system_property_get("ro.build.display.id", build_id);
device_id = DEVICE_NOT_SUPPORTED;
property_value = NULL;
if (property_name) {
__system_property_get(property_name, buf);
property_value = buf;
}
rc = sqlite3_prepare(db, SQL_QUERY_LAST_DEVICE_ID, -1, &st, NULL);
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_reset(st);
}
if (!IS_SQL_ERROR(rc)) {
for (rc = execute_sql(st); rc == SQLITE_ROW; rc = execute_sql(st)) {
device_id = sqlite3_column_int(st, 0) + 1;
if (device_id <= DEVICE_ID_REGISTER_START) {
device_id = DEVICE_ID_REGISTER_START;
}
break;
}
}
if (IS_SQL_ERROR(rc)) {
printf("%s(%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
sqlite3_finalize(st);
return DEVICE_NOT_SUPPORTED;
}
sqlite3_finalize(st);
rc = sqlite3_prepare(db, SQL_REGISTER_DEVICE, -1, &st, NULL);
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_reset(st);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_int(st, 1, device_id);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 2, device, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 3, build_id, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 4, property_name, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 5, property_value, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = execute_sql(st);
}
if (IS_SQL_ERROR(rc)) {
printf("%s(%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
sqlite3_finalize(st);
return DEVICE_NOT_SUPPORTED;
}
sqlite3_finalize(st);
return device_id;
}
static struct ast_config *config_sqlite(const char *database, const char *table, const char *file, struct ast_config *cfg)
{
struct ast_variable *new_v, *v;
struct ast_category *cur_cat;
char ttable[ARRAY_SIZE];
int configured = 0, res = 0;
sqlite3_stmt *stmt = NULL;;
int cat_metric=0, last_cat_metric=0;
char sql[ARRAY_SIZE];
char last[ARRAY_SIZE] = "";
char path[ARRAY_SIZE];
sqlite3 *db;
int running=0;
int i=0;
struct ast_config *config;
/* if the data was not passed from extconfig.conf then get it from sqlite.conf */
if(!database || ast_strlen_zero(database)) {
if (!file || !strcmp (file, "res_sqlite.conf"))
return NULL; // cant configure myself with myself !
config = ast_config_load ("res_sqlite.conf");
if (config) {
for (v = ast_variable_browse (config, "config"); v; v = v->next) {
if (!strcmp (v->name, "table")) {
strncpy (ttable, v->value, sizeof (ttable));
configured++;
} else if (!strcmp (v->name, "dbfile")) {
pick_path(v->value,path,ARRAY_SIZE);
configured++;
}
}
ast_config_destroy (config);
}
} else {
pick_path((char *)database,path,ARRAY_SIZE);
strncpy (ttable, table, sizeof (ttable));
configured = 2;
}
if (configured < 2)
return NULL;
db=open_db(path);
if (!db)
return NULL;
sprintf (sql, "select * from %s where filename='%s' and commented=0 order by filename,cat_metric desc,var_metric asc,id", ttable, file);
res = sqlite3_prepare(db,sql,0,&stmt,0);
if (res) {
ast_log (LOG_WARNING, "SQL select error [%s]!\n[%s]\n\n",sqlite3_errmsg(db), sql);
return NULL;
}
cur_cat = ast_config_get_current_category(cfg);
/*
0 id int
1 cat_metric int not null default 0,
2 var_metric int not null default 0,
3 commented int not null default 0,
4 filename varchar(128) not null,
5 category varchar(128) not null default 'default',
6 var_name varchar(128) not null,
7 var_val varchar(128) not null
*/
running = 1;
while (running) {
res = sqlite3_step(stmt);
running = 1;
switch( res ){
case SQLITE_DONE: running = 0 ; break;
case SQLITE_BUSY: sleep(2); running = 2; break ;
case SQLITE_ERROR: running = 0; break;
case SQLITE_MISUSE: running = 0; break;
case SQLITE_ROW:
default:
break;
}
if (!running)
break;
if (running == 2)
continue;
if(option_verbose > 4)
for(i=0;i<8;i++){
ast_verbose(VERBOSE_PREFIX_3"SQLite Config: %d=%s\n",i,sqlite3_column_text(stmt,i));
}
if (strcmp (last, sqlite3_column_text(stmt,5)) || last_cat_metric != cat_metric) {
cur_cat = ast_category_new((char *)sqlite3_column_text(stmt,5));
if (!cur_cat) {
ast_log(LOG_WARNING, "Out of memory!\n");
break;
}
strcpy (last, sqlite3_column_text(stmt,5));
last_cat_metric = cat_metric;
ast_category_append(cfg, cur_cat);
}
new_v = ast_variable_new ((char *)sqlite3_column_text(stmt,6), (char *)sqlite3_column_text(stmt,7));
ast_variable_append(cur_cat, new_v);
}
if ((sqlite3_finalize(stmt)))
ast_log(LOG_ERROR,"ERROR: %s\n",sqlite3_errmsg(db));
return cfg;
}
int statement::prepare_impl(char const* stmt)
{
return sqlite3_prepare(db_.db_, stmt, strlen(stmt), &stmt_, &tail_);
}
int main(int argc, char **argv)
{
sqlite3 *db;
sqlite3_stmt *plineInfo = 0;
char *line = NULL;
size_t len = 0;
ssize_t mread;
int fd, n;
long buflen = 0, totread = 0;
char *buf = NULL, *pbuf = NULL;
// char *zErrMsg = 0;
int rc, i;
if (argc < 3) {
fprintf(stderr,
"Usage: %s <DATABASE> <BINARYFILE> < sqlcommands \n\n"
"Or, the following:\n\n"
" $%s test3.db test.png \n"
" eatblob:0> create table blobtest (des varchar(80), b blob);\n"
" eatblob:0> insert into blobtest (des,b) values ('A test file: test.png',?);\n"
" eatblob:1> select * from blobtest;\n"
" A test file: test.png\n"
" eatblob:1>\n\n"
" Note output.0.png will contain a copy of test.png\n\n"
"Or, do everything on the command prompt:\n\n"
" $ ./eatblob test3.db test.png \"create table blobtest (des varchar(80),b blob);\"\n"
" $ ./eatblob test3.db test.png \"insert into blobtest (des,b) values ('A test file: test.png',?);\"\n"
"\n\n",
argv[0], argv[0]);
exit(1);
}
if (sqlite3_open(argv[1], &db) != SQLITE_OK) {
fprintf(stderr, "Can't open database: \n");
sqlite3_close(db);
exit(1);
}
if ((fd = open(argv[2], O_RDWR | O_CREAT, 0600)) == -1) {
fprintf(stderr, "Can't open data: %s\n", strerror(errno));
return 1;
}
while (buflen - totread - 1 < 1024)
buflen = addmem(&buf, buflen);
pbuf = buf;
totread = 0;
while ((n = read(fd, pbuf, 1024)) > 0) {
totread += n;
pbuf[n] = '\0'; // This is for printing test
while (buflen - totread - 1 < 1024)
buflen = addmem(&buf, buflen);
pbuf = &buf[totread];
}
close(fd);
if (argc == 4) {
rc = sqlite3_prepare(db, argv[3], -1, &plineInfo, 0);
if (rc == SQLITE_OK && plineInfo != NULL) {
//fprintf(stderr, "SQLITE_OK\n");
sqlite3_bind_blob(plineInfo, 1, buf, totread,
free);
while ((rc =
sqlite3_step(plineInfo)) == SQLITE_ROW) {
//
for (i = 0;
i < sqlite3_column_count(plineInfo);
++i)
print_col(plineInfo, i);
printf("\n");
}
rc = sqlite3_finalize(plineInfo);
}
fprintf(stderr, "eatblob:%d> ", sqlite3_total_changes(db));
} else {
fprintf(stderr, "eatblob:0> ");
while ((mread = mygetline(&line, &len, stdin)) > 0) {
rc = sqlite3_prepare(db, line, -1, &plineInfo, 0);
if (rc == SQLITE_OK && plineInfo != NULL) {
//fprintf(stderr, "SQLITE_OK\n");
sqlite3_bind_blob(plineInfo, 1, buf,
totread, free);
while ((rc =
sqlite3_step(plineInfo)) ==
SQLITE_ROW) {
//
for (i = 0;
i <
sqlite3_column_count
(plineInfo); ++i)
print_col(plineInfo, i);
printf("\n");
}
rc = sqlite3_finalize(plineInfo);
}
fprintf(stderr, "eatblob:%d> ",
sqlite3_total_changes(db));
} /* end of while */
}
if (line) {
free(line);
}
sqlite3_close(db);
return 0;
}
void output(char tbl){
char* type;
char* query;
sqlite3 *db;
char *zErrMsg = 0;
int rc;
std::ofstream outputfl;
switch (tbl){
case 'A':
{
type = "artist";
outputfl.open("artist.report.txt");
outputfl << "id | name\n";
query = "select * from artist";
break;
}
case 'C':
{
type = "cd";
outputfl.open("cd.report.txt");
outputfl << "id | title | artist_id | catalogue\n";
query = "select * from cd";
break;
}
case 'T':
{
type = "track";
outputfl.open("track.report.txt");
outputfl << "cd_id | track_id | title\n";
query = "select * from track";
break;
}
} // end of switch
// open database
rc = sqlite3_open("song.db", &db);
if (rc){
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
exit(0);
}
else{
fprintf(stdout, "Opened database successfully\n");
}
// prepare sql statement and output data to ofstream;
sqlite3_stmt *statement;
if (sqlite3_prepare(db, query, -1, &statement, 0) == SQLITE_OK)
{
int ctotal = sqlite3_column_count(statement);
int res = 0;
while (1)
{
res = sqlite3_step(statement);
if (res == SQLITE_ROW)
{
for (int i = 0; i < ctotal; i++)
{
std::string s = (char*)sqlite3_column_text(statement, i);
// output code here with formatting
outputfl << s;
if (i < ctotal - 1){
outputfl << " | ";
}
}
outputfl << "\n";
}
if (res == SQLITE_DONE || res == SQLITE_ERROR)
{
printf("done with %s table\n", type);
break;
}
} // end of while
} // end of if prepare
outputfl.close();
} // end of output
BOOL InsertBusStu(struct bus_stu &Bus_Student)
{
CString strSQL;
char* errMsg;
strSQL = _T("SELECT * from bus_stu where bus_run_ID='");
strSQL += Bus_Student.bus_run_ID;
strSQL += _T("' and student_ID='");
strSQL += Bus_Student.student_ID;
strSQL += _T("'");
char temp_data[1024]={'\0'};
WideCharToMultiByte(CP_ACP,0,(LPCWSTR)strSQL,-1,(LPSTR)temp_data,sizeof(temp_data),NULL,NULL);
sqlite3_stmt *stmt = NULL;
if(SQLITE_OK != sqlite3_prepare(pDB, temp_data, strlen(temp_data), &stmt, NULL))
{
return FALSE;
}
if(SQLITE_ROW != sqlite3_step(stmt)) //没有数据，插入数据
{
sqlite3_finalize(stmt);
strSQL = _T("INSERT into bus_stu values ('");
strSQL += Bus_Student.bus_run_ID;
strSQL += _T("', '");
strSQL += Bus_Student.student_ID;
strSQL += _T("', '");
strSQL += Bus_Student.up_station_ID;
strSQL += _T("', '");
strSQL += Bus_Student.up_time;
strSQL += _T("', '");
strSQL += Bus_Student.down_station_ID;
strSQL += _T("', '");
strSQL += Bus_Student.down_time;
strSQL += _T("', '')");
memset(temp_data, 0x00, sizeof(temp_data));
WideCharToMultiByte(CP_ACP,0,(LPCWSTR)strSQL,-1,(LPSTR)temp_data,sizeof(temp_data),NULL,NULL);
if( SQLITE_OK!=sqlite3_exec(pDB,temp_data,0,0,&errMsg))
{
#ifdef DEBUG_YFH
CString error(errMsg);
CString tmp;
tmp = _T("输入表bus_student数据错误,错误原因:") + error;
AfxMessageBox(tmp);
#endif
return FALSE;
}
}else{ //有数据，更新数据
sqlite3_finalize(stmt);
strSQL = _T("UPDATE bus_stu set up_station_ID='");
strSQL += Bus_Student.up_station_ID;
strSQL += _T("', up_time='");
strSQL += Bus_Student.up_time;
strSQL += _T("', down_station_ID='");
strSQL += Bus_Student.down_station_ID;
strSQL += _T("', down_time='");
strSQL += Bus_Student.down_time;
strSQL += _T("' where bus_run_ID='");
strSQL += Bus_Student.bus_run_ID;
strSQL += _T("' and student_ID='");
strSQL += Bus_Student.student_ID;
strSQL += _T("'");
memset(temp_data, 0x00, sizeof(temp_data));
WideCharToMultiByte(CP_ACP,0,(LPCWSTR)strSQL,-1,(LPSTR)temp_data,sizeof(temp_data),NULL,NULL);
if( SQLITE_OK!=sqlite3_exec(pDB,temp_data,0,0,&errMsg))
{
#ifdef DEBUG_YFH
CString error(errMsg);
CString tmp;
tmp = _T("输入表bus_student数据错误1,错误原因:") + error;
AfxMessageBox(tmp);
#endif
return FALSE;
}
}
return TRUE;
}
static void _mapcache_cache_mbtiles_delete(mapcache_context *ctx, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) tile->tileset->cache;
struct sqlite_conn *conn = _sqlite_get_conn(ctx, tile, 0);
sqlite3_stmt *stmt1,*stmt2,*stmt3;
int ret;
const char *tile_id;
size_t tile_id_size;
if (GC_HAS_ERROR(ctx)) {
_sqlite_release_conn(ctx, tile, conn);
return;
}
stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX];
stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX];
stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle, "select tile_id from map where tile_col=:x and tile_row=:y and zoom_level=:z",-1,&conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX], NULL);
sqlite3_prepare(conn->handle, "delete from map where tile_col=:x and tile_row=:y and zoom_level=:z", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle, "delete from images where tile_id=:foobar", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX];
stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX];
stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX];
}
/* first extract tile_id from the tile we will delete. We need this because we do not know
* if the tile is empty or not.
* If it is empty, we will not delete the image blob data from the images table */
cache->bind_stmt(ctx, stmt1, tile);
do {
ret = sqlite3_step(stmt1);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 1: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
_sqlite_release_conn(ctx, tile, conn);
return;
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if (ret == SQLITE_DONE) { /* tile does not exist, ignore */
sqlite3_reset(stmt1);
_sqlite_release_conn(ctx, tile, conn);
return;
} else {
tile_id = (const char*) sqlite3_column_text(stmt1, 0);
tile_id_size = sqlite3_column_bytes(stmt1, 0);
}
/* delete the tile from the "map" table */
cache->bind_stmt(ctx,stmt2, tile);
ret = sqlite3_step(stmt2);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 2: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
_sqlite_release_conn(ctx, tile, conn);
return;
}
if(tile_id[0] != '#') {
/* the tile isn't empty, we must also delete from the images table */
int paramidx = sqlite3_bind_parameter_index(stmt3, ":foobar");
if (paramidx) {
sqlite3_bind_text(stmt3, paramidx, tile_id, tile_id_size, SQLITE_STATIC);
}
ret = sqlite3_step(stmt3);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 3: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
sqlite3_reset(stmt3);
_sqlite_release_conn(ctx, tile, conn);
return;
}
}
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
sqlite3_reset(stmt3);
_sqlite_release_conn(ctx, tile, conn);
}
static inline int
gf_sql_delete_link (gf_sql_connection_t *sql_conn,
char *gfid,
char *pargfid,
char *basename)
{
int ret = -1;
sqlite3_stmt *delete_stmt = NULL;
char *delete_str = "DELETE FROM "
GF_FILE_LINK_TABLE
" WHERE GF_ID = ? AND GF_PID = ?"
" AND FNAME = ?;";
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
/*Prepare statement*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_str, -1,
&delete_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing delete "
"statment %s : %s", delete_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (delete_stmt, 1, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED,
"Failed binding gfid %s : %s", gfid,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind pargfid*/
ret = sqlite3_bind_text (delete_stmt, 2, pargfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
": %s", pargfid,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind basename*/
ret = sqlite3_bind_text (delete_stmt, 3, basename, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
"%s", basename,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step(delete_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
delete_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
/*Free prepared statement*/
sqlite3_finalize (delete_stmt);
return ret;
}
static void _single_mbtile_set(mapcache_context *ctx, mapcache_tile *tile, struct sqlite_conn *conn)
{
sqlite3_stmt *stmt1,*stmt2;
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)tile->tileset->cache;
int ret;
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
stmt1 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle,
"insert or ignore into images(tile_id,tile_data) values (:color,:data);",
-1, &conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle,
"insert or replace into map(tile_column,tile_row,zoom_level,tile_id) values (:x,:y,:z,:color);",
-1, &conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX];
}
cache->bind_stmt(ctx, stmt1, tile);
cache->bind_stmt(ctx, stmt2, tile);
} else {
stmt1 = conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle,
"insert or replace into images(tile_id,tile_data) values (:key,:data);",
-1, &conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle,
"insert or replace into map(tile_column,tile_row,zoom_level,tile_id) values (:x,:y,:z,:key);",
-1, &conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX];
}
cache->bind_stmt(ctx, stmt1, tile);
cache->bind_stmt(ctx, stmt2, tile);
}
do {
ret = sqlite3_step(stmt1);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "mbtiles backend failed on image set: %s (%d)", sqlite3_errmsg(conn->handle), ret);
break;
}
if (ret == SQLITE_BUSY) {
sqlite3_reset(stmt1);
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if(ret == SQLITE_DONE) {
do {
ret = sqlite3_step(stmt2);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "mbtiles backend failed on map set: %s (%d)", sqlite3_errmsg(conn->handle), ret);
break;
}
if (ret == SQLITE_BUSY) {
sqlite3_reset(stmt2);
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
}
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
}
static inline int
gf_sql_delete_all (gf_sql_connection_t *sql_conn,
char *gfid)
{
int ret = -1;
sqlite3_stmt *delete_file_stmt = NULL;
sqlite3_stmt *delete_link_stmt = NULL;
char *delete_link_str = "DELETE FROM "
GF_FILE_LINK_TABLE
" WHERE GF_ID = ? ;";
char *delete_file_str = "DELETE FROM "
GF_FILE_TABLE
" WHERE GF_ID = ? ;";
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
/*
* Delete all links associated with this GFID
*
* */
/*Prepare statement for delete all links*/
ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1,
&delete_link_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing delete "
"statment %s : %s", delete_link_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (delete_link_stmt, 1, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step (delete_link_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
delete_link_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*
* Delete entry from file table associated with this GFID
*
* */
/*Prepare statement for delete all links*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_file_str, -1,
&delete_file_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing delete "
"statment %s : %s", delete_file_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (delete_file_stmt, 1, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step (delete_file_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt %s : %s",
delete_file_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
out:
/*Free prepared statement*/
sqlite3_finalize (delete_file_stmt);
sqlite3_finalize (delete_link_stmt);
return ret;
}
PreparedStatement* SqliteDatabaseLayer::PrepareStatement(const wxString& strQuery, bool bLogForCleanup)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
SqlitePreparedStatement* pReturnStatement = new SqlitePreparedStatement((sqlite3*)m_pDatabase);
if (pReturnStatement)
pReturnStatement->SetEncoding(GetEncoding());
wxArrayString QueryArray = ParseQueries(strQuery);
wxArrayString::iterator start = QueryArray.begin();
wxArrayString::iterator stop = QueryArray.end();
while (start != stop)
{
const char* szTail=0;
wxCharBuffer sqlBuffer;
do
{
sqlite3_stmt* pStatement;
wxString strSQL;
if (szTail != 0)
{
strSQL = (wxChar*)szTail;
}
else
{
strSQL = (*start);
}
sqlBuffer = ConvertToUnicodeStream(strSQL);
#if SQLITE_VERSION_NUMBER>=3003009
int nReturn = sqlite3_prepare_v2((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail);
#else
int nReturn = sqlite3_prepare((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail);
#endif
if (nReturn != SQLITE_OK)
{
SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(nReturn));
SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg((sqlite3*)m_pDatabase)));
wxDELETE(pReturnStatement);
ThrowDatabaseException();
return NULL;
}
pReturnStatement->AddPreparedStatement(pStatement);
#if wxUSE_UNICODE
} while (strlen(szTail) > 0);
#else
} while (wxStrlen(szTail) > 0);
#endif
start++;
}
if (bLogForCleanup)
LogStatementForCleanup(pReturnStatement);
return pReturnStatement;
}
static inline int
gf_sql_insert_write_wind_time (gf_sql_connection_t *sql_conn,
char *gfid,
gfdb_time_t *wind_time)
{
int ret = -1;
sqlite3_stmt *insert_stmt = NULL;
char *insert_str = "INSERT INTO "
GF_FILE_TABLE
"(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)"
" VALUES (?, ?, ?, 0, 0);";
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, wind_time, out);
/*Prepare statement*/
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
&insert_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing insert "
"statment %s : %s", insert_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind gfid*/
ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind wind secs*/
ret = sqlite3_bind_int (insert_stmt, 2, wind_time->tv_sec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent wind "
"secs %ld : %s", wind_time->tv_sec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind wind msecs*/
ret = sqlite3_bind_int (insert_stmt, 3, wind_time->tv_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding parent wind "
"msecs %ld : %s", wind_time->tv_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the prepare statement*/
if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
"Failed executing the prepared stmt GFID:%s %s : %s",
gfid, insert_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
/*Free prepared statement*/
sqlite3_finalize (insert_stmt);
return ret;
}
list getByDate(struct tm t, struct error* err, const char* sql) {
err->error = NO_ERROR;
int seconds = t.tm_sec;
int minutes = t.tm_min;
int day = t.tm_wday;
int hours = t.tm_hour;
int month = t.tm_mon;
int year = t.tm_year;
year += 1900;
char* month_str;
char* day_str;
switch(month) {
case 0:
month_str = "Jan";
break;
case 1:
month_str = "Feb";
break;
case 2:
month_str = "Mar";
break;
case 3:
month_str = "Apr";
break;
case 4:
month_str = "May";
break;
case 5:
month_str = "Jun";
break;
case 6:
month_str = "Jul";
break;
case 7:
month_str = "Aug";
break;
case 8:
month_str = "Sep";
break;
case 9:
month_str = "Oct";
break;
case 10:
month_str = "Nov";
break;
case 11:
month_str = "Dec";
break;
default:
month_str = "%";
break;
}
switch(day) {
case 0:
day_str = "Sun";
break;
case 1:
day_str = "Mon";
break;
case 2:
day_str = "Tue";
break;
case 3:
day_str = "Wed";
break;
case 4:
day_str = "Thu";
break;
case 5:
day_str = "Fri";
break;
case 6:
day_str = "Sat";
break;
default:
day_str = "%";
break;
}
char seconds_str[3];
char minutes_str[3];
char hours_str[3];
char year_str[5];
sqlite3_stmt* statement;
const char* unused;
if(seconds < 0 || seconds > 60) {
strcpy(seconds_str,"%");
} else {
sprintf(seconds_str, "%d", seconds);
}
if(minutes < 0 || minutes > 59) {
strcpy(minutes_str, "%");
} else {
sprintf(minutes_str, "%d", minutes);
}
if(hours < 0 || hours > 23) {
strcpy(hours_str, "%");
} else {
sprintf(hours_str, "%d", hours);
}
if(year < 1900) {
strcpy(year_str, "%");
} else {
sprintf(year_str, "%d", year);
}
int rc = sqlite3_prepare(db, sql, -1, &statement, &unused);
if(rc != SQLITE_OK) {
err->error = DATABASE_SELECT;
err->description = sqlite3_errmsg(db);
return NULL;
}
int total_length = strlen(day_str) + 1 /*space*/ +
strlen(month_str)+ 1 /*space*/ + 8 /*hh:mm:ss*/+ 1/*space*/ + 4 /*year*/
+ 1 /*\0*/;
char* value = (char*)malloc(total_length * sizeof(char));
strcpy(value, day_str);
strcat(value, " ");
strcat(value, month_str);
strcat(value, " ");
strcat(value, hours_str);
strcat(value, ":");
strcat(value, minutes_str);
strcat(value, ":");
strcat(value, seconds_str);
strcat(value, " ");
strcat(value, year_str);
sqlite3_bind_text(statement, 1, value, strlen(value), SQLITE_STATIC);
list l = l_new();
if(sqlite3_step(statement) != SQLITE_ROW) {
err->error = DATABASE_SELECT;
err->description = sqlite3_errmsg(db);
sqlite3_finalize(statement);
return NULL;
}
populateList(l, statement);
while(sqlite3_step(statement) == SQLITE_ROW) {
populateList(l, statement);
}
free(value);
return l;
}
range* rangefunc_group(range_request* rr, range** r)
{
range* ret;
const char** members;
int i, err;
sqlite3* db;
sqlite3_stmt* tag_stmt;
sqlite3_stmt* all_nodes_stmt;
apr_pool_t* pool = range_request_pool(rr);
libcrange* lr = range_request_lr(rr);
ret = range_new(rr);
members = range_get_hostnames(pool, r[0]);
if (!(db = libcrange_get_cache(lr, "sqlite:nodes"))) {
const char* sqlite_db_path = libcrange_getcfg(lr, "sqlitedb");
if (!sqlite_db_path) sqlite_db_path = DEFAULT_SQLITE_DB;
err = sqlite3_open(sqlite_db_path, &db);
if (err != SQLITE_OK) {
fprintf(stderr, "%s: %s\n", sqlite_db_path, sqlite3_errmsg(db));
return ret;
}
libcrange_set_cache(lr, "sqlite:nodes", db);
}
/* prepare our selects */
err = sqlite3_prepare(db, ALL_NODES_SQL, strlen(ALL_NODES_SQL),
&all_nodes_stmt, NULL);
if (err != SQLITE_OK) {
fprintf(stderr, "%s: %s\n", ALL_NODES_SQL, sqlite3_errmsg(db));
abort();
}
err = sqlite3_prepare(db, RANGE_FROM_TAGS, strlen(RANGE_FROM_TAGS),
&tag_stmt, NULL);
assert(err == SQLITE_OK);
/* for each group */
for (i = 0; members[i]; ++i) {
sqlite3_stmt* stmt;
if (strcmp(members[i], "ALL") == 0) {
stmt = all_nodes_stmt;
} else {
stmt = tag_stmt;
/* bind the current group name */
sqlite3_bind_text(tag_stmt, 1, members[i], strlen(members[i]), SQLITE_STATIC);
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
range* this_group;
const char* result = (const char*)sqlite3_column_text(stmt, 0);
if (stmt == all_nodes_stmt) {
range_add(ret, result);
} else {
this_group = do_range_expand(rr, result);
set_union_inplace(ret->nodes, this_group->nodes);
}
}
sqlite3_reset(stmt);
}
sqlite3_finalize(all_nodes_stmt);
sqlite3_finalize(tag_stmt);
return ret;
}
YaTablePhraseRule* YaTablePhraseLoadRule(YaTableSid sid)
{
sqlite3* sqlhandle = YATABLESID(sid)->handle;
sqlite3_stmt* stmt = NULL;
char sql[64] = "SELECT rule FROM [PhraseRule] ORDER BY rule;";
int above = 0;
YaTablePhraseRule* pr = NULL,* prev = NULL,* head = NULL,* tail = NULL;
char* sztmp = NULL;
char* rulestr = NULL;
int* rule = NULL;
size_t codelen = YATABLESID(sid)->info->keylength;
if(sqlite3_prepare(sqlhandle, sql, -1, &stmt, NULL) != SQLITE_OK) {
return NULL;
}
while(sqlite3_step(stmt) == SQLITE_ROW) {
sztmp = (char*) sqlite3_column_text(stmt, 0);
if((above > 0) && (sztmp[0] == 'a'))
continue;
rulestr = yamalloc(strlen(sztmp) + 1);
strcpy(rulestr, sztmp);
delwhitespace(rulestr);
rule = YaTablePhraseGenRule(rulestr, codelen);
yafree(rulestr);
if(rule == NULL) continue;
if(*rule == 1) {
above = *(rule + 1);
} else {
if((above > 0) && (*(rule + 1) >= above)) {
yafree(rule);
break;
}
}
if(head != NULL) {
int* val = prev->rule;
if(*(rule + 1) == *(val + 1)) {
yafree(rule);
continue;
}
}
pr = yamalloc(sizeof(YaTablePhraseRule));
pr->codelen = codelen;
pr->next = NULL;
pr->rule = rule;
if(*rule == 1) {
tail = pr;
continue;
}
if(head == NULL) {
head = pr;
prev = pr;
} else {
prev->next = pr;
prev = pr;
}
};
if(head == NULL) {
head = tail;
} else {
prev->next = tail;
}
return head;
}
/**
* @brief Entering the programm
*
* The Program starts here.
*
* @param argc The Number of Arguments
* @param argv The Arguments
*/
int main(int argc, char *argv[])
{
config_einlesen();
if(argc != 5 && strstr(server, "SERVER"))
{
printf("Bitte folgendes Format einhalten:\n%s [server] [port] [channel (ohne '#')] [nick]\n\nOder Alternativ die Datei .config ändern.\n", argv[0]);
return 0;
}
if (argc == 5)
{
strcpy(server, argv[1]);
strcpy(port, argv[2]);
strcpy(channel, argv[3]);
strcpy(nick, argv[4]);
}
//Vor Release aktivieren - zum debuggen deaktiviert lassen
//daemonize();
//Datenbank
int id;
sqlite3 *db_handler;
sqlite3_open(DATABASE_FILE, &db_handler);
create_table(db_handler);
int sock;
int rec;
char recvbuf[512];
char sendbuf[512];
char *tok;
struct addrinfo *results, hints;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
int gai_err = getaddrinfo( server, port, &hints, &results);
if(gai_err != 0)
{
fprintf(stderr, "%s\n", gai_strerror(gai_err));
exit(EXIT_FAILURE);
}
sock = socket(results->ai_family, results->ai_socktype, results->ai_protocol);
if(sock == -1)
{
perror("sock()");
freeaddrinfo(results);
exit(EXIT_FAILURE);
}
if(connect(sock, results->ai_addr, results->ai_addrlen) == -1)
{
perror("connect()");
freeaddrinfo(results);
exit(EXIT_FAILURE);
}
sprintf(sendbuf, "NICK %s\r\nUSER %s 0 * :Pascal König\r\n", nick, nick);
if(send(sock, sendbuf, strlen(sendbuf), 0) == -1)
{
perror("send()");
freeaddrinfo(results);
exit(EXIT_FAILURE);
}
while(rec = recv(sock, recvbuf, sizeof(recvbuf), 0))
{
if(rec <= 0)
break;
struct tm *zeit;
time_t sekunde;
time( &sekunde );
zeit = localtime(&sekunde);
strftime(uhrzeit, sizeof(uhrzeit), "%Y-%m-%d %H:%M", zeit);
char recvbuf_temp[512];
strcpy(recvbuf_temp, recvbuf);
if(strstr(recvbuf_temp, "PRIVMSG"))
{
zeile_splitten_loggen(db_handler, recvbuf_temp);
}
else
{
zeile_loggen(db_handler, recvbuf_temp);
}
printf("%s", recvbuf);
if(strstr(recvbuf, "MODE"))
{
sprintf(sendbuf, "JOIN #%s\r\n", channel);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
if(strstr(recvbuf, "PING"))
{
tok = strtok(recvbuf, "PING :");
sprintf(sendbuf, "PONG :%s", tok);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "Uhrzeit"))
{
sprintf(sendbuf, "PRIVMSG #%s :%s\r\n", channel, uhrzeit);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_send_splitten_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
else if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "Kill dich"))
{
sprintf(sendbuf, "QUIT\r\n");
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
else if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "LastSeen"))
{
char *recv_nick_buf;
strcpy(recv_nick_buf, strtok(recvbuf," "));
strcpy(recv_nick_buf, strtok(NULL," "));
strcpy(recv_nick_buf, strtok(NULL," "));
strcpy(recv_nick_buf, strtok(NULL," "));
strcpy(recv_nick_buf, strtok(NULL," "));
strcpy(recv_nick_buf, strtok(NULL,"\r"));
sqlite3_stmt *vm;
char *sql_query;
sql_query = sqlite3_mprintf("SELECT * FROM log WHERE nick = ':%s' ORDER BY id DESC LIMIT 1", recv_nick_buf);
printf("%s\n", sql_query);
sqlite3_prepare_v2(db_handler, sql_query, strlen(sql_query), &vm, NULL);
while(sqlite3_step(vm) != SQLITE_DONE)
{
sprintf(sendbuf, "PRIVMSG #%s :Der User %s wurde zuletzt am %s auf dem Server %s im Channel %s gesehen. Seine letzte Nachricht: %s\r\n", channel, sqlite3_column_text(vm, 2), sqlite3_column_text(vm, 1), sqlite3_column_text(vm, 3), sqlite3_column_text(vm, 4), sqlite3_column_text(vm, 5));
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
memset(sendbuf, 0, 512);
}
sqlite3_finalize(vm);
}
else if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "Log ausgeben"))
{
sqlite3_stmt *vm;
sqlite3_prepare(db_handler, "SELECT * FROM log", -1, &vm, NULL);
while(sqlite3_step(vm) != SQLITE_DONE)
{
sprintf(sendbuf, "PRIVMSG #%s :%i\t%s\t%s\t%s\t%s\t%s\n", channel, sqlite3_column_int(vm, 0), sqlite3_column_text(vm, 1), sqlite3_column_text(vm, 2), sqlite3_column_text(vm, 3), sqlite3_column_text(vm, 4), sqlite3_column_text(vm, 5));
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
memset(sendbuf, 0, 512);
}
sqlite3_finalize(vm);
}
else if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "Switch Logging"))
{
if (logging == 1)
{
sprintf(sendbuf, "PRIVMSG #%s :Logging deaktiviert\r\n", channel);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_send_splitten_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
logging = 0;
}
else
{
logging = 1;
sprintf(sendbuf, "PRIVMSG #%s :Logging aktiviert\r\n", channel);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_send_splitten_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
}
else
{
if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && strstr(recvbuf, "#")) //Nachricht im Channel
{
sprintf(sendbuf, "PRIVMSG #%s :Ich nehme folgende Befehle entgegen: '%s Uhrzeit', '%s Kill dich', '%s LastSeen NICK', '%s Log ausgeben' und '%s Switch Logging'\r\n", channel, nick, nick, nick, nick, nick);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_send_splitten_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
if(strstr(recvbuf, "PRIVMSG") && strstr(recvbuf, nick) && !strstr(recvbuf, "#")) //PN erhalten
{
sprintf(sendbuf, "PRIVMSG #%s :Ich nehme auch per PN Befehle entgegen, die Ausgabe erfolgt jedoch in den Channel.\r\n", channel);
send(sock, sendbuf, strlen(sendbuf), 0);
printf("%s", sendbuf);
zeile_send_splitten_loggen(db_handler, sendbuf);
memset(sendbuf, 0, 512);
}
}
memset(recvbuf, 0, 512);
}
freeaddrinfo(results);
sqlite3_close(db_handler);
return 0;
}
boolean YaTablePhraseAddNewPhrase(YaTableSid sid)
{
YaTableCommitData* commitdata = YATABLESID(sid)->commitdata;
YaTableCommitData* data = NULL;
sqlite3* handle = YATABLESID(sid)->handle;
sqlite3_stmt* stmt = NULL;
size_t codelen = 0;
char* commitstr = YATABLESID(sid)->commitstr;
char* sql = NULL;
char wordsepar = YATABLESID(sid)->info->WordSepar;
YaTablePhraseRule* rule = YATABLESID(sid)->info->rule;;
boolean noempty = YATABLESID(sid)->info->PhraseCodeNoempty;
boolean useonce = YATABLESID(sid)->info->PhraseCodeUseonce;
if(commitdata == NULL) return false;
data = commitdata;
while(data != NULL) {
codelen += strlen(data->code);
data = data->next;
}
char* commitcode = yamalloc(sizeof(char) * (codelen + 1));
data = commitdata;
while(data != NULL) {
strcat(commitcode, data->code);
data = data->next;
}
if(sqlite3_exec(handle, "CREATE TABLE IF NOT EXISTS [tempPhrase] "
"([code] char, [text] char, [used] int);", 0, 0, NULL) !=
SQLITE_OK) {
yafree(commitcode);
return false;
}
sqlite3_free(sql);
sql = sqlite3_mprintf("SELECT used FROM [tempPhrase] WHERE "
"code=%q%q%q AND text=%q%q%q;",
"\"", commitcode, "\"", "\"", commitstr, "\"");
sqlite3_prepare(handle, sql, -1, &stmt, NULL);
sqlite3_free(sql);
if(sqlite3_step(stmt) != SQLITE_ROW) {
sqlite3_finalize(stmt);
sql = sqlite3_mprintf("INSERT INTO [tempPhrase] "
"VALUES(\'%q\', \'%q\', 1);",
commitcode, commitstr);
yafree(commitcode);
boolean val = true;
if(sqlite3_exec(handle, sql, 0, 0, NULL) != SQLITE_OK) val = false;
sqlite3_free(sql);
return val;
}
size_t codeweight = 3;
size_t used = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if(used >= codeweight) {
sql = sqlite3_mprintf("DELETE FROM [tempPhrase] "
"WHERE code=\"%q\" AND text=\"%q\";",
commitcode, commitstr);
if(sqlite3_exec(handle, sql, 0, 0, NULL) != SQLITE_OK) {
yafree(commitcode);
sqlite3_free(sql);
return false;
}
data = commitdata;
char* sztmp = NULL;
while(data != NULL) {
sztmp = YaTablePhraseGetstem(sid, data->code, data->text);
if(sztmp != NULL) {
yafree(data->code);
data->code = sztmp;
}
data = data->next;
}
char* code = NULL;
code = YaTablePhraseGenCode(commitdata, rule,
wordsepar, noempty, useonce);
if(code == NULL) {
yafree(commitcode);
sqlite3_free(sql);
return false;
}
boolean val = true;
sql = sqlite3_mprintf("SELECT weight FROM [Data] WHERE "
"code=%q%q%q AND text=%q%q%q;",
"\"", code, "\"", "\"", commitstr, "\"");
sqlite3_prepare(handle, sql, -1, &stmt, NULL);
sqlite3_free(sql);
if(sqlite3_step(stmt) != SQLITE_ROW) {
sql = sqlite3_mprintf("INSERT INTO [Data] "
"VALUES(\'%q\', \'%q\', \'\', %u, %d);",
code, commitstr, codeweight, \
YATABLE_USER_PHRASE);
if(sqlite3_exec(handle, sql, 0, 0, NULL) != SQLITE_OK) val = false;
sqlite3_free(sql);
}
sqlite3_finalize(stmt);
yafree(code);
yafree(commitcode);
return val;
}
boolean val = true;
sql = sqlite3_mprintf("UPDATE [tempPhrase] SET used=%d "
"WHERE code=%q%q%q AND text=%q%q%q;", used + 1,
"\"", commitcode, "\"", "\"", commitstr, "\"");
if(sqlite3_exec(handle, sql, 0, 0, NULL) != SQLITE_OK) val = false;
yafree(commitcode);
sqlite3_free(sql);
return val;
}
/*
* Find recently changed files with a specific frequency from the DB
* Input:
* db_conn : db connection object
* query_callback : query callback fuction to handle
* result records from the query
* from_time : Time to define what is recent
* freq_write_cnt : Frequency thresold for write
* freq_read_cnt : Frequency thresold for read
* clear_counters : Clear counters (r/w) for all inodes in DB
* */
int
gf_sqlite3_find_recently_changed_files_freq (void *db_conn,
gf_query_callback_t query_callback,
void *query_cbk_args,
gfdb_time_t *from_time,
int freq_write_cnt,
int freq_read_cnt,
gf_boolean_t clear_counters)
{
int ret = -1;
char *query_str = NULL;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *prep_stmt = NULL;
long int from_time_usec = 0;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
query_str = "select GF_FILE_TB.GF_ID,"
" (select group_concat( GF_PID || ',' || FNAME || ','"
" || FPATH || ',' || W_DEL_FLAG ||',' || LINK_UPDATE , '::')"
" from GF_FLINK_TB where GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID)"
" from GF_FILE_TB where "
/*First condition: For Writes*/
"( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_WMSEC ") >= ? )"
" AND "" (" GF_COL_TB_WFC " >= ? ) )"
" OR "
/*Second condition: For Reads */
"( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_RWMSEC ") >= ?)"
" AND "" (" GF_COL_TB_RFC " >= ? ) )";
from_time_usec = gfdb_time_2_usec(from_time);
ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1,
&prep_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed preparing statment %s :"
" %s", query_str,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write wind time*/
ret = sqlite3_bind_int64(prep_stmt, 1, from_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding from_time_usec "
"%ld : %s", from_time_usec,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write frequency thresold*/
ret = sqlite3_bind_int(prep_stmt, 2, freq_write_cnt);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding freq_write_cnt "
"%d : %s", freq_write_cnt,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read wind time*/
ret = sqlite3_bind_int64(prep_stmt, 3, from_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding from_time_usec "
"%ld : %s", from_time_usec,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read frequency thresold*/
ret = sqlite3_bind_int(prep_stmt, 4, freq_read_cnt);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed binding freq_read_cnt "
"%d : %s", freq_read_cnt,
sqlite3_errmsg(sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the query*/
ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed Query %s", query_str);
goto out;
}
/*Clear counters*/
if (clear_counters) {
ret = gf_sql_clear_counters(sql_conn);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CLEAR_COUNTER_FAILED, "Failed clearing"
" counters!");
goto out;
}
}
ret = 0;
out:
sqlite3_finalize (prep_stmt);
return ret;
}
/**
* 初始化数据库
* @param[in] env 存储着应用程序运行环境的结构体
* @param[in] db_path 待初始化的数据库文件的名字
* @return sqlite3的错误代码
* @retval 0 成功
*/
int
init_database(wiser_env *env, const char *db_path)
{
int rc;
if ((rc = sqlite3_open(db_path, &env->db))) {
print_error("cannot open databases.");
return rc;
}
sqlite3_exec(env->db,
"CREATE TABLE settings (" \
" key TEXT PRIMARY KEY," \
" value TEXT" \
");",
NULL, NULL, NULL);
sqlite3_exec(env->db,
"CREATE TABLE documents (" \
" id INTEGER PRIMARY KEY," /* auto increment */ \
" title TEXT NOT NULL," \
" body TEXT NOT NULL" \
");",
NULL, NULL, NULL);
sqlite3_exec(env->db,
"CREATE TABLE tokens (" \
" id INTEGER PRIMARY KEY," \
" token TEXT NOT NULL," \
" docs_count INT NOT NULL," \
" postings BLOB NOT NULL" \
");",
NULL, NULL, NULL);
sqlite3_exec(env->db,
"CREATE UNIQUE INDEX token_index ON tokens(token);",
NULL, NULL, NULL);
sqlite3_exec(env->db,
"CREATE UNIQUE INDEX title_index ON documents(title);" ,
NULL, NULL, NULL);
sqlite3_prepare(env->db,
"SELECT id FROM documents WHERE title = ?;",
-1, &env->get_document_id_st, NULL);
sqlite3_prepare(env->db,
"SELECT title FROM documents WHERE id = ?;",
-1, &env->get_document_title_st, NULL);
sqlite3_prepare(env->db,
"INSERT INTO documents (title, body) VALUES (?, ?);",
-1, &env->insert_document_st, NULL);
sqlite3_prepare(env->db,
"UPDATE documents set body = ? WHERE id = ?;",
-1, &env->update_document_st, NULL);
sqlite3_prepare(env->db,
"SELECT id, docs_count FROM tokens WHERE token = ?;",
-1, &env->get_token_id_st, NULL);
sqlite3_prepare(env->db,
"SELECT token FROM tokens WHERE id = ?;",
-1, &env->get_token_st, NULL);
sqlite3_prepare(env->db,
"INSERT OR IGNORE INTO tokens (token, docs_count, postings)"
" VALUES (?, 0, ?);",
-1, &env->store_token_st, NULL);
sqlite3_prepare(env->db,
"SELECT docs_count, postings FROM tokens WHERE id = ?;",
-1, &env->get_postings_st, NULL);
sqlite3_prepare(env->db,
"UPDATE tokens SET docs_count = ?, postings = ? WHERE id = ?;",
-1, &env->update_postings_st, NULL);
sqlite3_prepare(env->db,
"SELECT value FROM settings WHERE key = ?;",
-1, &env->get_settings_st, NULL);
sqlite3_prepare(env->db,
"INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?);",
-1, &env->replace_settings_st, NULL);
sqlite3_prepare(env->db,
"SELECT COUNT(*) FROM documents;",
-1, &env->get_document_count_st, NULL);
sqlite3_prepare(env->db,
"BEGIN;",
-1, &env->begin_st, NULL);
sqlite3_prepare(env->db,
"COMMIT;",
-1, &env->commit_st, NULL);
sqlite3_prepare(env->db,
"ROLLBACK;",
-1, &env->rollback_st, NULL);
sqlite3_prepare(env->db,
"SELECT LENGTH(body) FROM documents WHERE id = ?;",
-1, &env->get_document_body_size_st, NULL);
return 0;
}
