int zkcfg__getValue(struct soap *soap, char *key, struct zkcfg__Ret *res)
{
struct dbhlpColumn desc[1] = {
{{ 0 }, DBT_STRING },
};
sqlite3 *db = db_get();
struct dbhlpColumn **all = 0;
int rows = 0, i, rc;
char *sql = (char*)alloca(1024);
snprintf(sql, 1024, "SELECT value FROM config WHERE key='%s'", key);
rc = db_exec_select2(db, sql, desc, 1, &all, &rows);
if (rc >= 0) {
if (rows == 0) {
res->value = 0;
res->result = -1;
}
else {
res->value = soap_strdup(soap, all[0][0].data.s);
res->result = 0;
}
db_free_select2(desc, 1, all, rows);
}
db_release(db);
return SOAP_OK;
}
int zkcfg__setValue(struct soap *soap, char *key, char *value, struct zkcfg__Ret *res)
{
char *sql = (char*)alloca(1024);
struct zkcfg__Ret ret;
sqlite3 *db = db_get();
zkcfg__getValue(soap, key, &ret);
if (ret.value) {
// ¸üÐÂ
snprintf(sql, 1024, "UPDATE config SET value='%s' WHERE key='%s'",
value, key);
res->result = 1;
}
else {
// н¨
snprintf(sql, 1024, "INSERT INTO config VALUES('%s', '%s')", key, value);
res->result = 0;
}
db_exec_sql(db, sql);
db_release(db);
return SOAP_OK;
}
int main(int argc, char* argv[])
{
void *db_test = db_init("test.db", DB_OMOD_WR);
CP_ID id_test = 123;
char test_str[] = "if you see this, then the db works.";
BOOL res;
if (NULL == db_test) {
fprintf(stderr, "cannot open test.db!\n");
return 0;
}
res = db_put(db_test, &id_test, CP_ID_SZ, test_str,
strlen(test_str) + 1);
if (0 == res)
fprintf(stderr, "db_put() fails.\n");
else
fprintf(stderr, "db_put() successful.\n");
if (db_test)
db_release(db_test);
return 0;
}
int zkcfg__getAllKeys(struct soap *soap, void *notused, struct zkcfg__Keys *keys)
{
struct dbhlpColumn desc[1] = {
{ { 0 }, DBT_STRING },
};
sqlite3 *db = db_get();
struct dbhlpColumn **all = 0;
int rows = 0, i;
db_exec_select2(db, "SELECT key FROM config", desc, 1, &all, &rows);
if (rows > 0) {
keys->__ptr = (char**)soap_malloc(soap, rows * sizeof(char*));
keys->__size = rows;
for (i = 0; i < rows; i++) {
keys->__ptr[i] = soap_strdup(soap, all[i][0].data.s);
}
}
else {
keys->__ptr = 0;
keys->__size = 0;
}
db_free_select2(desc, 1, all, rows);
db_release(db);
return SOAP_OK;
}
int zkcfg__delKey(struct soap *soap, char *key, struct zkcfg__Ret *res)
{
char *sql = (char*)alloca(1024);
sqlite3 *db = db_get();
snprintf(sql, 1024, "DELETE FROM config WHERE key='%s'", key);
db_exec_sql(db, sql);
res->result = 0;
db_release(db);
return SOAP_OK;
}
//简单测试
void test_single_dump(MEM_POOL* mem_pool)
{
system("rm -rf /tmp/binlog");
system("rm -rf /tmp/log");
system("rm -rf /tmp/storage");
db_initialize(mem_pool);
//构造数据
uint16 sid = 0;
uint32 docid = 0;
int32 ret;
uint16 field_count = 5;
enum field_types types[5] = {HI_TYPE_STRING,HI_TYPE_LONG,HI_TYPE_TINY,HI_TYPE_LONGLONG,HI_TYPE_DOUBLE};
//将第一个段填满
while(sid == 0)
{
ret = db_insert("hello", &sid, &docid,get_row_data(field_count,types,mem_pool), DOCID_BY_SELF, mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
}
sid = 0;
docid = 10;
//验证是否可查询
uint32 i;
for(i=0; i<docid; i++)
ASSERT_EQ(1,verify_row_data(db_data_query_row("hello",sid,i,mem_pool),field_count,types));
ret = db_unload_segment("hello",sid,mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
//验证是否可查询
for(i=0; i<docid; i++)
ASSERT_EQ(0,verify_row_data(db_data_query_row("hello",sid,i,mem_pool),field_count,types));
char segment_file_name[FILENAME_MAX_LENGTH];
memset(segment_file_name,0,sizeof(segment_file_name));
sprintf(segment_file_name,"%s/hello/hello_segment_000000_dump",get_db()->work_space);
ret = db_load_segment("hello",sid,segment_file_name,mem_pool);
//验证是否可查询
for(i=0; i<docid; i++)
ASSERT_EQ(1,verify_row_data(db_data_query_row("hello",sid,i,mem_pool),field_count,types));
db_release();
}
/*
* Close descriptor and remove it from index
*/
static void
server_close_fd(server_t *srv, int fd)
{
assert(FD_ISSET(fd, &srv->fdset));
assert(srv->fdidx[fd].valid);
db_unselect(srv, fd); /* release selected records */
db_release(srv, fd); /* expire owned records */
close(fd);
FD_CLR(fd, &srv->fdset);
srv->fdidx[fd].valid = false;
log_debug("client on fd#%d closed", fd);
if (fd == srv->fdmax) {
while (fd > 0 && !srv->fdidx[fd].valid)
fd--;
srv->fdmax = fd;
}
}
DocEngine::~DocEngine() {
db_release();
mem_pool_destroy(mem_);
mem_ = NULL;
}
int ag_db_release(unsigned dbh)
{ return db_release(h2p(dbh));
}
void data_insert_test(MEM_POOL* mem_pool)
{
system("rm -rf /tmp/binlog");
system("rm -rf /tmp/log");
system("rm -rf /tmp/storage");
db_initialize(mem_pool);
//构造数据
uint16 sid = 0;
uint32 docid = 0;
int32 ret;
uint16 field_count = 3;
enum field_types types[5] = {HI_TYPE_STRING,HI_TYPE_LONG,HI_TYPE_TINY,HI_TYPE_LONGLONG,HI_TYPE_DOUBLE};
ret = db_insert("hello", &sid, &docid,get_row_data(field_count,types,mem_pool), DOCID_BY_SELF, mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
struct row_data* query_row_ret = NULL;
struct low_data_struct* query_col_ret = NULL;
query_row_ret = db_data_query_row("hello",sid,docid,mem_pool);
ASSERT_EQ(1,verify_row_data(query_row_ret,field_count,types));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_STRING",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_STRING));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONG",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_LONG));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_TINY",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_TINY));
//不同的列数量
field_count = 5;
ret = db_insert("hello", &sid, &docid,get_row_data(field_count,types,mem_pool), DOCID_BY_SELF, mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
query_row_ret = db_data_query_row("hello",sid,docid,mem_pool);
ASSERT_EQ(1,verify_row_data(query_row_ret,field_count,types));
//表名不对
query_row_ret = db_data_query_row("world",sid,docid,mem_pool);
ASSERT_EQ(0,verify_row_data(query_row_ret,field_count,types));
//sid不对
query_row_ret = db_data_query_row("hello",sid+1,docid,mem_pool);
ASSERT_EQ(0,verify_row_data(query_row_ret,field_count,types));
//docid不对
query_row_ret = db_data_query_row("hello",sid,docid+1,mem_pool);
ASSERT_EQ(0,verify_row_data(query_row_ret,field_count,types));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_STRING",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_STRING));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONG",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_LONG));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONGLONG",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_TINY",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_TINY));
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_DOUBLE",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_DOUBLE));
//表名不对
query_col_ret = db_data_query_col("world",sid,"HI_TYPE_DOUBLE",docid,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_DOUBLE));
//sid不对
query_col_ret = db_data_query_col("hello",sid+1,"HI_TYPE_LONGLONG",docid,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
//docid不对
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONGLONG",docid+1,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
//列名不对
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LON",docid,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_LONG));
//列名不对
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONG",docid,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
//换一个表名
field_count = 3;
ret = db_insert("world", &sid, &docid,get_row_data(field_count,types,mem_pool), DOCID_BY_SELF, mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
ASSERT_EQ(sid,0);
ASSERT_EQ(docid,0);
query_row_ret = db_data_query_row("world",sid,docid,mem_pool);
ASSERT_EQ(1,verify_row_data(query_row_ret,field_count,types));
query_col_ret = db_data_query_col("world",sid,"HI_TYPE_STRING",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_STRING));
query_col_ret = db_data_query_col("world",sid,"HI_TYPE_LONG",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_LONG));
query_col_ret = db_data_query_col("world",sid,"HI_TYPE_TINY",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_TINY));
db_release();
}
void data_update_test(MEM_POOL* mem_pool)
{
system("rm -rf /tmp/binlog");
system("rm -rf /tmp/log");
system("rm -rf /tmp/storage");
db_initialize(mem_pool);
uint16 field_count = 3;
enum field_types types[5] = {HI_TYPE_STRING,HI_TYPE_LONG,HI_TYPE_TINY,HI_TYPE_LONGLONG,HI_TYPE_DOUBLE};
//构造数据
uint16 sid = 0;
uint32 docid = 0;
int32 ret;
ret = db_insert("hello", &sid, &docid,get_row_data(field_count,types,mem_pool), DOCID_BY_SELF, mem_pool);
struct low_data_struct* new_data = (struct low_data_struct*)mem_pool_malloc(mem_pool,sizeof(struct low_data_struct));
get_low_data(new_data,HI_TYPE_STRING,mem_pool);
struct low_data_struct* old_data = NULL;
memset(new_data->field_name,0,20);
strcpy(new_data->field_name,"HI_TYPE_LONG");
//更新已有的列
ret = db_update("hello",sid,docid,new_data,&old_data,mem_pool);
ASSERT_EQ(MILE_RETURN_SUCCESS,ret);
ASSERT_EQ(1,verify_low_data(old_data,HI_TYPE_LONG));
//查询一列
struct low_data_struct* query_col_ret = NULL;
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONG",docid,mem_pool);
ASSERT_STREQ(query_col_ret->field_name,"HI_TYPE_LONG");
query_col_ret->field_name = (char*)mem_pool_malloc(mem_pool,20);
strcpy(query_col_ret->field_name,"HI_TYPE_STRING");
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_STRING));
//更新不存在的列
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONGLONG",docid,mem_pool);
ASSERT_EQ(0,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
get_low_data(new_data,HI_TYPE_LONGLONG,mem_pool);
ret = db_update("hello",sid,docid,new_data,&old_data,mem_pool);
query_col_ret = db_data_query_col("hello",sid,"HI_TYPE_LONGLONG",docid,mem_pool);
ASSERT_EQ(1,verify_low_data(query_col_ret,HI_TYPE_LONGLONG));
//更新不存在的段
ret = db_update("hello",sid+1,docid,new_data,&old_data,mem_pool);
ASSERT_EQ(ERROR_SEGMENT_NOT_INIT,ret);
//更新不存在的docid
ret = db_update("hello",sid,docid+1,new_data,&old_data,mem_pool);
ASSERT_EQ(ERROR_EXCEED_CURRENT,ret);
ASSERT_EQ(0,verify_low_data(old_data,HI_TYPE_STRING));
//更新不存在的表名
ret = db_update("world",sid,docid,new_data,&old_data,mem_pool);
ASSERT_EQ(ret,ERROR_TABLE_NOT_EXIT);
db_release();
}
int main(int argc, char* argv[])
{
char *frml = NULL, *url = NULL;
struct list_it li_subpath;
void *db_formula;
void *db_webpage;
void *db_textree;
BOOL bad_parse = 0;
int subpath_err;
uint64_t records;
CP_ID id_new;
CP_NBRW n_brw;
int c;
/* log file initialize */
trace_init("index.log");
/* open key-value database files */
db_formula = db_init(CONFIG_FORMULA_DB_NAME, DB_OMOD_WR);
db_webpage = db_init(CONFIG_WEBPAGE_DB_NAME, DB_OMOD_WR);
db_textree = db_init(CONFIG_TEXTREE_DB_NAME, DB_OMOD_WR);
/* set parser_root to NULL initially */
/* or "go to exit" might free a random address. */
parser_root = NULL;
/* handle program arguments */
while ((c = getopt(argc, argv, "hf:u:")) != -1) {
switch (c) {
case 'h':
printf("DESCRIPTION:\n");
printf("index raw collection.\n");
printf("\n");
printf("SYNOPSIS:\n");
printf("%s -h | "
"-f <formula string> "
"-u <url> "
"\n",
argv[0]);
goto exit;
case 'f':
frml = cp_strdup(optarg);
break;
case 'u':
url = cp_strdup(optarg);
break;
default:
goto exit;
}
}
if (frml == NULL || url == NULL) {
printf("bad argument.\n");
goto exit;
}
printf("index... (`" C_RED "%s" C_RST "' @ %s)\n", frml, url);
/* before parsing, it is necessary to substitute possible
* carriage return(s) with space. Because a Mathjax content
* $ a\<^M>b $ will be interpreted as $ a\ b $, we infer a
* line-feed or carriage return should be replaced by a space.
*/
sub_cr_space(frml);
/* parse formula string */
if (!cp_parse(frml))
goto exit;
/* handle parser error */
if (parser_err_flg) {
parser_err_flg = 0;
printf("parser: %s\n", parser_err_msg);
bad_parse = 1;
goto exit;
}
/* check parser root */
if (NULL == parser_root) {
trace(INDEX, "NULL parser root.\n", NULL);
bad_parse = 1;
goto exit;
}
/* assign new formula ID in order */
records = (CP_ID)db_num_records(db_formula);
if (0 != records % 3)
trace(INDEX, "bad records number: %u.\n", records);
if (records / 3 + 1 >= MAX_CP_ID) {
trace(INDEX, "NO available ID to assign.\n", NULL);
goto exit;
} else {
id_new = records / 3 + 1;
printf("assign ID = %u\n", id_new);
}
/* prepare posting file */
n_brw = tex_tr_update(parser_root);
if (n_brw == 0) {
trace(INDEX, "tex_tr_update() fails.\n", NULL);
goto exit;
}
li_subpath = tex_tr_subpaths(parser_root, &subpath_err);
if (subpath_err) {
trace(INDEX, "tex_tr_subpaths() fails.\n", NULL);
subpaths_free(&li_subpath);
goto exit;
}
/* write posting file */
posting_write(&li_subpath, id_new);
subpaths_free(&li_subpath);
/* index formula */
if (db_formula) {
if (!index_formula(db_formula, id_new, frml, url, n_brw))
goto exit;
} else {
trace(INDEX, "fail to open %s for writing.\n",
CONFIG_FORMULA_DB_NAME);
goto exit;
}
/* index URL */
if (db_webpage) {
index_webpage(db_webpage, url, id_new);
}
/* index tree shape */
if (db_textree) {
index_textree(db_textree, id_new);
}
exit:
/* releases textree */
if (parser_root) {
tex_tr_release(parser_root);
parser_root = NULL;
}
/* free program argument string */
if (frml)
cp_free(frml);
if (url)
cp_free(url);
/* database release */
if (db_formula)
db_release(db_formula);
if (db_webpage)
db_release(db_webpage);
if (db_textree)
db_release(db_textree);
/* unfree trace */
if (0 != trace_unfree()) {
for (c = 0; c < argc; c ++) {
trace(UNFREE, "%s \n", argv[c]);
}
trace(UNFREE, "\n", NULL);
}
/* log release */
trace_uninit();
return bad_parse;
}
