/* main routine */ int main (int argc, char **argv) { KCDB *db; char *vbuf; size_t vsiz; /* Variable for time mesure */ clock_t start, finish; int duration; start = clock (); db = kcdbnew (); /* open the database */ if (!kcdbopen (db, argv[1], KCOWRITER | KCOCREATE)) { fprintf (stderr, "open error: %s\n", kcecodename (kcdbecode (db))); return 100; } vbuf = kcdbget (db, argv[2], strlen (argv[2]), &vsiz); if (vbuf) { printf ("%s\n", vbuf); kcfree (vbuf); } /* delete the database object */ kcdbdel (db); finish = clock (); duration = (finish - start); printf ("\nduration : %iclock (%i clock/s) \n", duration, CLOCKS_PER_SEC); return 0; }
/* get_genid * Looks up the host's genid in the host->genid database */ static int get_genid(char *host) { KCDB *db; char *vbuf; size_t vsiz; int answer = 0; int host_size; /* create the database object */ db = kcdbnew(); /* open the database */ if (!kcdbopen(db, genid_kyoto_db, KCOREADER | KCONOLOCK)) { TSDebug(PLUGIN_NAME, "could not open the genid database %s", genid_kyoto_db); TSError("[%s] could not open the genid database %s: %s", PLUGIN_NAME, genid_kyoto_db, strerror(errno)); return 0; } vbuf = kcdbget(db, host, strlen(host), &vsiz); if (vbuf) { TSDebug(PLUGIN_NAME, "kcdbget(%s) = %s", host, vbuf); answer = (int)strtol(vbuf, NULL, 10); kcfree(vbuf); } else { host_size = strlen(host); TSDebug(PLUGIN_NAME, "kcdbget(%s) - no record found, len(%d)", host, host_size); answer = 0; } kcdbclose(db); return answer; }
/* main routine */ int main (int argc, char **argv) { KCDB *db; char *vbuf; size_t vsiz; int retour = 1; db = kcdbnew (); if (argc != 3) { fprintf (stderr, "Usage getVal DB_FILE KEY\n"); return 100; } /* open the database */ if (!kcdbopen (db, argv[1], KCOWRITER | KCOCREATE)) { fprintf (stderr, "open error: %s\n", kcecodename (kcdbecode (db))); return 100; } vbuf = kcdbget (db, argv[2], strlen (argv[2]), &vsiz); if (vbuf) { printf ("%s\n", vbuf); kcfree (vbuf); retour = 0; } /* delete the database object */ kcdbdel (db); return retour; }
char * pwd_save(KCDB * db, const char * origin_url) { char * pk, * epk, * url; char hash[41]; size_t vsiz; if(!kcdbopen(db, db_file, KCOWRITER|KCOCREATE)) { printf("Status: 500 INTERNAL ERROR\r\n\r\nkcdb open error: %s\n", kcecodename(kcdbecode(db))); return NULL; } if(strstr(origin_url, "http://") == NULL && strstr(origin_url, "https://") == NULL) { url = malloc(strlen(origin_url) + 8); strcpy(url, "http://"); strcat(url, origin_url); } else { url = malloc(strlen(origin_url) + 1); strcpy(url, origin_url); } // calc url hash and check if exists sha1(hash, url); epk = kcdbget(db, hash, strlen(hash), &vsiz); if(epk) { pk = malloc(strlen(epk) + 1); strcpy(pk, epk); kcfree(epk); free(url); kcdbclose(db); return pk; } pk = pwd_get_pk(db); if(pk == NULL) { free(url); kcdbclose(db); return NULL; } //TODO save pk => url && hash => pk if(!kcdbset(db, pk, strlen(pk), url, strlen(url))) { free(pk); pk = NULL; } if(!kcdbset(db, hash, strlen(hash), pk, strlen(pk))) { free(pk); pk = NULL; } free(url); kcdbclose(db); return pk; }
char * pwd_get_pk(KCDB * db) { char * pk, * result; size_t vsiz; int i; const char * map = ".adgjmptw"; pk = kcdbget(db, "master", 6, &vsiz); if(pk) { result = malloc(vsiz + 2); strcpy(result, pk); kcfree(pk); pk = NULL; } else { result = malloc(3); strcpy(result, "0"); } // increase pk vsiz = strlen(result); for(i = 0; ; i++) { if(i == vsiz) { result[i] = i == 0 ? '1' : (result[i - 1] == '1' ? '2' : '1'); result[i + 1] = '\0'; break; } result[i]++; if(result[i] >= '9') result[i] = i > 0 ? (result[i - 1] == '0' ? '1' : '0') : '1'; else if(i > 0 && result[i - 1] == result[i]) i--; else if(i < vsiz && result[i + 1] == result[i]) i--; else break; } if(!kcdbset(db, "master", 6, result, strlen(result))) { free(result); return NULL; } // mapping result vsiz = strlen(result); for(i = 0 ; i < vsiz; i++) { result[i] = map[result[i]&0x0f]; } return result; }
/* print error message of database */ static void dberrprint(KCDB* db, int32_t line, const char* func) { char* path; const char* emsg; int32_t ecode; path = kcdbpath(db); ecode = kcdbecode(db); emsg = kcdbemsg(db); oprintf("%s: %d: %s: %s: %d: %s: %s\n", g_progname, line, func, path ? path : "-", ecode, kcecodename(ecode), emsg); kcfree(path); }
static void fetch_request_data_finalize( nxweb_http_server_connection *conn, nxweb_http_request *req, nxweb_http_response *resp, nxe_data data) { KC_DATA * d = data.ptr; if (d->data_ptr){ kcfree(d->data_ptr); d->data_ptr = NULL; } }
void get_master_pgn(struct evhttp_request *req, void *context) { if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) { evhttp_send_error(req, HTTP_BADMETHOD, "Method Not Allowed"); return; } const struct evhttp_uri *uri = evhttp_request_get_evhttp_uri(req); if (!uri) { puts("evhttp_request_get_evhttp_uri failed"); return; } const char *path = evhttp_uri_get_path(uri); if (!path) { puts("evhttp_uri_get_path failed"); return; } char game_id[9] = {}; int end; if (1 != sscanf(path, "/master/pgn/%8s%n", game_id, &end) || strlen(game_id) != 8 || strlen(path) != end) { evhttp_send_error(req, HTTP_NOTFOUND, "Not Found"); return; } size_t pgn_size; char *pgn = kcdbget(master_pgn_db, game_id, 8, &pgn_size); if (!pgn) { evhttp_send_error(req, HTTP_NOTFOUND, "Master PGN Not Found"); return; } struct evbuffer *res = evbuffer_new(); if (!res) { puts("could not allocate response buffer"); abort(); } struct evkeyvalq *headers = evhttp_request_get_output_headers(req); evhttp_add_header(headers, "Content-Type", "application/vnd.chess-pgn; charset=utf-8"); evbuffer_add(res, pgn, pgn_size); kcfree(pgn); evhttp_send_reply(req, HTTP_OK, "OK", res); evbuffer_free(res); }
int merge_using_kv_map(Cloudflare__ZoneTimeBucket *msg_old, Cloudflare__ZoneTimeBucket *msg_new, KCDB* db) { unsigned int i; int num_new = 0; if (msg_new->kv_map_file) { // Open a db for the new map file. KCCUR* cur; KCDB* new_db; new_db = kcdbnew(); /* open the database */ if (!kcdbopen(new_db, msg_new->kv_map_file, KCOWRITER)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("open error: %s", kcecodename(kcdbecode(new_db))))); } cur = kcdbcursor(new_db); kccurjump(cur); char *kv_kbuf; size_t kv_ksiz; while ((kv_kbuf = kccurgetkey(cur, &kv_ksiz, 1)) != NULL) { int64_t value = kcdbincrint (new_db, kv_kbuf, kv_ksiz, 0); #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Saving: %s -- %ld", kv_kbuf, value))); #endif kcdbincrint (db, kv_kbuf, kv_ksiz, value); num_new++; kcfree(kv_kbuf); } kccurdel(cur); kcdbclose(new_db); } else { for (i = 0; i < msg_new->n_map_entry; i++) { kcdbincrint (db, msg_new->map_entry[i]->key, strlen(msg_new->map_entry[i]->key), msg_new->map_entry[i]->value); num_new++; } } return num_new; }
extern CAMLprim value kc_status(value caml_db) { CAMLparam1(caml_db); CAMLlocal1(val); KCDB* db = get_db(caml_db); const char* status = kcdbstatus(db); if (! status) { const char *error = kcdbemsg(db); RAISE(error); } val = caml_copy_string(status); kcfree((void*) status); CAMLreturn(val); }
extern CAMLprim value kc_path(value caml_db) { CAMLparam1(caml_db); CAMLlocal1(val); KCDB* db = get_db(caml_db); const char* path = kcdbpath(db); if (! path) { const char *error = kcdbemsg(db); RAISE(error); } val = caml_copy_string(path); kcfree((void*) path); CAMLreturn(val); }
/////////////// status ///////////////////// static nxweb_result status_on_request(nxweb_http_server_connection* conn, nxweb_http_request* req, nxweb_http_response* resp) { nxweb_set_response_content_type(resp, "text/plain"); char *status = kcdbstatus( g_kcdb ); size_t len = 2*strlen(status); char *buf = malloc(len); memset(buf, 0, len); int i=0, j=0; for (i=0; i<strlen(status); i++) { if (status[i] == '\t') { strcat(buf, ": "); j+=2; } else { buf[j] = status[i]; j++; } } nxweb_response_printf( resp, "%s\n", buf ); kcfree( status ); status = NULL; free(buf); return NXWEB_OK; }
/* print members of database */ static void dbmetaprint(KCDB* db, int32_t verbose) { char* status, *rp; if (verbose) { status = kcdbstatus(db); if (status) { rp = status; while (*rp != '\0') { if (*rp == '\t') { printf(": "); } else { putchar(*rp); } rp++; } kcfree(status); } } else { oprintf("count: %ld\n", (long)kcdbcount(db)); oprintf("size: %ld\n", (long)kcdbsize(db)); } }
static nxweb_result list_on_request(nxweb_http_server_connection* conn, nxweb_http_request* req, nxweb_http_response* resp) { nxweb_set_response_content_type(resp, "text/plain"); const char *name_space = nx_simple_map_get_nocase( req->parameters, "namespace" ); const char *prefix = nx_simple_map_get_nocase( req->parameters, "prefix" ); char kc_prefix[1024] = {0}; if( name_space ){ strncpy( kc_prefix, name_space, sizeof( kc_prefix )-3 ); strcat( kc_prefix, ":/" ); if (prefix){ strncat(kc_prefix, prefix, sizeof(kc_prefix)-strlen(kc_prefix)-1); } } printf("list prefix:%s\n", kc_prefix ); char *fnames[MAX_COUNT_PER_LIST] = {0}; int cnt = kcdbmatchprefix (g_kcdb, kc_prefix, fnames, MAX_COUNT_PER_LIST ); int i = 0; while( i< cnt ){ nxweb_response_printf( resp, "%s\n", fnames[i] ); kcfree( fnames[i] ); fnames[i] = NULL; i++; } return NXWEB_OK; }
char * pwd_load(KCDB * db, const char * key) { char * url, * value; size_t vsiz; if(!kcdbopen(db, db_file, KCOREADER)) { printf("Status: 500 INTERNAL ERROR\r\n\r\nkcdb open error: %s\n", kcecodename(kcdbecode(db))); return NULL; } value = kcdbget(db, key, strlen(key), &vsiz); if(!value) { kcdbclose(db); return NULL; } url = malloc(strlen(value) + 1); strcpy(url, value); kcfree(value); kcdbclose(db); return url; }
Datum kc_delete(PG_FUNCTION_ARGS) { char *map_name = text_to_cstring(PG_GETARG_TEXT_PP(0)); char *start_time = text_to_cstring(PG_GETARG_TEXT_PP(1)); ArrayType *rids = PG_GETARG_ARRAYTYPE_P(2); int i; Datum *rid_datums; bool *rid_nulls; int rid_count; char *next_rid; KCDB *main_db; char *vbuf; size_t vsiz; int64_t num_keys_to_run; int64_t num_keys_deleted; char **keys_to_use; Cloudflare__ZoneTimeBucket *msg_new; // Open our DB. main_db = kcdbnew(); if (!open_db (main_db, map_name, start_time)) { PG_RETURN_INT64(0); } kcdbbegintran (main_db, 0); // Now run over the array. deconstruct_array(rids, TEXTOID, -1, false, 'i', &rid_datums, &rid_nulls, &rid_count); if (ARR_HASNULL(rids)) { ereport(ERROR, (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), errmsg("cannot work with arrays containing NULLs"))); } keys_to_use = (char **)palloc(KC_MAX_ENTRIES_PER_RID * sizeof(char)); num_keys_deleted = 0; char prefixes_to_use[rid_count][KC_MAX_RID]; for (i = 0; i < rid_count; i++) { next_rid = TextDatumGetCString(rid_datums[i]); snprintf(prefixes_to_use[i], KC_MAX_RID, "%s%s", next_rid, CF_LABEL_SEP); num_keys_to_run = kcdbmatchprefix (main_db, prefixes_to_use[i], keys_to_use, KC_MAX_ENTRIES_PER_RID); if (num_keys_to_run != -1) { num_keys_deleted += num_keys_to_run; int next_key; for (next_key=0; next_key < num_keys_to_run; next_key++) { vbuf = kcdbget(main_db, keys_to_use[next_key], strlen(keys_to_use[next_key]), &vsiz); if (vbuf) { msg_new = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)vbuf); if (msg_new == NULL) { // Something failed ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("error unpacking incoming message"))); } else { if (msg_new->kv_map_file) { unlink(msg_new->kv_map_file); } kcdbremove (main_db, keys_to_use[next_key], strlen(keys_to_use[next_key])); } cloudflare__zone_time_bucket__free_unpacked(msg_new, NULL); kcfree(vbuf); kcfree(keys_to_use[next_key]); } else { ereport(NOTICE, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("get error on %s -- %s", keys_to_use[next_key], kcecodename(kcdbecode(main_db))))); } } } else { ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("prefix error on %s -- %s", prefixes_to_use[i], kcecodename(kcdbecode(main_db))))); } } pfree(keys_to_use); // Done! kcdbendtran (main_db, 1); if (!kcdbclose(main_db)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(main_db))))); } PG_RETURN_INT64(num_keys_deleted); }
Datum kc_shrink(PG_FUNCTION_ARGS) { char *map_name = text_to_cstring(PG_GETARG_TEXT_PP(0)); char *start_time = text_to_cstring(PG_GETARG_TEXT_PP(1)); // Start time + uid!!! char *new_rid = text_to_cstring(PG_GETARG_TEXT_PP(2)); ArrayType *old_rids = PG_GETARG_ARRAYTYPE_P(3); char *classification = text_to_cstring(PG_GETARG_TEXT_PP(4)); char *doctype = text_to_cstring(PG_GETARG_TEXT_PP(5)); char *pop = text_to_cstring(PG_GETARG_TEXT_PP(6)); char *psource = text_to_cstring(PG_GETARG_TEXT_PP(7)); text *tout; int i,j; Datum *rid_datums; bool *rid_nulls; int rid_count; char *next_rid; KCDB *main_db; char *vbuf; size_t vsiz; // Open our DB. main_db = kcdbnew(); if (!open_db (main_db, map_name, start_time)) { tout = cstring_to_text(new_rid); PG_RETURN_TEXT_P(tout); } kcdbbegintran (main_db, 0); // First fill in what we can from the input. Cloudflare__ZoneTimeBucket msg = CLOUDFLARE__ZONE_TIME_BUCKET__INIT; msg.map_name = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.doctype = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.classification = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.pop = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.psource = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.result_id = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.db_key = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.db_path = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); msg.map_entry = palloc(MAX_KEYS_BEFORE_KV_MAP * sizeof(Cloudflare__ZoneTimeBucket__Counter)); msg.n_map_entry = 0; strncpy(msg.map_name, map_name, MAX_KC_ROW_ENTRY); strncpy(msg.classification, classification, MAX_KC_ROW_ENTRY); strncpy(msg.doctype, doctype, MAX_KC_ROW_ENTRY); strncpy(msg.pop, pop, MAX_KC_ROW_ENTRY); strncpy(msg.psource, psource, MAX_KC_ROW_ENTRY); strncpy(msg.result_id, new_rid, KC_MAX_RID); snprintf(msg.db_path, MAX_KC_ROW_ENTRY, "%s%s%s", map_name, "/", start_time); snprintf(msg.db_key, KC_MAX_RID, "%s%s%s%s%s%s%s%s%s%s%s", new_rid, CF_LABEL_SEP, classification, CF_LABEL_SEP, doctype, CF_LABEL_SEP, pop, CF_LABEL_SEP, psource, CF_LABEL_SEP, map_name); // Now run over the array. deconstruct_array(old_rids, TEXTOID, -1, false, 'i', &rid_datums, &rid_nulls, &rid_count); if (ARR_HASNULL(old_rids)) { ereport(ERROR, (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), errmsg("cannot work with arrays containing NULLs"))); } int num_new_keys = 0; int num_entries = 0; char keys_to_use[rid_count][KC_MAX_RID]; Cloudflare__ZoneTimeBucket *msg_new[rid_count]; j=0; for (i = 0; i < rid_count; i++) { next_rid = TextDatumGetCString(rid_datums[i]); snprintf(keys_to_use[i], KC_MAX_RID, "%s%s%s%s%s%s%s%s%s%s%s", next_rid, CF_LABEL_SEP, classification, CF_LABEL_SEP, doctype, CF_LABEL_SEP, pop, CF_LABEL_SEP, psource, CF_LABEL_SEP, map_name); vbuf = kcdbget(main_db, keys_to_use[i], strlen(keys_to_use[i]), &vsiz); if (vbuf) { msg_new[j] = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)vbuf); if (msg_new[j] == NULL) { // Something failed ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("error unpacking incoming message"))); } else { if (msg_new[j]->kv_map_file) { num_entries = MAX_KEYS_BEFORE_KV_MAP + 1; } else { num_entries += msg_new[j]->n_map_entry; } j++; } kcfree(vbuf); } else { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("get error on %s -- %s", keys_to_use[i], kcecodename(kcdbecode(main_db))))); #endif } } // Now merge the buffers. KCDB* msg_db = NULL; if (num_entries > MAX_KEYS_BEFORE_KV_MAP) { msg_db = kcdbnew(); set_kv_path(&msg, map_name, start_time, msg_db); } for (i = 0; i < j; i++) { if (num_entries > MAX_KEYS_BEFORE_KV_MAP) { num_new_keys += merge_using_kv_map(&msg, msg_new[i], msg_db); } else { num_new_keys += merge_messages_basic(&msg, msg_new[i]); } cloudflare__zone_time_bucket__free_unpacked(msg_new[i], NULL); } if (num_entries > MAX_KEYS_BEFORE_KV_MAP) { // Close the db. kcdbendtran (msg_db, 1); kcdbclose(msg_db); } #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("saving: num map entries: %zu -- writting with %d keys", msg.n_map_entry, num_new_keys))); #endif // Save the updated buffer. if (num_new_keys > 0) { unsigned int len; void *buf; len = cloudflare__zone_time_bucket__get_packed_size (&msg); buf = palloc (len); cloudflare__zone_time_bucket__pack (&msg, buf); if(!kcdbset(main_db, msg.db_key, strlen(msg.db_key), buf, len)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("set error: %s\n", kcecodename(kcdbecode(main_db))))); } pfree (buf); } // Done! kcdbendtran (main_db, 1); if (!kcdbclose(main_db)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(main_db))))); } tout = cstring_to_text(new_rid); PG_RETURN_TEXT_P(tout); }
Datum kc_expand(PG_FUNCTION_ARGS) { KC_ENTRY *search; FuncCallContext *funcctx; int call_cntr; char *kbuf; size_t ksiz, vsiz; const char *cvbuf; char *kv_kbuf = NULL; size_t kv_ksiz; int done; /* stuff done only on the first call of the function */ if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; /* create a function context for cross-call persistence */ funcctx = SRF_FIRSTCALL_INIT(); /* switch to memory context appropriate for multiple function calls */ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); // Make sure that there are enough args. if (PG_NARGS() < MIN_ARGS) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION), errmsg("Must run expand with at least %d args!", MIN_ARGS))); } /* Make the kcdb here. */ search = (KC_ENTRY *)palloc(sizeof(KC_ENTRY)); search->db = kcdbnew(); if (open_db (search->db, text_to_cstring(PG_GETARG_TEXT_PP(0)), text_to_cstring(PG_GETARG_TEXT_PP(1)))) { // Set the key to jump into: // Call with -- map_name, result_id, class, doctype, pop, psource // Here, map_name describes a db to open. // Otherwise, result_id:class:doctype:pop:psource (search->jump_key) = (char *) palloc(MAX_JUMP_KEY_LEN * sizeof(char)); int index_point; search->jump_key = text_to_cstring(PG_GETARG_TEXT_PP(2)); int size_left = MAX_JUMP_KEY_LEN; for (index_point = START_VARIABLE_INDEX; index_point < END_VARIABLE_INDEX; index_point++) { if (PG_NARGS() > index_point) { char *next_idx = text_to_cstring(PG_GETARG_TEXT_PP(index_point)); if (next_idx != NULL) { size_left = size_left - (2 + strlen(next_idx)); strncat (search->jump_key, CF_LABEL_SEP, size_left); strncat (search->jump_key, next_idx, size_left); } } } #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Setting jump buffer -- [%s]", search->jump_key))); #endif // Create a cursor, and set it to the base point looking for entries. search->cur = kcdbcursor(search->db); kccurjumpkey(search->cur, search->jump_key, MAX_JUMP_KEY_LEN); } else { search->db = NULL; } search->next_map = 0; search->msg = NULL; // Save the search struct for the subsequent calls. funcctx->user_fctx = search; MemoryContextSwitchTo(oldcontext); } /* stuff done on every call of the function */ funcctx = SRF_PERCALL_SETUP(); call_cntr = funcctx->call_cntr; search = (KC_ENTRY *) funcctx->user_fctx; // If no current msg, try to get the next one. done = 1; #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("beginning run"))); #endif if (search->msg) { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Incrementing next from map %d -- %zu", search->next_map, search->msg->n_map_entry))); #endif // Case if we are using the external cursor running over kv map. // Ready the next if (search->msg->kv_map_file) { if ((kv_kbuf = kccurgetkey(search->kv_cur, &kv_ksiz, 1)) == NULL) { done = 1; kccurdel(search->kv_cur); kcdbendtran (search->kv_db, 1); if (!kcdbclose(search->kv_db)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->kv_db))))); } // Also need to free this. cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL); search->msg = NULL; } else { done = 0; } } else { if (search->next_map >= search->msg->n_map_entry) { // Done with this msg -- move on to the next one. cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL); search->msg = NULL; } else { done = 0; } } } if (search->db && !search->msg) { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Getting new buf -- %s", search->jump_key))); #endif if ((kbuf = kccurget(search->cur, &ksiz, &cvbuf, &vsiz, 1)) != NULL) { // Pull up the PB and expand it. search->msg = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)cvbuf); if (search->msg == NULL) { // Something failed ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("error unpacking incoming message"))); done = 1; } else { // Does the buffer match the searched for string? // @TODO -- bound this? if (strstr(search->msg->db_key, search->jump_key)) { done = 0; search->next_map = 0; // And load the kvkc if needed. if (search->msg->kv_map_file) { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Switching to kvs %s", search->msg->kv_map_file))); #endif search->kv_db = kcdbnew(); if (!kcdbopen(search->kv_db, search->msg->kv_map_file, KCOWRITER)) { #ifdef CF_NO_DB_IS_ERR ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.", search->msg->kv_map_file, kcecodename(kcdbecode(search->kv_db))))); #endif #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.", search->msg->kv_map_file, kcecodename(kcdbecode(search->kv_db))))); #endif done = 1; } else { kcdbbegintran (search->kv_db, 0); search->kv_cur = kcdbcursor(search->kv_db); kccurjump(search->kv_cur); if ((kv_kbuf = kccurgetkey(search->kv_cur, &kv_ksiz, 1)) == NULL) { done = 1; kccurdel(search->kv_cur); kcdbendtran (search->kv_db, 1); if (!kcdbclose(search->kv_db)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->kv_db))))); } } else { done = 0; } } } } else { done = 1; } } kcfree(kbuf); } else { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("no msg to find"))); #endif done = 1; } } #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Done? %d -- next buf -- %d", done, search->next_map))); #endif // Take the next itteration over the cursor. If the next is NULL or else not matching the resultid passed in // End. Otherwise, parse the value, populating the next row of the returning tuple. if (!done) { KC_ROW *out; Datum result; size_t size = sizeof(KC_ROW); out = (KC_ROW *)palloc(size); memset(out, '0', size); SET_VARSIZE(out, size); out->classification = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); out->doctype = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); out->pop = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); out->psource = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); out->key = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char)); strncpy(out->classification, search->msg->classification, MAX_KC_ROW_ENTRY); strncpy(out->doctype, search->msg->doctype, MAX_KC_ROW_ENTRY); strncpy(out->pop, search->msg->pop, MAX_KC_ROW_ENTRY); strncpy(out->psource, search->msg->psource, MAX_KC_ROW_ENTRY); if (search->msg->kv_map_file) { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("getting val from -- [%s]", search->msg->kv_map_file))); #endif snprintf(out->key, MAX_KC_ROW_ENTRY, "%s", kv_kbuf); out->value = kcdbincrint (search->kv_db, kv_kbuf, kv_ksiz, 0); if (out->value == INT64_MIN) { ereport(NOTICE, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("ERROR Getting val from key -- [%s], %s", kv_kbuf, kcecodename(kcdbecode(search->kv_db))))); } kcfree(kv_kbuf); } else { #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Loading %s %ld", search->msg->map_entry[search->next_map]->key, search->msg->map_entry[search->next_map]->value))); #endif snprintf(out->key, MAX_KC_ROW_ENTRY, "%s", search->msg->map_entry[search->next_map]->key); out->value = search->msg->map_entry[search->next_map]->value; } result = PointerGetDatum(out); /* clean up (this is not really necessary) */ pfree(out->classification); pfree(out->doctype); pfree(out->pop); pfree(out->psource); pfree(out->key); pfree(out); // Remember that we are going to the next step. search->next_map++; SRF_RETURN_NEXT(funcctx, result); } else { /* do when there is no more left */ if (search->db) { kccurdel(search->cur); if (!kcdbclose(search->db)) { ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->db))))); } if (search->msg != NULL) { cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL); } pfree(search->jump_key); } pfree(search); #ifdef CF_DUBUG ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Done with run"))); #endif // Don't delete db, this leads to segfaults. SRF_RETURN_DONE(funcctx); } }
/* perform order command */ static int32_t procorder(const char* path, int64_t rnum, int32_t rnd, int32_t etc, int32_t tran, int32_t oflags) { KCDB* db; KCCUR* cur, *paracur; int32_t err; char kbuf[RECBUFSIZ], *vbuf, wbuf[RECBUFSIZ], *corepath, *copypath, *snappath; size_t ksiz, vsiz, psiz; int32_t wsiz; int64_t i, cnt; double stime, etime; VISARG visarg; oprintf("<In-order Test>\n path=%s rnum=%ld rnd=%d etc=%d tran=%d oflags=%d\n\n", path, (long)rnum, rnd, etc, tran, oflags); err = FALSE; db = kcdbnew(); oprintf("opening the database:\n"); stime = kctime(); if (!kcdbopen(db, path, KCOWRITER | KCOCREATE | KCOTRUNCATE | oflags)) { dberrprint(db, __LINE__, "kcdbopen"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); oprintf("setting records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcdbset(db, kbuf, ksiz, kbuf, ksiz)) { dberrprint(db, __LINE__, "kcdbset"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); if (etc) { oprintf("adding records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcdbadd(db, kbuf, ksiz, kbuf, ksiz) && kcdbecode(db) != KCEDUPREC) { dberrprint(db, __LINE__, "kcdbadd"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { oprintf("appending records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcdbappend(db, kbuf, ksiz, kbuf, ksiz)) { dberrprint(db, __LINE__, "kcdbadd"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } oprintf("getting records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); vbuf = kcdbget(db, kbuf, ksiz, &vsiz); if (vbuf) { if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) { dberrprint(db, __LINE__, "kcdbget"); err = TRUE; } kcfree(vbuf); } else if (!rnd || kcdbecode(db) != KCENOREC) { dberrprint(db, __LINE__, "kcdbget"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); if (etc) { oprintf("getting records with a buffer:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); wsiz = kcdbgetbuf(db, kbuf, ksiz, wbuf, sizeof(wbuf)); if (wsiz >= 0) { if (wsiz < (int32_t)ksiz || memcmp(wbuf, kbuf, ksiz)) { dberrprint(db, __LINE__, "kcdbgetbuf"); err = TRUE; } } else if (!rnd || kcdbecode(db) != KCENOREC) { dberrprint(db, __LINE__, "kcdbgetbuf"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { oprintf("traversing the database by the inner iterator:\n"); stime = kctime(); cnt = kcdbcount(db); visarg.rnum = rnum; visarg.rnd = rnd; visarg.cnt = 0; memset(visarg.rbuf, '+', sizeof(visarg.rbuf)); if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } if (!kcdbiterate(db, visitfull, &visarg, TRUE)) { dberrprint(db, __LINE__, "kcdbiterate"); err = TRUE; } if (rnd) oprintf(" (end)\n"); if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (visarg.cnt != cnt) { dberrprint(db, __LINE__, "kcdbiterate"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { oprintf("traversing the database by the outer cursor:\n"); stime = kctime(); cnt = kcdbcount(db); visarg.rnum = rnum; visarg.rnd = rnd; visarg.cnt = 0; if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } cur = kcdbcursor(db); if (!kccurjump(cur) && kccurecode(cur) != KCENOREC) { dberrprint(db, __LINE__, "kccurjump"); err = TRUE; } paracur = kcdbcursor(db); while (!err && kccuraccept(cur, &visitfull, &visarg, TRUE, !rnd)) { if (rnd) { ksiz = sprintf(kbuf, "%08ld", (long)myrand(rnum)); switch (myrand(3)) { case 0: { if (!kcdbremove(db, kbuf, ksiz) && kcdbecode(db) != KCENOREC) { dberrprint(db, __LINE__, "kcdbremove"); err = TRUE; } break; } case 1: { if (!kccurjumpkey(paracur, kbuf, ksiz) && kccurecode(paracur) != KCENOREC) { dberrprint(db, __LINE__, "kccurjump"); err = TRUE; } break; } default: { if (!kccurstep(cur) && kccurecode(cur) != KCENOREC) { dberrprint(db, __LINE__, "kccurstep"); err = TRUE; } break; } } } } oprintf(" (end)\n"); kccurdel(paracur); kccurdel(cur); if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (!rnd && visarg.cnt != cnt) { dberrprint(db, __LINE__, "kccuraccept"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { oprintf("synchronizing the database:\n"); stime = kctime(); if (!kcdbsync(db, FALSE, NULL, NULL)) { dberrprint(db, __LINE__, "kcdbsync"); err = TRUE; } if (!kcdboccupy(db, FALSE, NULL, NULL)) { dberrprint(db, __LINE__, "kcdboccupy"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { corepath = kcdbpath(db); psiz = strlen(corepath); if (strstr(corepath, ".kch") || strstr(corepath, ".kct")) { copypath = kcmalloc(psiz + 256); sprintf(copypath, "%s.tmp", corepath); snappath = kcmalloc(psiz + 256); sprintf(snappath, "%s.kcss", corepath); } else { copypath = kcmalloc(256); sprintf(copypath, "kclangctest.tmp"); snappath = kcmalloc(256); sprintf(snappath, "kclangctest.kcss"); } oprintf("copying the database file:\n"); stime = kctime(); if (!kcdbcopy(db, copypath)) { dberrprint(db, __LINE__, "kcdbcopy"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); remove(copypath); oprintf("dumping records into snapshot:\n"); stime = kctime(); if (!kcdbdumpsnap(db, snappath)) { dberrprint(db, __LINE__, "kcdbdumpsnap"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); oprintf("loading records into snapshot:\n"); stime = kctime(); cnt = kcdbcount(db); if (rnd && myrand(2) == 0 && !kcdbclear(db)) { dberrprint(db, __LINE__, "kcdbclear"); err = TRUE; } if (!kcdbloadsnap(db, snappath) || kcdbcount(db) != cnt) { dberrprint(db, __LINE__, "kcdbloadsnap"); err = TRUE; } etime = kctime(); dbmetaprint(db, FALSE); oprintf("time: %.3f\n", etime - stime); remove(snappath); kcfree(copypath); kcfree(snappath); kcfree(corepath); } oprintf("removing records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { if (tran && !kcdbbegintran(db, FALSE)) { dberrprint(db, __LINE__, "kcdbbegintran"); err = TRUE; } ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcdbremove(db, kbuf, ksiz) && ((!rnd && !etc) || kcdbecode(db) != KCENOREC)) { dberrprint(db, __LINE__, "kcdbremove"); err = TRUE; } if (tran && !kcdbendtran(db, TRUE)) { dberrprint(db, __LINE__, "kcdbendtran"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); dbmetaprint(db, TRUE); oprintf("time: %.3f\n", etime - stime); oprintf("closing the database:\n"); stime = kctime(); if (!kcdbclose(db)) { dberrprint(db, __LINE__, "kcdbclose"); err = TRUE; } etime = kctime(); oprintf("time: %.3f\n", etime - stime); kcdbdel(db); oprintf("%s\n\n", err ? "error" : "ok"); return err ? 1 : 0; }
/* perform index command */ static int32_t procindex(const char* path, int64_t rnum, int32_t rnd, int32_t etc, int32_t oflags) { KCIDX* idx; int32_t err; char kbuf[RECBUFSIZ], *vbuf; size_t ksiz, vsiz; int64_t i; double stime, etime; oprintf("<Index Database Test>\n path=%s rnum=%ld rnd=%d etc=%d oflags=%d\n\n", path, (long)rnum, rnd, etc, oflags); err = FALSE; idx = kcidxnew(); oprintf("opening the database:\n"); stime = kctime(); if (!kcidxopen(idx, path, KCOWRITER | KCOCREATE | KCOTRUNCATE | oflags)) { idxerrprint(idx, __LINE__, "kcidxopen"); err = TRUE; } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); oprintf("setting records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcidxset(idx, kbuf, ksiz, kbuf, ksiz)) { idxerrprint(idx, __LINE__, "kcidxset"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); if (etc) { oprintf("adding records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcidxadd(idx, kbuf, ksiz, kbuf, ksiz) && kcidxecode(idx) != KCEDUPREC) { idxerrprint(idx, __LINE__, "kcidxadd"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); } if (etc) { oprintf("appending records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcidxappend(idx, kbuf, ksiz, kbuf, ksiz)) { idxerrprint(idx, __LINE__, "kcidxadd"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); } oprintf("getting records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); vbuf = kcidxget(idx, kbuf, ksiz, &vsiz); if (vbuf) { if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) { idxerrprint(idx, __LINE__, "kcidxget"); err = TRUE; } kcfree(vbuf); } else if (!rnd || kcidxecode(idx) != KCENOREC) { idxerrprint(idx, __LINE__, "kcidxget"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); if (etc) { oprintf("synchronizing the database:\n"); stime = kctime(); if (!kcidxsync(idx, FALSE, NULL, NULL)) { idxerrprint(idx, __LINE__, "kcidxsync"); err = TRUE; } etime = kctime(); idxmetaprint(idx, FALSE); oprintf("time: %.3f\n", etime - stime); } oprintf("removing records:\n"); stime = kctime(); for (i = 1; !err && i <= rnum; i++) { ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i)); if (!kcidxremove(idx, kbuf, ksiz) && ((!rnd && !etc) || kcidxecode(idx) != KCENOREC)) { idxerrprint(idx, __LINE__, "kcidxremove"); err = TRUE; } if (rnum > 250 && i % (rnum / 250) == 0) { oputchar('.'); if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i); } } etime = kctime(); idxmetaprint(idx, TRUE); oprintf("time: %.3f\n", etime - stime); oprintf("closing the database:\n"); stime = kctime(); if (!kcidxclose(idx)) { idxerrprint(idx, __LINE__, "kcidxclose"); err = TRUE; } etime = kctime(); oprintf("time: %.3f\n", etime - stime); kcidxdel(idx); oprintf("%s\n\n", err ? "error" : "ok"); return err ? 1 : 0; }