自学教程：C++ sqlite3_prepare函数代码示例

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 * */intgf_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 intgf_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;//.........这里部分代码省略.........

/*Update write/read times for both wind and unwind*/static inline intgf_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) {//.........这里部分代码省略.........

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 intgf_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);                }//.........这里部分代码省略.........

/*** 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 ){//.........这里部分代码省略.........

static device_id_tget_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;  }//.........这里部分代码省略.........

static device_id_tregister_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;			}//.........这里部分代码省略.........

 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);//.........这里部分代码省略.........

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 intgf_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 intgf_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 intgf_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;}

//.........这里部分代码省略.........            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;}

//.........这里部分代码省略.........	    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;

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) {//.........这里部分代码省略.........

/* * 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 * */intgf_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;//.........这里部分代码省略.........

/** * 初始化数据库 * @param[in] env 存储着应用程序运行环境的结构体 * @param[in] db_path 待初始化的数据库文件的名字 * @return sqlite3的错误代码 * @retval 0 成功 */intinit_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;}