int db__driver_execute_immediate(dbString * sql)
{
char *s, msg[OD_MSG];
cursor *c;
SQLRETURN ret;
SQLINTEGER err;
s = db_get_string(sql);
/* allocate cursor */
c = alloc_cursor();
if (c == NULL)
return DB_FAILED;
ret = SQLExecDirect(c->stmt, s, SQL_NTS);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
SQLGetDiagRec(SQL_HANDLE_STMT, c->stmt, 1, NULL, &err, msg,
sizeof(msg), NULL);
db_d_append_error("SQLExecDirect():\n%s\n%s (%d)\n", s, msg,
(int)err);
db_d_report_error();
return DB_FAILED;
}
free_cursor(c);
return DB_OK;
}
int main (int argc, const char * argv[]) {
FILE *fl = fopen(argv[1], "r");
FILE *out = fopen("/tmp/out.json", "w");
fseek(fl, 0, SEEK_END);
int file_size = ftell(fl);
printf("File size: %d\n", file_size);
fseek(fl, 0, SEEK_SET);
int index = 0;
Cursor* cursor = alloc_cursor();
clear_cursor(cursor);
cursor->position = -1;
read_osm_header(cursor, fl);
OsmItem* item;
do {
item = read_osm_item(cursor, fl, file_size);
if (item) {
char* json_item_txt = encode_item(item);
fputs(json_item_txt, out);
free(json_item_txt);
fputs("\n", out);
}
index += 1;
} while (item != NULL);
free_cursor(cursor);
fclose(fl);
fclose(out);
}
void show_tree_range(struct btree *btree, tuxkey_t start, unsigned count)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
__tux3_dbg("%i level btree at %Li:\n",
btree->root.depth, btree->root.block);
if (!has_root(btree))
return;
struct cursor *cursor = alloc_cursor(btree, 0);
if (!cursor) {
tux3_err(btree->sb, "out of memory");
return;
}
if (btree_probe(cursor, start)) {
tux3_fs_error(btree->sb, "tell me why!!!");
goto out;
}
struct buffer_head *buffer;
do {
buffer = cursor_leafbuf(cursor);
assert((btree->ops->leaf_sniff)(btree, bufdata(buffer)));
(btree->ops->leaf_dump)(btree, bufdata(buffer));
} while (--count && cursor_advance(cursor));
out:
free_cursor(cursor);
}
static krb5_error_code KRB5_CALLCONV
xcc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor)
{
CFDictionaryRef query;
struct xcc_cursor *c;
const void *keys[] = {
(void *)kHEIMAttrType,
(void *)kHEIMAttrServerName,
};
const void *values[] = {
(void *)kHEIMTypeKerberos,
(void *)kCFNull,
};
c = calloc(1, sizeof(*c));
if (c == NULL)
return krb5_enomem(context);
query = CFDictionaryCreate(NULL, keys, values, sizeof(keys)/sizeof(keys[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
heim_assert(query != NULL, "Failed to create dictionary");
c->array = HeimCredCopyQuery(query);
CFRELEASE_NULL(query);
if (c->array == NULL) {
free_cursor(c);
return KRB5_CC_END;
}
*cursor = c;
return 0;
}
static krb5_error_code KRB5_CALLCONV
xcc_get_first (krb5_context context,
krb5_ccache id,
krb5_cc_cursor *cursor)
{
CFDictionaryRef query;
krb5_xcc *x = XCACHE(id);
CFUUIDRef uuid = HeimCredGetUUID(x->cred);
struct xcc_cursor *c;
c = calloc(1, sizeof(*c));
if (c == NULL)
return krb5_enomem(context);
const void *keys[] = { (void *)kHEIMAttrParentCredential, kHEIMAttrType };
const void *values[] = { (void *)uuid, kHEIMTypeKerberos };
query = CFDictionaryCreate(NULL, keys, values, sizeof(keys)/sizeof(keys[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
heim_assert(query != NULL, "out of memory");
c->array = HeimCredCopyQuery(query);
CFRELEASE_NULL(query);
if (c->array == NULL) {
free_cursor(c);
return KRB5_CC_END;
}
*cursor = c;
return 0;
}
//
// Delete clog
//
CLogGtk::~CLogGtk()
{
free_cursor();
delete clognav;
if ( filter_form)
gtk_widget_destroy( filter_form);
gtk_widget_destroy( toplevel);
}
bool_t free_lessui(lessui_t *ui) {
if( ui ) {
free_display(&ui->display);
free_cursorrep(&ui->cr);
free_cursormanager(&ui->cmg);
free_cursor(&ui->cursor);
return TRUE;
}
return FALSE;
}
static krb5_error_code KRB5_CALLCONV
xcc_end_get (krb5_context context,
krb5_ccache id,
krb5_cc_cursor *cursor)
{
free_cursor((struct xcc_cursor *)*cursor);
*cursor = NULL;
return 0;
}
int sql_open(const char *stmt, SQL_ROW &argv) {
const char *p=stmt;
int n_sub=0,rv=-1;
SQL_CURSOR c=-1;
std::string query("");
while (*p != 0) {
if (*p=='?') {
if (n_sub<argv.argc()) {
query+=argv[n_sub];
}
n_sub++;
} else {
query+=*p;
}
p++;
}
//printf("argv.argc()= %d",argv.argc()); fflush(stdout);
if ((argv.argc()==n_sub) && ((c=allocate_cursor())>=0)) {
//printf("mysql= %p",mysql); fflush(stdout);
rv=mysql_real_query(mysql,query.c_str(),query.size());
//printf("rv= %d",rv); fflush(stdout);
} else {
//fprintf(stderr,"field mismatch: %d != %d in %s\r\n",argv.argc(),n_sub,query.c_str());
}
if (rv) {
chk_cursor(c,"mysql_real_query");
free_cursor(c);
return -1;
}
if (store_result(c)) {
cursor_arr[c].is_select=1;
} else {
if (mysql_field_count(mysql)!=0) {
fprintf(stderr,"mysql_field_count()!=0 : %s\r\n",query.c_str());
free_cursor(c);
return -1;
}
cursor_arr[c].is_select=0;
}
return c;
}
void Root_widget::pop_cursor()
{
// All cursors but the top one must be freed after use
if (_cursor_stack.size() > 1)
{
free_cursor( get_current_cursor() );
}
set_cursor(_cursor_stack.top());
_cursor_stack.pop();
}
int db__driver_close_cursor(dbCursor * dbc)
{
cursor *c;
/* get my cursor via the dbc token */
c = (cursor *) db_find_token(db_get_cursor_token(dbc));
if (c == NULL)
return DB_FAILED;
/* free_cursor(cursor) */
free_cursor(c);
return DB_OK;
}
int main (int argc, char *argv[])
{
struct queryopt opt;
struct ofields *fields;
struct select_doc *s_doc;
struct query_doc *qu_doc;
struct db_connect *db_conn;
struct output *out;
struct db_cursor *db_c;
struct results *res;
opt.e_skip = 0; // standard
opt.e_ret = 0; // standard
opt.bsever = 0;
opt.blevel = 0;
opt.bdate = 0;
opt.bdateu = 0;
opt.bdatef = 0;
opt.bmsg = 0;
opt.bskip = 0;
opt.bsys = 0;
getoptions(argc, argv, &opt);
qu_doc = create_query(&opt); // crate query
s_doc = create_select();
db_conn = create_conn(); // create connection
out = launch_query(&opt, s_doc, qu_doc, db_conn); // launch the query
db_c = open_cursor(db_conn, out); // open cursor
while (cursor_next(db_c))
{
res = read_data(db_c);
fields = get_data(res);
formater(fields); // formate output
free(fields);
free(res);
}
free_cursor(db_c);
close_conn(db_conn);
free(out);
free(s_doc);
free(qu_doc);
return (0);
}
void show_tree_range(struct btree *btree, tuxkey_t start, unsigned count)
{
printf("%i level btree at %Li:\n", btree->root.depth, (L)btree->root.block);
struct cursor *cursor = alloc_cursor(btree, 0);
if (!cursor)
error("out of memory");
if (probe(btree, start, cursor))
error("tell me why!!!");
struct buffer_head *buffer;
do {
buffer = cursor_leafbuf(cursor);
assert((btree->ops->leaf_sniff)(btree, bufdata(buffer)));
(btree->ops->leaf_dump)(btree, bufdata(buffer));
//tuxkey_t *next = pnext_key(cursor, btree->depth);
//printf("next key = %Lx:\n", next ? (L)*next : 0);
} while (--count && advance(btree, cursor));
free_cursor(cursor);
}
cursor *alloc_cursor()
{
cursor *c;
/* allocate the cursor */
c = (cursor *) db_malloc(sizeof(cursor));
if (c == NULL) {
append_error("cannot alloc new cursor");
return c;
}
c->st = NULL;
c->cols = NULL;
/* tokenize it */
c->token = db_new_token(c);
if (c->token < 0) {
free_cursor(c);
c = NULL;
append_error("cannot tokenize new cursor\n");
}
return c;
}
int db__driver_create_table(dbTable * table)
{
dbString sql;
cursor *c;
char msg[OD_MSG];
char *emsg = NULL;
SQLRETURN ret;
SQLINTEGER err;
G_debug(3, "db__driver_create_table()");
db_init_string(&sql);
db_table_to_sql(table, &sql);
G_debug(3, " SQL: %s", db_get_string(&sql));
c = alloc_cursor();
if (c == NULL)
return DB_FAILED;
ret = SQLExecDirect(c->stmt, db_get_string(&sql), SQL_NTS);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
SQLGetDiagRec(SQL_HANDLE_STMT, c->stmt, 1, NULL, &err, msg,
sizeof(msg), NULL);
G_asprintf(&emsg, "SQLExecDirect():\n%s\n%s (%d)\n",
db_get_string(&sql), msg, (int)err);
report_error(emsg);
G_free(emsg);
return DB_FAILED;
}
free_cursor(c);
return DB_OK;
}
static int select_and_print(DB * db, const char *tname,
col_t * cols, int ncol, cond_t * conds, int ncond)
{
table_t *t;
cursor_t *cur;
record_t *r;
int count;
int ret = 0;
int error, xerror;
if ((t = db_find_table(db, tname)) == NULL) {
xerrno = ERR_NOTABLE;
return -1;
}
for (int i = 0; i < ncol; i++) {
int k;
if ((k = table_find_col(t, cols[i].name)) < 0) {
xerrno = ERR_NOCOL;
return -1;
}
cols[i].type = t->cols[k].type;
cols[i].size = t->cols[k].size;
}
if (ncol == 0) {
ncol = t->ncols;
cols = t->cols;
}
int *width;
if ((width = calloc(ncol, sizeof(int))) == NULL) {
perror("out of memory");
return -1;
}
for (int i = 0; i < ncol; i++) {
int k = table_find_col(t, cols[i].name);
switch (t->cols[k].type) {
case TYPE_INT:
width[i] =
_max(INT_P_WIDTH, strlen(t->cols[k].name) + 1);
break;
case TYPE_FLOAT:
width[i] =
_max(FLOAT_P_WIDTH, strlen(t->cols[k].name) + 1);
break;
case TYPE_STRING:
width[i] =
_max(t->cols[k].size, strlen(t->cols[k].name) + 1);
break;
}
}
if ((cur = select_from(db, tname, conds, ncond)) == NULL) {
preserve_errno(free(width));
return -1;
}
print_thead(cols, ncol, width);
count = 0;
while ((r = select_next(db, cur)) != NULL) {
print_record(t, cols, ncol, r, width);
free_record(r);
count++;
}
if (select_error(cur)) {
error = errno;
xerror = xerrno;
ret = -1;
}
printf("Total %d %s\n\n", count, count > 1 ? "records" : "record");
free_cursor(cur);
free(width);
errno = error;
xerrno = xerror;
return ret;
}
bool sql_close(SQL_CURSOR c) {
free_result(c);
return free_cursor(c);
}
/*
* This is range deletion. So, instead of adjusting balance of the
* space on sibling nodes for each change, this just removes the range
* and merges from right to left even if it is not same parent.
*
* +--------------- (A, B, C)--------------------+
* | | |
* +-- (AA, AB, AC) -+ +- (BA, BB, BC) -+ + (CA, CB, CC) +
* | | | | | | | | |
* (AAA,AAB)(ABA,ABB)(ACA,ACB) (BAA,BAB)(BBA)(BCA,BCB) (CAA)(CBA,CBB)(CCA)
*
* [less : A, AA, AAA, AAB, AB, ABA, ABB, AC, ACA, ACB, B, BA ... : greater]
*
* If we merged from cousin (or re-distributed), we may have to update
* the index until common parent. (e.g. removed (ACB), then merged
* from (BAA,BAB) to (ACA), we have to adjust B in root node to BB)
*
* See, adjust_parent_sep().
*
* FIXME: no re-distribute. so, we don't guarantee above than 50%
* space efficiency. And if range is end of key (truncate() case), we
* don't need to merge, and adjust_parent_sep().
*
* FIXME2: we may want to split chop work for each step. instead of
* blocking for a long time.
*/
int btree_chop(struct btree *btree, tuxkey_t start, u64 len)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
struct sb *sb = btree->sb;
struct btree_ops *ops = btree->ops;
struct buffer_head **prev, *leafprev = NULL;
struct chopped_index_info *cii;
struct cursor *cursor;
tuxkey_t limit;
int ret, done = 0;
if (!has_root(btree))
return 0;
/* Chop all range if len >= TUXKEY_LIMIT */
limit = (len >= TUXKEY_LIMIT) ? TUXKEY_LIMIT : start + len;
prev = malloc(sizeof(*prev) * btree->root.depth);
if (prev == NULL)
return -ENOMEM;
memset(prev, 0, sizeof(*prev) * btree->root.depth);
cii = malloc(sizeof(*cii) * btree->root.depth);
if (cii == NULL) {
ret = -ENOMEM;
goto error_cii;
}
memset(cii, 0, sizeof(*cii) * btree->root.depth);
cursor = alloc_cursor(btree, 0);
if (!cursor) {
ret = -ENOMEM;
goto error_alloc_cursor;
}
down_write(&btree->lock);
ret = btree_probe(cursor, start);
if (ret)
goto error_btree_probe;
/* Walk leaves */
while (1) {
struct buffer_head *leafbuf;
tuxkey_t this_key;
/*
* FIXME: If leaf was merged and freed later, we don't
* need to redirect leaf and leaf_chop()
*/
if ((ret = cursor_redirect(cursor)))
goto out;
leafbuf = cursor_pop(cursor);
/* Adjust start and len for this leaf */
this_key = cursor_level_this_key(cursor);
if (start < this_key) {
if (limit < TUXKEY_LIMIT)
len -= this_key - start;
start = this_key;
}
ret = ops->leaf_chop(btree, start, len, bufdata(leafbuf));
if (ret) {
if (ret < 0) {
blockput(leafbuf);
goto out;
}
mark_buffer_dirty_non(leafbuf);
}
/* Try to merge this leaf with prev */
if (leafprev) {
if (try_leaf_merge(btree, leafprev, leafbuf)) {
trace(">>> can merge leaf %p into leaf %p", leafbuf, leafprev);
remove_index(cursor, cii);
mark_buffer_dirty_non(leafprev);
blockput_free(sb, leafbuf);
goto keep_prev_leaf;
}
blockput(leafprev);
}
leafprev = leafbuf;
keep_prev_leaf:
if (cursor_level_next_key(cursor) >= limit)
done = 1;
/* Pop and try to merge finished nodes */
while (done || cursor_level_finished(cursor)) {
struct buffer_head *buf;
int level = cursor->level;
struct chopped_index_info *ciil = &cii[level];
/* Get merge src buffer, and go parent level */
buf = cursor_pop(cursor);
/*
* Logging chopped indexes
* FIXME: If node is freed later (e.g. merged),
* we dont't need to log this
*/
if (ciil->count) {
log_bnode_del(sb, bufindex(buf), ciil->start,
ciil->count);
}
memset(ciil, 0, sizeof(*ciil));
/* Try to merge node with prev */
if (prev[level]) {
assert(level);
if (try_bnode_merge(sb, prev[level], buf)) {
trace(">>> can merge node %p into node %p", buf, prev[level]);
remove_index(cursor, cii);
mark_buffer_unify_non(prev[level]);
blockput_free_unify(sb, buf);
goto keep_prev_node;
}
blockput(prev[level]);
}
prev[level] = buf;
keep_prev_node:
if (!level)
goto chop_root;
}
/* Push back down to leaf level */
do {
ret = cursor_advance_down(cursor);
if (ret < 0)
goto out;
} while (ret);
}
chop_root:
/* Remove depth if possible */
while (btree->root.depth > 1 && bcount(bufdata(prev[0])) == 1) {
trace("drop btree level");
btree->root.block = bufindex(prev[1]);
btree->root.depth--;
tux3_mark_btree_dirty(btree);
/*
* We know prev[0] is redirected and dirty. So, in
* here, we can just cancel bnode_redirect by bfree(),
* instead of defered_bfree()
* FIXME: we can optimize freeing bnode without
* bnode_redirect, and if we did, this is not true.
*/
bfree(sb, bufindex(prev[0]), 1);
log_bnode_free(sb, bufindex(prev[0]));
blockput_free_unify(sb, prev[0]);
vecmove(prev, prev + 1, btree->root.depth);
}
ret = 0;
out:
if (leafprev)
blockput(leafprev);
for (int i = 0; i < btree->root.depth; i++) {
if (prev[i])
blockput(prev[i]);
}
release_cursor(cursor);
error_btree_probe:
up_write(&btree->lock);
free_cursor(cursor);
error_alloc_cursor:
free(cii);
error_cii:
free(prev);
return ret;
}
static krb5_error_code KRB5_CALLCONV
xcc_end_cache_get(krb5_context context, krb5_cc_cursor cursor)
{
free_cursor((struct xcc_cursor *)cursor);
return 0;
}
//
// Delete clog
//
CLogMotif::~CLogMotif()
{
free_cursor();
XtDestroyWidget( parent_wid_clog);
delete clognav;
}
//
// Delete nodelist
//
NodelistGtk::~NodelistGtk()
{
free_cursor();
delete nodelistnav;
gtk_widget_destroy( toplevel);
}
int db__driver_drop_table(dbString * name)
{
char cmd[200];
cursor *c;
SQLRETURN ret;
char msg[OD_MSG];
char *emsg = NULL;
SQLINTEGER err;
SQLCHAR ttype[50], *tname;
SQLINTEGER nrow = 0;
/* allocate cursor */
c = alloc_cursor();
if (c == NULL)
return DB_FAILED;
tname = db_get_string(name);
ret = SQLTables(c->stmt, NULL, 0, NULL, 0, tname, sizeof(tname), NULL, 0);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
report_error("SQLTables()");
return DB_FAILED;
}
/* Get number of rows */
ret = SQLRowCount(c->stmt, &nrow);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
report_error("SQLRowCount()");
return DB_FAILED;
}
if (nrow == 0) {
G_asprintf(&emsg, "Table %s doesn't exist\n", tname);
report_error(emsg);
G_free(emsg);
return DB_FAILED;
}
ret = SQLFetchScroll(c->stmt, SQL_FETCH_NEXT, 0);
ret = SQLGetData(c->stmt, 4, SQL_C_CHAR, ttype, sizeof(ttype), NULL);
if (strcmp(ttype, "TABLE") == 0) {
sprintf(cmd, "DROP TABLE %s", tname);
}
else if (strcmp(ttype, "VIEW") == 0) {
sprintf(cmd, "DROP VIEW %s", tname);
}
else {
G_asprintf(&emsg, "Table %s isn't 'TABLE' or 'VIEW' but %s\n", tname,
ttype);
report_error(emsg);
G_free(emsg);
return DB_FAILED;
}
SQLCloseCursor(c->stmt);
ret = SQLExecDirect(c->stmt, cmd, SQL_NTS);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
SQLGetDiagRec(SQL_HANDLE_STMT, c->stmt, 1, NULL, &err, msg,
sizeof(msg), NULL);
G_asprintf(&emsg, "SQLExecDirect():\n%s\n%s (%d)\n", cmd, msg,
(int)err);
report_error(emsg);
G_free(emsg);
return DB_FAILED;
}
free_cursor(c);
return DB_OK;
}
