static enum interval_iter cb(struct interval_node *n, void *args) { struct it_node *node = (struct it_node *)n; static int count = 1; if (node->hit == 1) { error("A duplicate node "__S" access found\n", __F(&n->in_extent)); return INTERVAL_ITER_CONT; } if (node->valid == 0) { error("A deleted node "__S" being accessed\n", __F(&n->in_extent)); return INTERVAL_ITER_STOP; } if (count++ == 8) { dprintf("\n"); count = 1; } dprintf(""__S" ", __F(&n->in_extent)); fflush(stdout); node->hit = 1; return INTERVAL_ITER_CONT; }
void UserVarEvent::init() { rb_cBinlogUserVarEvent = rb_define_class_under(rb_mBinlog, "UserVarEvent", rb_cBinlogEvent); rb_define_alloc_func(rb_cBinlogUserVarEvent, &alloc); Event::init(rb_cBinlogUserVarEvent); rb_define_method(rb_cBinlogUserVarEvent, "name", __F(&get_name), 0); rb_define_method(rb_cBinlogUserVarEvent, "is_null", __F(&get_is_null), 0); rb_define_method(rb_cBinlogUserVarEvent, "var_type", __F(&get_type), 0); rb_define_method(rb_cBinlogUserVarEvent, "charset", __F(&get_charset), 0); rb_define_method(rb_cBinlogUserVarEvent, "value", __F(&get_value), 0); }
/* sanity test is tightly coupled with implementation, so when you changed * the interval tree implementation, change this code also. */ static enum interval_iter sanity_cb(struct interval_node *node, void *args) { __u64 max_high = node->in_max_high; struct interval_node *tmp, *parent; int left = 1, has = 0, nr = 0; parent = node->in_parent; node->in_parent = NULL; interval_for_each(tmp, node) { if ((left && node_compare(tmp, node) > 0) || (!left && node_compare(tmp, node) < 0)) error("interval tree sanity test\n"); if (tmp->in_max_high > max_high) { dprintf("max high sanity check, max_high is %llu," "child max_high: %llu"__S"\n", max_high, tmp->in_max_high, __F(&tmp->in_extent)); goto err; } else if (tmp->in_max_high == max_high) { has = 1; } if (tmp == node) { left = 0; continue; } } if (!has) { int count; err: count = 1; dprintf("node"__S":%llu Child list:\n", node->in_extent.start, node->in_extent.end, node->in_max_high); interval_for_each(tmp, node) { dprintf(""__S":%llu ", __F(&tmp->in_extent), tmp->in_max_high); if (count++ == 8) { dprintf("\n"); count = 1; } }
static int it_test_find(struct interval_node *root) { int idx; struct interval_node_extent *ext; dprintf("\ninterval_find testing start ..\n"); for (idx = 0; idx < it_count; idx++) { if (it_array[idx].valid == 0) continue; ext = &it_array[idx].node.in_extent; dprintf("Try to find "__S"\n", __F(ext)); if (!interval_find(root, ext)) error("interval_find, try to find "__S"\n", __F(ext)); } return 0; }
static int it_test_search(struct interval_node *root) { struct it_node *n; struct interval_node_extent ext; int times = 10, i, err = 0; while (times--) { it_test_clear(); ext.start = (random() % max_count) & ALIGN_MASK; ext.end = random() % (max_count - ext.start + 2) + ext.start; ext.end &= ALIGN_MASK; if (ext.end > max_count) ext.end = max_count; dprintf("\n\nSearching the node overlapped "__S" ..\n", __F(&ext)); interval_search(root, &ext, cb, NULL); dprintf("\nverifing ..."); /* verify */ for (i = 0; i < it_count; i++) { n = &it_array[i]; if (n->valid == 0) continue; if (extent_overlapped(&ext, &n->node.in_extent) && n->hit == 0) error("node "__S" overlaps" __S"," "but never to be hit.\n", __F(&n->node.in_extent), __F(&ext)); if (!extent_overlapped(&ext, &n->node.in_extent) && n->hit) error("node "__S" overlaps" __S", but hit.\n", __F(&n->node.in_extent), __F(&ext)); } if (err) error("search error\n"); dprintf("ok.\n"); } return 0; }
void Event::init(VALUE clazz) { rb_define_method(clazz, "marker", __F(&get_marker), 0); rb_define_method(clazz, "timestamp", __F(&get_timestamp), 0); rb_define_method(clazz, "type_code", __F(&get_type_code), 0); rb_define_method(clazz, "server_id", __F(&get_server_id), 0); rb_define_method(clazz, "event_length", __F(&get_event_length), 0); rb_define_method(clazz, "next_position", __F(&get_next_position), 0); rb_define_method(clazz, "flags", __F(&get_flags), 0); rb_define_method(clazz, "event_type", __F(&get_event_type), 0); }
void QueryEvent::init() { rb_cBinlogQueryEvent = rb_define_class_under(rb_mBinlog, "QueryEvent", rb_cBinlogEvent); rb_define_alloc_func(rb_cBinlogQueryEvent, &alloc); Event::init(rb_cBinlogQueryEvent); rb_define_method(rb_cBinlogQueryEvent, "thread_id", __F(&get_thread_id), 0); rb_define_method(rb_cBinlogQueryEvent, "exec_time", __F(&get_exec_time), 0); rb_define_method(rb_cBinlogQueryEvent, "error_code", __F(&get_error_code), 0); rb_define_method(rb_cBinlogQueryEvent, "variables", __F(&get_variables), 0); rb_define_method(rb_cBinlogQueryEvent, "db_name", __F(&get_db_name), 0); rb_define_method(rb_cBinlogQueryEvent, "query", __F(&get_query), 0); }
static int it_test_iterate(struct interval_node *root) { int i; dprintf("\n\nIterate testing start..\n"); it_test_clear(); interval_iterate(root, cb, NULL); /* verify */ for (i = 0; i < it_count; i++) { if (it_array[i].valid == 0) continue; if (it_array[i].hit == 0) error("Node "__S" is not accessed\n", __F(&it_array[i].node.in_extent)); } return 0; }
void RowEvent::init() { rb_cBinlogRowEvent = rb_define_class_under(rb_mBinlog, "RowEvent", rb_cBinlogEvent); rb_define_alloc_func(rb_cBinlogRowEvent, &alloc); Event::init(rb_cBinlogRowEvent); rb_define_method(rb_cBinlogRowEvent, "table_id", __F(&get_table_id), 0); rb_define_method(rb_cBinlogRowEvent, "db_name", __F(&get_db_name), 0); rb_define_method(rb_cBinlogRowEvent, "table_name", __F(&get_table_name), 0); rb_define_method(rb_cBinlogRowEvent, "columns", __F(&get_column_types), 0); rb_define_method(rb_cBinlogRowEvent, "flags", __F(&get_flags), 0); rb_define_method(rb_cBinlogRowEvent, "columns_len", __F(&get_columns_len), 0); rb_define_method(rb_cBinlogRowEvent, "null_bits_len", __F(&get_null_bits_len), 0); rb_define_method(rb_cBinlogRowEvent, "raw_columns_before_image", __F(&get_columns_before_image), 0); rb_define_method(rb_cBinlogRowEvent, "raw_used_columns", __F(&get_used_columns), 0); rb_define_method(rb_cBinlogRowEvent, "raw_row", __F(&get_row), 0); rb_define_method(rb_cBinlogRowEvent, "rows", __F(&get_rows), 0); }