rbt rbt_delete(rbt r)
{
if(r == NULL){
return r;/*aka return null*/
}else{
rbt_delete(r->left);
rbt_delete(r->right);
free(r->key);
free(r);
return r;
}
}
static void
aoff_unlink_free_block(Allctr_t *allctr, Block_t *blk)
{
AOFFAllctr_t* alc = (AOFFAllctr_t*)allctr;
AOFF_RBTree_t* del = (AOFF_RBTree_t*)blk;
AOFF_Carrier_t *crr = (AOFF_Carrier_t*) FBLK_TO_MBC(&del->hdr);
ASSERT(crr->rbt_node.hdr.bhdr == crr->root->max_sz);
HARD_CHECK_TREE(&crr->crr, alc->blk_order, crr->root, 0);
if (alc->blk_order == FF_BF) {
ASSERT(del->flags & IS_BF_FLG);
if (IS_LIST_ELEM(del)) {
/* Remove from list */
ASSERT(LIST_PREV(del));
ASSERT(LIST_PREV(del)->flags & IS_BF_FLG);
LIST_NEXT(LIST_PREV(del)) = LIST_NEXT(del);
if (LIST_NEXT(del)) {
ASSERT(LIST_NEXT(del)->flags & IS_BF_FLG);
LIST_PREV(LIST_NEXT(del)) = LIST_PREV(del);
}
return;
}
else if (LIST_NEXT(del)) {
/* Replace tree node by next element in list... */
ASSERT(AOFF_BLK_SZ(LIST_NEXT(del)) == AOFF_BLK_SZ(del));
ASSERT(IS_LIST_ELEM(LIST_NEXT(del)));
replace(&crr->root, (AOFF_RBTree_t*)del, LIST_NEXT(del));
HARD_CHECK_TREE(&crr->crr, alc->blk_order, crr->root, 0);
return;
}
}
rbt_delete(&crr->root, (AOFF_RBTree_t*)del);
HARD_CHECK_TREE(&crr->crr, alc->blk_order, crr->root, 0);
/* Update the carrier tree with a potentially new (lower) max_sz
*/
if (crr->root) {
if (crr->rbt_node.hdr.bhdr == crr->root->max_sz) {
return;
}
ASSERT(crr->rbt_node.hdr.bhdr > crr->root->max_sz);
crr->rbt_node.hdr.bhdr = crr->root->max_sz;
}
else {
crr->rbt_node.hdr.bhdr = 0;
}
lower_max_size(&crr->rbt_node, NULL);
}
rbt rbt_delete(rbt r, char *s) {
rbt tmp_r;
char *tmp_str;
if (r == NULL) {
return r;
} else if (strcmp(s, r->key) == 0) {
if (r->left == NULL && r->right == NULL) {
free(r->key);
free(r);
r = NULL;
return r;
} else if (r->left != NULL && r->right != NULL) {
/* LEFTMOST = tmp_r */
tmp_r = r->right;
while (tmp_r->left != NULL) {
tmp_r = tmp_r->left;
}
tmp_str = tmp_r->key;
tmp_r->key = r->key;
r->key = tmp_str;
r->right = rbt_delete(r->right, s);
} else {
if (r->left != NULL) {
tmp_r = r;
r = r->left;
free(tmp_r->key);
free(tmp_r);
} else {
tmp_r = r;
r = r->right;
free(tmp_r->key);
free(tmp_r);
}
}
} else if (strcmp(s, r->key) < 0) {
r->left = rbt_delete(r->left, s);
} else {
r->right = rbt_delete(r->right, s);
}
return r;
}
void aoff_remove_pooled_mbc(Allctr_t *allctr, Carrier_t *crr)
{
ASSERT(allctr == crr->cpool.orig_allctr);
HARD_CHECK_TREE(NULL, 0, allctr->cpool.pooled_tree, 0);
rbt_delete(&allctr->cpool.pooled_tree, &crr->cpool.pooled);
#ifdef DEBUG
crr->cpool.pooled.parent = NULL;
crr->cpool.pooled.left = NULL;
crr->cpool.pooled.right = NULL;
crr->cpool.pooled.max_sz = 0;
#endif
HARD_CHECK_TREE(NULL, 0, allctr->cpool.pooled_tree, 0);
}
int main(){
Rbt_tree_link a = rbt_create();
Rbtlink it;
srand(time(NULL));
puts("Inserting...");
for(i=0;i<N;i++) {
num[i] = rand() % N;
rbt_insert(a,num[i]);
}
printf("rbt_size: %d\n",rbt_size(a));
printf("min value:%d max value:%d\n",rbt_item(rbt_minimum(a)),rbt_item(rbt_maximum(a)));
puts("Doing assert...");
rbt_assert(a);
puts("Traversing (inorder)...");
rbt_inorder(a,func);
for(i=0; i < N; i++)
rbt_search(a, i);
puts("Traversing (from max to min)...");
it = rbt_maximum(a);
for(i = rbt_size(a)-1; i >= 0; i--) {
assert(n[i] == rbt_item(it));
it = rbt_predecessor(it);
}
printf("rbt_size: %d\n",rbt_size(a));
puts("Deleting all values...");
int i = 0;
for (i = 0; i < N; ++i) {
printf("%d deleted\r", num[i]);
rbt_delete(a, num[i]);
}
puts("\nDestroying rbt..");
rbt_destroy(a);
puts("OK!");
return 0;
}
static void aoff_remove_mbc(Allctr_t *allctr, Carrier_t *carrier)
{
AOFF_RBTree_t **root = &((AOFFAllctr_t*)allctr)->mbc_root;
AOFF_Carrier_t *crr = (AOFF_Carrier_t*)carrier;
ASSERT(allctr == ERTS_ALC_CARRIER_TO_ALLCTR(carrier));
if (!IS_CRR_IN_TREE(crr,*root))
return;
HARD_CHECK_TREE(NULL, alc->crr_order, *root, 0);
rbt_delete(root, &crr->rbt_node);
crr->rbt_node.parent = NULL;
crr->rbt_node.left = NULL;
crr->rbt_node.right = NULL;
crr->rbt_node.max_sz = crr->rbt_node.hdr.bhdr;
HARD_CHECK_TREE(NULL, alc->crr_order, *root, 0);
}
int
bc_remove_block(page_idx_t start_page, int order, int zap_page) {
if (zap_page) {
char* p = get_page_addr(start_page);
size_t len = ((size_t)(1 << order)) << alloc_info->page_size_log2;
madvise(p, len, MADV_DONTDUMP|MADV_DONTNEED);
}
if (!blk_cache_init || !enable_blk_cache)
return 0;
intptr_t idx;
if (!rbt_delete(blk_cache->blks, start_page, &idx))
return 0;
ASSERT(blk_cache->lru_v[idx].order == order);
blk_cache->total_page_num -= (1 << order);
ASSERT(blk_cache->total_page_num >= 0);
lru_remove(idx);
return 1;
}
/********************************************************************//**
Add a single foreign key definition to the data dictionary tables in the
database. We also generate names to constraints that were not named by the
user. A generated constraint has a name of the format
databasename/tablename_ibfk_NUMBER, where the numbers start from 1, and
are given locally for this table, that is, the number is not global, as in
the old format constraints < 4.0.18 it used to be.
@return error code or DB_SUCCESS */
static
ulint
dict_create_add_foreign_to_dictionary(
/*==================================*/
ulint* id_nr, /*!< in/out: number to use in id generation;
incremented if used */
dict_table_t* table, /*!< in: table */
dict_foreign_t* foreign,/*!< in: foreign */
trx_t* trx) /*!< in: transaction */
{
ulint error;
ulint i;
pars_info_t* info;
ut_ad(mutex_own(&(dict_sys->mutex)));
if (foreign->id == NULL) {
/* Generate a new constraint id */
ulint namelen = strlen(table->name);
char* id = mem_heap_alloc(foreign->heap, namelen + 20);
if (row_is_mysql_tmp_table_name(table->name)) {
sprintf(id, "%s_ibfk_%lu", table->name,
(ulong) (*id_nr)++);
} else {
char table_name[MAX_TABLE_NAME_LEN + 20] = "";
uint errors = 0;
strncpy(table_name, table->name,
MAX_TABLE_NAME_LEN + 20);
innobase_convert_to_system_charset(
strchr(table_name, '/') + 1,
strchr(table->name, '/') + 1,
MAX_TABLE_NAME_LEN, &errors);
if (errors) {
strncpy(table_name, table->name,
MAX_TABLE_NAME_LEN + 20);
}
sprintf(id, "%s_ibfk_%lu", table_name,
(ulong) (*id_nr)++);
if (innobase_check_identifier_length(
strchr(id,'/') + 1)) {
return(DB_IDENTIFIER_TOO_LONG);
}
}
foreign->id = id;
}
info = pars_info_create();
pars_info_add_str_literal(info, "id", foreign->id);
pars_info_add_str_literal(info, "for_name", table->name);
pars_info_add_str_literal(info, "ref_name",
foreign->referenced_table_name);
pars_info_add_int4_literal(info, "n_cols",
foreign->n_fields + (foreign->type << 24));
error = dict_foreign_eval_sql(info,
"PROCEDURE P () IS\n"
"BEGIN\n"
"INSERT INTO SYS_FOREIGN VALUES"
"(:id, :for_name, :ref_name, :n_cols);\n"
"END;\n"
, table, foreign, trx);
if (error != DB_SUCCESS) {
return(error);
}
for (i = 0; i < foreign->n_fields; i++) {
error = dict_create_add_foreign_field_to_dictionary(
i, table, foreign, trx);
if (error != DB_SUCCESS) {
return(error);
}
}
error = dict_foreign_eval_sql(NULL,
"PROCEDURE P () IS\n"
"BEGIN\n"
"COMMIT WORK;\n"
"END;\n"
, table, foreign, trx);
if (error == DB_SUCCESS) {
if (foreign->foreign_table != NULL) {
ib_rbt_t* rbt
= foreign->foreign_table->foreign_rbt;
if (rbt == NULL) {
rbt = dict_table_init_foreign_rbt(
foreign->foreign_table);
} else {
rbt_delete(rbt, foreign->id);
}
rbt_insert(rbt, foreign->id, &foreign);
}
if (foreign->referenced_table != NULL) {
ib_rbt_t* rbt
= foreign->referenced_table->referenced_rbt;
if (rbt == NULL) {
rbt = dict_table_init_referenced_rbt(
foreign->referenced_table);
} else {
rbt_delete(rbt, foreign->id);
}
rbt_insert(rbt, foreign->id, &foreign);
}
}
return(error);
}
