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); }