开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
dict0crea.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：33k
源码类别：

MySQL数据库

开发平台：

Visual C++

dict0crea.c：源码内容
  1. /******************************************************
  2. Database object creation
  4. (c) 1996 Innobase Oy
  6. Created 1/8/1996 Heikki Tuuri
  7. *******************************************************/
  9. #include "dict0crea.h"
  11. #ifdef UNIV_NONINL
  12. #include "dict0crea.ic"
  13. #endif
  15. #include "btr0pcur.h"
  16. #include "btr0btr.h"
  17. #include "page0page.h"
  18. #include "mach0data.h"
  19. #include "dict0boot.h"
  20. #include "dict0dict.h"
  21. #include "que0que.h"
  22. #include "row0ins.h"
  23. #include "row0mysql.h"
  24. #include "pars0pars.h"
  25. #include "trx0roll.h"
  26. #include "usr0sess.h"
  28. /*********************************************************************
  29. Based on a table object, this function builds the entry to be inserted
  30. in the SYS_TABLES system table. */
  31. static
  32. dtuple_t*
  33. dict_create_sys_tables_tuple(
  34. /*=========================*/
  35. /* out: the tuple which should be inserted */
  36. dict_table_t* table,  /* in: table */
  37. mem_heap_t* heap) /* in: memory heap from which the memory for
  38. the built tuple is allocated */
  39. {
  40. dict_table_t* sys_tables;
  41. dtuple_t* entry;
  42. dfield_t* dfield;
  43. byte* ptr;
  45. ut_ad(table && heap);
  47. sys_tables = dict_sys->sys_tables;
  49. entry = dtuple_create(heap, 8 + DATA_N_SYS_COLS);
  51. /* 0: NAME -----------------------------*/
  52. dfield = dtuple_get_nth_field(entry, 0);
  54. dfield_set_data(dfield, table->name, ut_strlen(table->name));
  55. /* 3: ID -------------------------------*/
  56. dfield = dtuple_get_nth_field(entry, 1);
  58. ptr = mem_heap_alloc(heap, 8);
  59. mach_write_to_8(ptr, table->id);
  61. dfield_set_data(dfield, ptr, 8);
  62. /* 4: N_COLS ---------------------------*/
  63. dfield = dtuple_get_nth_field(entry, 2);
  65. ptr = mem_heap_alloc(heap, 4);
  66. mach_write_to_4(ptr, table->n_def);
  68. dfield_set_data(dfield, ptr, 4);
  69. /* 5: TYPE -----------------------------*/
  70. dfield = dtuple_get_nth_field(entry, 3);
  72. ptr = mem_heap_alloc(heap, 4);
  73. mach_write_to_4(ptr, table->type);
  75. dfield_set_data(dfield, ptr, 4);
  76. /* 6: MIX_ID ---------------------------*/
  77. dfield = dtuple_get_nth_field(entry, 4);
  79. ptr = mem_heap_alloc(heap, 8);
  80. mach_write_to_8(ptr, table->mix_id);
  82. dfield_set_data(dfield, ptr, 8);
  83. /* 7: MIX_LEN --------------------------*/
  85. /* Track corruption reported on mailing list Jan 14, 2005 */
  86. if (table->mix_len != 0 && table->mix_len != 0x80000000) {
  87. fprintf(stderr,
  88. "InnoDB: Error: mix_len is %lu in table %sn", (ulong)table->mix_len,
  89. table->name);
  90. mem_analyze_corruption((byte*)&(table->mix_len));
  92. ut_error;
  93. }
  95. dfield = dtuple_get_nth_field(entry, 5);
  97. ptr = mem_heap_alloc(heap, 4);
  98. mach_write_to_4(ptr, table->mix_len);
  100. dfield_set_data(dfield, ptr, 4);
  101. /* 8: CLUSTER_NAME ---------------------*/
  102. dfield = dtuple_get_nth_field(entry, 6);
  104.   if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
  105. dfield_set_data(dfield, table->cluster_name,
  106. ut_strlen(table->cluster_name));
  107. ut_error; /* Oracle-style clusters are not supported yet */
  108. } else {
  109. dfield_set_data(dfield, NULL, UNIV_SQL_NULL);
  110. }
  111. /* 9: SPACE ----------------------------*/
  112. dfield = dtuple_get_nth_field(entry, 7);
  114. ptr = mem_heap_alloc(heap, 4);
  115. mach_write_to_4(ptr, table->space);
  117. dfield_set_data(dfield, ptr, 4);
  118. /*----------------------------------*/
  120. dict_table_copy_types(entry, sys_tables);
  122. return(entry);
  123. }
  125. /*********************************************************************
  126. Based on a table object, this function builds the entry to be inserted
  127. in the SYS_COLUMNS system table. */
  128. static
  129. dtuple_t*
  130. dict_create_sys_columns_tuple(
  131. /*==========================*/
  132. /* out: the tuple which should be inserted */
  133. dict_table_t* table,  /* in: table */
  134. ulint i, /* in: column number */
  135. mem_heap_t* heap) /* in: memory heap from which the memory for
  136. the built tuple is allocated */
  137. {
  138. dict_table_t* sys_columns;
  139. dtuple_t* entry;
  140. dict_col_t* column;
  141. dfield_t* dfield;
  142. byte* ptr;
  144. ut_ad(table && heap);
  146. column = dict_table_get_nth_col(table, i);
  148. sys_columns = dict_sys->sys_columns;
  150. entry = dtuple_create(heap, 7 + DATA_N_SYS_COLS);
  152. /* 0: TABLE_ID -----------------------*/
  153. dfield = dtuple_get_nth_field(entry, 0);
  155. ptr = mem_heap_alloc(heap, 8);
  156. mach_write_to_8(ptr, table->id);
  158. dfield_set_data(dfield, ptr, 8);
  159. /* 1: POS ----------------------------*/
  160. dfield = dtuple_get_nth_field(entry, 1);
  162. ptr = mem_heap_alloc(heap, 4);
  163. mach_write_to_4(ptr, i);
  165. dfield_set_data(dfield, ptr, 4);
  166. /* 4: NAME ---------------------------*/
  167. dfield = dtuple_get_nth_field(entry, 2);
  169. dfield_set_data(dfield, column->name, ut_strlen(column->name));
  170. /* 5: MTYPE --------------------------*/
  171. dfield = dtuple_get_nth_field(entry, 3);
  173. ptr = mem_heap_alloc(heap, 4);
  174. mach_write_to_4(ptr, (column->type).mtype);
  176. dfield_set_data(dfield, ptr, 4);
  177. /* 6: PRTYPE -------------------------*/
  178. dfield = dtuple_get_nth_field(entry, 4);
  180. ptr = mem_heap_alloc(heap, 4);
  181. mach_write_to_4(ptr, (column->type).prtype);
  183. dfield_set_data(dfield, ptr, 4);
  184. /* 7: LEN ----------------------------*/
  185. dfield = dtuple_get_nth_field(entry, 5);
  187. ptr = mem_heap_alloc(heap, 4);
  188. mach_write_to_4(ptr, (column->type).len);
  190. dfield_set_data(dfield, ptr, 4);
  191. /* 8: PREC ---------------------------*/
  192. dfield = dtuple_get_nth_field(entry, 6);
  194. ptr = mem_heap_alloc(heap, 4);
  195. mach_write_to_4(ptr, (column->type).prec);
  197. dfield_set_data(dfield, ptr, 4);
  198. /*---------------------------------*/
  200. dict_table_copy_types(entry, sys_columns);
  202. return(entry);
  203. }
  205. /*******************************************************************
  206. Builds a table definition to insert. */
  207. static
  208. ulint
  209. dict_build_table_def_step(
  210. /*======================*/
  211. /* out: DB_SUCCESS or error code */
  212. que_thr_t* thr, /* in: query thread */
  213. tab_node_t* node) /* in: table create node */
  214. {
  215. dict_table_t* table;
  216. dict_table_t* cluster_table;
  217. dtuple_t* row;
  218. ulint error;
  219. const char* path_or_name;
  220. ibool is_path;
  221. mtr_t mtr;
  223. #ifdef UNIV_SYNC_DEBUG
  224. ut_ad(mutex_own(&(dict_sys->mutex)));
  225. #endif /* UNIV_SYNC_DEBUG */
  227. table = node->table;
  229. table->id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
  231. thr_get_trx(thr)->table_id = table->id;
  233. if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
  235. cluster_table = dict_table_get_low(table->cluster_name);
  237. if (cluster_table == NULL) {
  239. return(DB_CLUSTER_NOT_FOUND);
  240. }
  242. /* Inherit space and mix len from the cluster */
  244. table->space = cluster_table->space;
  245. table->mix_len = cluster_table->mix_len;
  247. table->mix_id = dict_hdr_get_new_id(DICT_HDR_MIX_ID);
  248. }
  250. if (srv_file_per_table) {
  251. /* We create a new single-table tablespace for the table.
  252. We initially let it be 4 pages:
  253. - page 0 is the fsp header and an extent descriptor page,
  254. - page 1 is an ibuf bitmap page,
  255. - page 2 is the first inode page,
  256. - page 3 will contain the root of the clustered index of the
  257.   table we create here. */
  259. table->space = 0; /* reset to zero for the call below */
  261. if (table->dir_path_of_temp_table) {
  262. /* We place tables created with CREATE TEMPORARY
  263. TABLE in the tmp dir of mysqld server */
  265. path_or_name = table->dir_path_of_temp_table;
  266. is_path = TRUE;
  267. } else {
  268. path_or_name = table->name;
  269. is_path = FALSE;
  270. }
  272. error = fil_create_new_single_table_tablespace(
  273. &(table->space), path_or_name, is_path,
  274. FIL_IBD_FILE_INITIAL_SIZE);
  275. if (error != DB_SUCCESS) {
  277. return(error);
  278. }
  280. mtr_start(&mtr);
  282. fsp_header_init(table->space, FIL_IBD_FILE_INITIAL_SIZE, &mtr);
  284. mtr_commit(&mtr);
  285. }
  287. row = dict_create_sys_tables_tuple(table, node->heap);
  289. ins_node_set_new_row(node->tab_def, row);
  291. return(DB_SUCCESS);
  292. }
  294. /*******************************************************************
  295. Builds a column definition to insert. */
  296. static
  297. ulint
  298. dict_build_col_def_step(
  299. /*====================*/
  300. /* out: DB_SUCCESS */
  301. tab_node_t* node) /* in: table create node */
  302. {
  303. dtuple_t* row;
  305. row = dict_create_sys_columns_tuple(node->table, node->col_no,
  306. node->heap);
  307. ins_node_set_new_row(node->col_def, row);
  309. return(DB_SUCCESS);
  310. }
  312. /*********************************************************************
  313. Based on an index object, this function builds the entry to be inserted
  314. in the SYS_INDEXES system table. */
  315. static
  316. dtuple_t*
  317. dict_create_sys_indexes_tuple(
  318. /*==========================*/
  319. /* out: the tuple which should be inserted */
  320. dict_index_t* index,  /* in: index */
  321. mem_heap_t* heap) /* in: memory heap from which the memory for
  322. the built tuple is allocated */
  323. {
  324. dict_table_t* sys_indexes;
  325. dict_table_t* table;
  326. dtuple_t* entry;
  327. dfield_t* dfield;
  328. byte* ptr;
  330. #ifdef UNIV_SYNC_DEBUG
  331. ut_ad(mutex_own(&(dict_sys->mutex)));
  332. #endif /* UNIV_SYNC_DEBUG */
  333. ut_ad(index && heap);
  335. sys_indexes = dict_sys->sys_indexes;
  337. table = dict_table_get_low(index->table_name);
  339. entry = dtuple_create(heap, 7 + DATA_N_SYS_COLS);
  341. /* 0: TABLE_ID -----------------------*/
  342. dfield = dtuple_get_nth_field(entry, 0);
  344. ptr = mem_heap_alloc(heap, 8);
  345. mach_write_to_8(ptr, table->id);
  347. dfield_set_data(dfield, ptr, 8);
  348. /* 1: ID ----------------------------*/
  349. dfield = dtuple_get_nth_field(entry, 1);
  351. ptr = mem_heap_alloc(heap, 8);
  352. mach_write_to_8(ptr, index->id);
  354. dfield_set_data(dfield, ptr, 8);
  355. /* 4: NAME --------------------------*/
  356. dfield = dtuple_get_nth_field(entry, 2);
  358. dfield_set_data(dfield, index->name, ut_strlen(index->name));
  359. /* 5: N_FIELDS ----------------------*/
  360. dfield = dtuple_get_nth_field(entry, 3);
  362. ptr = mem_heap_alloc(heap, 4);
  363. mach_write_to_4(ptr, index->n_fields);
  365. dfield_set_data(dfield, ptr, 4);
  366. /* 6: TYPE --------------------------*/
  367. dfield = dtuple_get_nth_field(entry, 4);
  369. ptr = mem_heap_alloc(heap, 4);
  370. mach_write_to_4(ptr, index->type);
  372. dfield_set_data(dfield, ptr, 4);
  373. /* 7: SPACE --------------------------*/
  375. #if DICT_SYS_INDEXES_SPACE_NO_FIELD != 7
  376. #error "DICT_SYS_INDEXES_SPACE_NO_FIELD != 7"
  377. #endif
  379. dfield = dtuple_get_nth_field(entry, 5);
  381. ptr = mem_heap_alloc(heap, 4);
  382. mach_write_to_4(ptr, index->space);
  384. dfield_set_data(dfield, ptr, 4);
  385. /* 8: PAGE_NO --------------------------*/
  387. #if DICT_SYS_INDEXES_PAGE_NO_FIELD != 8
  388. #error "DICT_SYS_INDEXES_PAGE_NO_FIELD != 8"
  389. #endif
  391. dfield = dtuple_get_nth_field(entry, 6);
  393. ptr = mem_heap_alloc(heap, 4);
  394. mach_write_to_4(ptr, FIL_NULL);
  396. dfield_set_data(dfield, ptr, 4);
  397. /*--------------------------------*/
  399. dict_table_copy_types(entry, sys_indexes);
  401. return(entry);
  402. }
  404. /*********************************************************************
  405. Based on an index object, this function builds the entry to be inserted
  406. in the SYS_FIELDS system table. */
  407. static
  408. dtuple_t*
  409. dict_create_sys_fields_tuple(
  410. /*=========================*/
  411. /* out: the tuple which should be inserted */
  412. dict_index_t* index,  /* in: index */
  413. ulint i, /* in: field number */
  414. mem_heap_t* heap) /* in: memory heap from which the memory for
  415. the built tuple is allocated */
  416. {
  417. dict_table_t* sys_fields;
  418. dtuple_t* entry;
  419. dict_field_t* field;
  420. dfield_t* dfield;
  421. byte* ptr;
  422. ibool index_contains_column_prefix_field = FALSE;
  423. ulint j;
  425. ut_ad(index && heap);
  427. for (j = 0; j < index->n_fields; j++) {
  428.         if (dict_index_get_nth_field(index, j)->prefix_len > 0) {
  429.                 index_contains_column_prefix_field = TRUE;    
  430. }
  431. }
  433. field = dict_index_get_nth_field(index, i);
  435. sys_fields = dict_sys->sys_fields;
  437. entry = dtuple_create(heap, 3 + DATA_N_SYS_COLS);
  439. /* 0: INDEX_ID -----------------------*/
  440. dfield = dtuple_get_nth_field(entry, 0);
  442. ptr = mem_heap_alloc(heap, 8);
  443. mach_write_to_8(ptr, index->id);
  445. dfield_set_data(dfield, ptr, 8);
  446. /* 1: POS + PREFIX LENGTH ----------------------------*/
  448. dfield = dtuple_get_nth_field(entry, 1);
  450. ptr = mem_heap_alloc(heap, 4);
  452. if (index_contains_column_prefix_field) {
  453. /* If there are column prefix fields in the index, then
  454. we store the number of the field to the 2 HIGH bytes
  455. and the prefix length to the 2 low bytes, */
  457.         mach_write_to_4(ptr, (i << 16) + field->prefix_len);
  458. } else {
  459.         /* Else we store the number of the field to the 2 LOW bytes.
  460. This is to keep the storage format compatible with
  461. InnoDB versions < 4.0.14. */
  462.   
  463.         mach_write_to_4(ptr, i);
  464. }
  466. dfield_set_data(dfield, ptr, 4);
  467. /* 4: COL_NAME -------------------------*/
  468. dfield = dtuple_get_nth_field(entry, 2);
  470. dfield_set_data(dfield, field->name,
  471. ut_strlen(field->name));
  472. /*---------------------------------*/
  474. dict_table_copy_types(entry, sys_fields);
  476. return(entry);
  477. }
  479. /*********************************************************************
  480. Creates the tuple with which the index entry is searched for writing the index
  481. tree root page number, if such a tree is created. */
  482. static
  483. dtuple_t*
  484. dict_create_search_tuple(
  485. /*=====================*/
  486. /* out: the tuple for search */
  487. dtuple_t* tuple, /* in: the tuple inserted in the SYS_INDEXES
  488. table */
  489. mem_heap_t* heap) /* in: memory heap from which the memory for
  490. the built tuple is allocated */
  491. {
  492. dtuple_t* search_tuple;
  493. dfield_t* field1;
  494. dfield_t* field2;
  496. ut_ad(tuple && heap);
  498. search_tuple = dtuple_create(heap, 2);
  500. field1 = dtuple_get_nth_field(tuple, 0);
  501. field2 = dtuple_get_nth_field(search_tuple, 0);
  503. dfield_copy(field2, field1);
  505. field1 = dtuple_get_nth_field(tuple, 1);
  506. field2 = dtuple_get_nth_field(search_tuple, 1);
  508. dfield_copy(field2, field1);
  510. ut_ad(dtuple_validate(search_tuple));
  512. return(search_tuple);
  513. }
  515. /*******************************************************************
  516. Builds an index definition row to insert. */
  517. static
  518. ulint
  519. dict_build_index_def_step(
  520. /*======================*/
  521. /* out: DB_SUCCESS or error code */
  522. que_thr_t* thr, /* in: query thread */
  523. ind_node_t* node) /* in: index create node */
  524. {
  525. dict_table_t* table;
  526. dict_index_t* index;
  527. dtuple_t* row;
  528. trx_t* trx;
  530. #ifdef UNIV_SYNC_DEBUG
  531. ut_ad(mutex_own(&(dict_sys->mutex)));
  532. #endif /* UNIV_SYNC_DEBUG */
  534. trx = thr_get_trx(thr);
  536. index = node->index;
  538. table = dict_table_get_low(index->table_name);
  540. if (table == NULL) {
  541. return(DB_TABLE_NOT_FOUND);
  542. }
  544. trx->table_id = table->id;
  546. node->table = table;
  548. ut_ad((UT_LIST_GET_LEN(table->indexes) > 0)
  549.       || (index->type & DICT_CLUSTERED));
  551. index->id = dict_hdr_get_new_id(DICT_HDR_INDEX_ID);
  553. /* Inherit the space id from the table; we store all indexes of a
  554. table in the same tablespace */
  556. index->space = table->space;
  558. index->page_no = FIL_NULL;
  560. row = dict_create_sys_indexes_tuple(index, node->heap);
  561. node->ind_row = row;
  563. ins_node_set_new_row(node->ind_def, row);
  565. return(DB_SUCCESS);
  566. }
  568. /*******************************************************************
  569. Builds a field definition row to insert. */
  570. static
  571. ulint
  572. dict_build_field_def_step(
  573. /*======================*/
  574. /* out: DB_SUCCESS */
  575. ind_node_t* node) /* in: index create node */
  576. {
  577. dict_index_t* index;
  578. dtuple_t* row;
  580. index = node->index;
  582. row = dict_create_sys_fields_tuple(index, node->field_no, node->heap);
  584. ins_node_set_new_row(node->field_def, row);
  586. return(DB_SUCCESS);
  587. }
  589. /*******************************************************************
  590. Creates an index tree for the index if it is not a member of a cluster. */
  591. static
  592. ulint
  593. dict_create_index_tree_step(
  594. /*========================*/
  595. /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
  596. ind_node_t* node) /* in: index create node */
  597. {
  598. dict_index_t* index;
  599. dict_table_t* sys_indexes;
  600. dict_table_t* table;
  601. dtuple_t* search_tuple;
  602. btr_pcur_t pcur;
  603. mtr_t mtr;
  605. #ifdef UNIV_SYNC_DEBUG
  606. ut_ad(mutex_own(&(dict_sys->mutex)));
  607. #endif /* UNIV_SYNC_DEBUG */
  609. index = node->index;
  610. table = node->table;
  612. sys_indexes = dict_sys->sys_indexes;
  614. if (index->type & DICT_CLUSTERED
  615. && table->type == DICT_TABLE_CLUSTER_MEMBER) {
  617. /* Do not create a new index tree: entries are put to the
  618. cluster tree */
  620. return(DB_SUCCESS);
  621. }
  623. /* Run a mini-transaction in which the index tree is allocated for
  624. the index and its root address is written to the index entry in
  625. sys_indexes */
  627. mtr_start(&mtr);
  629. search_tuple = dict_create_search_tuple(node->ind_row, node->heap);
  630.     
  631. btr_pcur_open(UT_LIST_GET_FIRST(sys_indexes->indexes),
  632. search_tuple, PAGE_CUR_L, BTR_MODIFY_LEAF,
  633. &pcur, &mtr);
  635. btr_pcur_move_to_next_user_rec(&pcur, &mtr);
  637. index->page_no = btr_create(index->type, index->space, index->id,
  638. &mtr);
  639. /* printf("Created a new index tree in space %lu root page %lun",
  640. index->space, index->page_no); */
  642. page_rec_write_index_page_no(btr_pcur_get_rec(&pcur),
  643. DICT_SYS_INDEXES_PAGE_NO_FIELD,
  644. index->page_no, &mtr);
  645. btr_pcur_close(&pcur);
  646. mtr_commit(&mtr);
  648. if (index->page_no == FIL_NULL) {
  650. return(DB_OUT_OF_FILE_SPACE);
  651. }
  653. return(DB_SUCCESS);
  654. }
  656. /***********************************************************************
  657. Drops the index tree associated with a row in SYS_INDEXES table. */
  659. void
  660. dict_drop_index_tree(
  661. /*=================*/
  662. rec_t* rec, /* in: record in the clustered index of SYS_INDEXES
  663. table */
  664. mtr_t* mtr) /* in: mtr having the latch on the record page */
  665. {
  666. ulint root_page_no;
  667. ulint space;
  668. byte* ptr;
  669. ulint len;
  671. #ifdef UNIV_SYNC_DEBUG
  672. ut_ad(mutex_own(&(dict_sys->mutex)));
  673. #endif /* UNIV_SYNC_DEBUG */
  675. ptr = rec_get_nth_field(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD, &len);
  677. ut_ad(len == 4);
  679. root_page_no = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);
  681. if (root_page_no == FIL_NULL) {
  682. /* The tree has already been freed */
  684. return;
  685. }
  687. ptr = rec_get_nth_field(rec, DICT_SYS_INDEXES_SPACE_NO_FIELD, &len);
  689. ut_ad(len == 4);
  691. space = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);
  693. if (!fil_tablespace_exists_in_mem(space)) {
  694. /* It is a single table tablespace and the .ibd file is
  695. missing: do nothing */
  697. return;
  698. }
  700. /* We free all the pages but the root page first; this operation
  701. may span several mini-transactions */
  703. btr_free_but_not_root(space, root_page_no);
  705. /* Then we free the root page in the same mini-transaction where
  706. we write FIL_NULL to the appropriate field in the SYS_INDEXES
  707. record: this mini-transaction marks the B-tree totally freed */
  709. /* printf("Dropping index tree in space %lu root page %lun", space,
  710.  root_page_no); */
  711. btr_free_root(space, root_page_no, mtr);
  713. page_rec_write_index_page_no(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD,
  714. FIL_NULL, mtr);
  715. }
  717. /*************************************************************************
  718. Creates a table create graph. */
  720. tab_node_t*
  721. tab_create_graph_create(
  722. /*====================*/
  723. /* out, own: table create node */
  724. dict_table_t* table, /* in: table to create, built as a memory data
  725. structure */
  726. mem_heap_t* heap) /* in: heap where created */
  727. {
  728. tab_node_t* node;
  730. node = mem_heap_alloc(heap, sizeof(tab_node_t));
  732. node->common.type = QUE_NODE_CREATE_TABLE;
  734. node->table = table;
  736. node->state = TABLE_BUILD_TABLE_DEF;
  737. node->heap = mem_heap_create(256);
  739. node->tab_def = ins_node_create(INS_DIRECT, dict_sys->sys_tables,
  740. heap); 
  741. node->tab_def->common.parent = node;
  743. node->col_def = ins_node_create(INS_DIRECT, dict_sys->sys_columns,
  744. heap);
  745. node->col_def->common.parent = node;
  747. node->commit_node = commit_node_create(heap);
  748. node->commit_node->common.parent = node;
  750. return(node);
  751. }
  753. /*************************************************************************
  754. Creates an index create graph. */
  756. ind_node_t*
  757. ind_create_graph_create(
  758. /*====================*/
  759. /* out, own: index create node */
  760. dict_index_t* index, /* in: index to create, built as a memory data
  761. structure */
  762. mem_heap_t* heap) /* in: heap where created */
  763. {
  764. ind_node_t* node;
  766. node = mem_heap_alloc(heap, sizeof(ind_node_t));
  768. node->common.type = QUE_NODE_CREATE_INDEX;
  770. node->index = index;
  772. node->state = INDEX_BUILD_INDEX_DEF;
  773. node->heap = mem_heap_create(256);
  775. node->ind_def = ins_node_create(INS_DIRECT,
  776. dict_sys->sys_indexes, heap); 
  777. node->ind_def->common.parent = node;
  779. node->field_def = ins_node_create(INS_DIRECT,
  780. dict_sys->sys_fields, heap);
  781. node->field_def->common.parent = node;
  783. node->commit_node = commit_node_create(heap);
  784. node->commit_node->common.parent = node;
  786. return(node);
  787. }
  789. /***************************************************************
  790. Creates a table. This is a high-level function used in SQL execution graphs. */
  792. que_thr_t*
  793. dict_create_table_step(
  794. /*===================*/
  795. /* out: query thread to run next or NULL */
  796. que_thr_t* thr) /* in: query thread */
  797. {
  798. tab_node_t* node;
  799. ulint err = DB_ERROR;
  800. trx_t* trx;
  802. ut_ad(thr);
  803. #ifdef UNIV_SYNC_DEBUG
  804. ut_ad(mutex_own(&(dict_sys->mutex)));
  805. #endif /* UNIV_SYNC_DEBUG */
  807. trx = thr_get_trx(thr);
  809. node = thr->run_node;
  811. ut_ad(que_node_get_type(node) == QUE_NODE_CREATE_TABLE);
  813. if (thr->prev_node == que_node_get_parent(node)) {
  814. node->state = TABLE_BUILD_TABLE_DEF;
  815. }
  817. if (node->state == TABLE_BUILD_TABLE_DEF) {
  819. /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
  821. err = dict_build_table_def_step(thr, node);
  823. if (err != DB_SUCCESS) {
  825. goto function_exit;
  826. }
  828. node->state = TABLE_BUILD_COL_DEF;
  829. node->col_no = 0;
  831. thr->run_node = node->tab_def;
  833. return(thr);
  834. }
  836. if (node->state == TABLE_BUILD_COL_DEF) {
  838. if (node->col_no < (node->table)->n_def) {
  840. err = dict_build_col_def_step(node);
  842. if (err != DB_SUCCESS) {
  844. goto function_exit;
  845. }
  847. node->col_no++;
  849. thr->run_node = node->col_def;
  851. return(thr);
  852. } else {
  853. node->state = TABLE_COMMIT_WORK;
  854. }
  855. }
  857. if (node->state == TABLE_COMMIT_WORK) {
  859. /* Table was correctly defined: do NOT commit the transaction
  860. (CREATE TABLE does NOT do an implicit commit of the current
  861. transaction) */
  863. node->state = TABLE_ADD_TO_CACHE;
  865. /* thr->run_node = node->commit_node;
  867. return(thr); */
  868. }
  870. if (node->state == TABLE_ADD_TO_CACHE) {
  872. dict_table_add_to_cache(node->table);
  874. err = DB_SUCCESS;
  875. }
  877. function_exit:
  878. trx->error_state = err;
  880. if (err == DB_SUCCESS) {
  881. /* Ok: do nothing */
  883. } else if (err == DB_LOCK_WAIT) {
  885. return(NULL);
  886. } else {
  887. /* SQL error detected */
  889. return(NULL);
  890. }
  892. thr->run_node = que_node_get_parent(node);
  894. return(thr);
  895. } 
  897. /***************************************************************
  898. Creates an index. This is a high-level function used in SQL execution
  899. graphs. */
  901. que_thr_t*
  902. dict_create_index_step(
  903. /*===================*/
  904. /* out: query thread to run next or NULL */
  905. que_thr_t* thr) /* in: query thread */
  906. {
  907. ind_node_t* node;
  908. ibool success;
  909. ulint err = DB_ERROR;
  910. trx_t* trx;
  912. ut_ad(thr);
  913. #ifdef UNIV_SYNC_DEBUG
  914. ut_ad(mutex_own(&(dict_sys->mutex)));
  915. #endif /* UNIV_SYNC_DEBUG */
  917. trx = thr_get_trx(thr);
  919. node = thr->run_node;
  921. ut_ad(que_node_get_type(node) == QUE_NODE_CREATE_INDEX);
  923. if (thr->prev_node == que_node_get_parent(node)) {
  924. node->state = INDEX_BUILD_INDEX_DEF;
  925. }
  927. if (node->state == INDEX_BUILD_INDEX_DEF) {
  928. /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
  929. err = dict_build_index_def_step(thr, node);
  931. if (err != DB_SUCCESS) {
  933. goto function_exit;
  934. }
  936. node->state = INDEX_BUILD_FIELD_DEF;
  937. node->field_no = 0;
  939. thr->run_node = node->ind_def;
  941. return(thr);
  942. }
  944. if (node->state == INDEX_BUILD_FIELD_DEF) {
  946. if (node->field_no < (node->index)->n_fields) {
  948. err = dict_build_field_def_step(node);
  950. if (err != DB_SUCCESS) {
  952. goto function_exit;
  953. }
  955. node->field_no++;
  957. thr->run_node = node->field_def;
  959. return(thr);
  960. } else {
  961. node->state = INDEX_CREATE_INDEX_TREE;
  962. }
  963. }
  965. if (node->state == INDEX_CREATE_INDEX_TREE) {
  967. err = dict_create_index_tree_step(node);
  969. if (err != DB_SUCCESS) {
  971. goto function_exit;
  972. }
  974. node->state = INDEX_COMMIT_WORK;
  975. }
  977. if (node->state == INDEX_COMMIT_WORK) {
  979. /* Index was correctly defined: do NOT commit the transaction
  980. (CREATE INDEX does NOT currently do an implicit commit of
  981. the current transaction) */
  983. node->state = INDEX_ADD_TO_CACHE;
  985. /* thr->run_node = node->commit_node;
  987. return(thr); */
  988. }
  990. if (node->state == INDEX_ADD_TO_CACHE) {
  992. success = dict_index_add_to_cache(node->table, node->index);
  994. ut_a(success);
  996. err = DB_SUCCESS;
  997. }
  999. function_exit:
  1000. trx->error_state = err;
  1002. if (err == DB_SUCCESS) {
  1003. /* Ok: do nothing */
  1005. } else if (err == DB_LOCK_WAIT) {
  1007. return(NULL);
  1008. } else {
  1009. /* SQL error detected */
  1011. return(NULL);
  1012. }
  1014. thr->run_node = que_node_get_parent(node);
  1016. return(thr);
  1017. } 
  1019. /********************************************************************
  1020. Creates the foreign key constraints system tables inside InnoDB
  1021. at database creation or database start if they are not found or are
  1022. not of the right form. */
  1024. ulint
  1025. dict_create_or_check_foreign_constraint_tables(void)
  1026. /*================================================*/
  1027. /* out: DB_SUCCESS or error code */
  1028. {
  1029. dict_table_t* table1;
  1030. dict_table_t* table2;
  1031. que_thr_t* thr;
  1032. que_t* graph;
  1033. ulint error;
  1034. trx_t* trx;
  1035. const char* str;
  1037. mutex_enter(&(dict_sys->mutex));
  1039. table1 = dict_table_get_low("SYS_FOREIGN");
  1040. table2 = dict_table_get_low("SYS_FOREIGN_COLS");
  1042. if (table1 && table2
  1043.             && UT_LIST_GET_LEN(table1->indexes) == 3
  1044.             && UT_LIST_GET_LEN(table2->indexes) == 1) {
  1046.              /* Foreign constraint system tables have already been
  1047.              created, and they are ok */
  1049. mutex_exit(&(dict_sys->mutex));
  1051.              return(DB_SUCCESS);
  1052.         }
  1054. mutex_exit(&(dict_sys->mutex));
  1056. trx = trx_allocate_for_mysql();
  1058. trx->op_info = "creating foreign key sys tables";
  1060. row_mysql_lock_data_dictionary(trx);
  1062. if (table1) {
  1063. fprintf(stderr,
  1064. "InnoDB: dropping incompletely created SYS_FOREIGN tablen");
  1065. row_drop_table_for_mysql("SYS_FOREIGN", trx, TRUE);
  1066. }
  1068. if (table2) {
  1069. fprintf(stderr,
  1070. "InnoDB: dropping incompletely created SYS_FOREIGN_COLS tablen");
  1071. row_drop_table_for_mysql("SYS_FOREIGN_COLS", trx, TRUE);
  1072. }
  1074. fprintf(stderr,
  1075. "InnoDB: Creating foreign key constraint system tablesn");
  1077. /* NOTE: in dict_load_foreigns we use the fact that
  1078. there are 2 secondary indexes on SYS_FOREIGN, and they
  1079. are defined just like below */
  1081. /* NOTE: when designing InnoDB's foreign key support in 2001, we made
  1082. an error and made the table names and the foreign key id of type
  1083. 'CHAR' (internally, really a VARCHAR). We should have made the type
  1084. VARBINARY, like in other InnoDB system tables, to get a clean
  1085. design. */
  1087. str =
  1088. "PROCEDURE CREATE_FOREIGN_SYS_TABLES_PROC () ISn"
  1089. "BEGINn"
  1090. "CREATE TABLEn"
  1091. "SYS_FOREIGN(ID CHAR, FOR_NAME CHAR, REF_NAME CHAR, N_COLS INT);n"
  1092. "CREATE UNIQUE CLUSTERED INDEX ID_IND ON SYS_FOREIGN (ID);n"
  1093. "CREATE INDEX FOR_IND ON SYS_FOREIGN (FOR_NAME);n"
  1094. "CREATE INDEX REF_IND ON SYS_FOREIGN (REF_NAME);n"
  1095. "CREATE TABLEn"
  1096.   "SYS_FOREIGN_COLS(ID CHAR, POS INT, FOR_COL_NAME CHAR, REF_COL_NAME CHAR);n"
  1097. "CREATE UNIQUE CLUSTERED INDEX ID_IND ON SYS_FOREIGN_COLS (ID, POS);n"
  1098. "COMMIT WORK;n"
  1099. "END;n";
  1101. graph = pars_sql(str);
  1103. ut_a(graph);
  1105. graph->trx = trx;
  1106. trx->graph = NULL;
  1108. graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
  1110. ut_a(thr = que_fork_start_command(graph));
  1112. que_run_threads(thr);
  1114. error = trx->error_state;
  1116. if (error != DB_SUCCESS) {
  1117. fprintf(stderr, "InnoDB: error %lu in creationn",
  1118. (ulong) error);
  1120. ut_a(error == DB_OUT_OF_FILE_SPACE);
  1122. fprintf(stderr, "InnoDB: creation failedn");
  1123. fprintf(stderr, "InnoDB: tablespace is fulln");
  1124. fprintf(stderr,
  1125. "InnoDB: dropping incompletely created SYS_FOREIGN tablesn");
  1127. row_drop_table_for_mysql("SYS_FOREIGN", trx, TRUE);
  1128. row_drop_table_for_mysql("SYS_FOREIGN_COLS", trx, TRUE);
  1130. error = DB_MUST_GET_MORE_FILE_SPACE;
  1131. }
  1133. que_graph_free(graph);
  1135. trx->op_info = "";
  1137. row_mysql_unlock_data_dictionary(trx);
  1139.    trx_free_for_mysql(trx);
  1141.    if (error == DB_SUCCESS) {
  1142. fprintf(stderr,
  1143. "InnoDB: Foreign key constraint system tables createdn");
  1144. }
  1146. return(error);
  1147. }
  1149. /************************************************************************
  1150. Adds foreign key definitions to data dictionary tables in the database. We
  1151. look at table->foreign_list, and also generate names to constraints that were
  1152. not named by the user. A generated constraint has a name of the format
  1153. databasename/tablename_ibfk_<number>, where the numbers start from 1, and are
  1154. given locally for this table, that is, the number is not global, as in the
  1155. old format constraints < 4.0.18 it used to be. */
  1157. ulint
  1158. dict_create_add_foreigns_to_dictionary(
  1159. /*===================================*/
  1160. /* out: error code or DB_SUCCESS */
  1161. ulint start_id,/* in: if we are actually doing ALTER TABLE
  1162. ADD CONSTRAINT, we want to generate constraint
  1163. numbers which are bigger than in the table so
  1164. far; we number the constraints from
  1165. start_id + 1 up; start_id should be set to 0 if
  1166. we are creating a new table, or if the table
  1167. so far has no constraints for which the name
  1168. was generated here */
  1169. dict_table_t* table, /* in: table */
  1170. trx_t* trx) /* in: transaction */
  1171. {
  1172. dict_foreign_t* foreign;
  1173. que_thr_t* thr;
  1174. que_t* graph;
  1175. ulint number = start_id + 1;
  1176. ulint len;
  1177. ulint error;
  1178. FILE* ef = dict_foreign_err_file;
  1179. ulint i;
  1180. char* sql;
  1181. char* sqlend;
  1182. /* This procedure builds an InnoDB stored procedure which will insert
  1183. the necessary rows into SYS_FOREIGN and SYS_FOREIGN_COLS. */
  1184. static const char str1[] = "PROCEDURE ADD_FOREIGN_DEFS_PROC () ISn"
  1185. "BEGINn"
  1186. "INSERT INTO SYS_FOREIGN VALUES(";
  1187. static const char str2[] = ");n";
  1188. static const char str3[] =
  1189. "INSERT INTO SYS_FOREIGN_COLS VALUES(";
  1190. static const char str4[] =
  1191. "COMMIT WORK;n"
  1192. "END;n";
  1194. #ifdef UNIV_SYNC_DEBUG
  1195. ut_ad(mutex_own(&(dict_sys->mutex)));
  1196. #endif /* UNIV_SYNC_DEBUG */
  1198. if (NULL == dict_table_get_low("SYS_FOREIGN")) {
  1199. fprintf(stderr,
  1200.      "InnoDB: table SYS_FOREIGN not found from internal data dictionaryn");
  1202. return(DB_ERROR);
  1203. }
  1205. foreign = UT_LIST_GET_FIRST(table->foreign_list);
  1206. loop:
  1207. if (foreign == NULL) {
  1209. return(DB_SUCCESS);
  1210. }
  1212. if (foreign->id == NULL) {
  1213. /* Generate a new constraint id */
  1214. ulint namelen = strlen(table->name);
  1215. char* id = mem_heap_alloc(foreign->heap, namelen + 20);
  1216. /* no overflow if number < 1e13 */
  1217. sprintf(id, "%s_ibfk_%lu", table->name, (ulong) number++);
  1218. foreign->id = id;
  1219. }
  1221. len = (sizeof str1) + (sizeof str2) + (sizeof str4) - 3
  1222. + 9/* ' and , chars */ + 10/* 32-bit integer */
  1223. + ut_strlenq(foreign->id, ''') * (foreign->n_fields + 1)
  1224. + ut_strlenq(table->name, ''')
  1225. + ut_strlenq(foreign->referenced_table_name, ''');
  1227. for (i = 0; i < foreign->n_fields; i++) {
  1228. len += 9/* ' and , chars */ + 10/* 32-bit integer */
  1229. + (sizeof str3) + (sizeof str2) - 2
  1230. + ut_strlenq(foreign->foreign_col_names[i], ''')
  1231. + ut_strlenq(foreign->referenced_col_names[i], ''');
  1232. }
  1234. sql = sqlend = mem_alloc(len + 1);
  1236. /* INSERT INTO SYS_FOREIGN VALUES(...); */
  1237. memcpy(sqlend, str1, (sizeof str1) - 1);
  1238. sqlend += (sizeof str1) - 1;
  1239. *sqlend++ = ''';
  1240. sqlend = ut_strcpyq(sqlend, ''', foreign->id);
  1241. *sqlend++ = ''', *sqlend++ = ',', *sqlend++ = ''';
  1242. sqlend = ut_strcpyq(sqlend, ''', table->name);
  1243. *sqlend++ = ''', *sqlend++ = ',', *sqlend++ = ''';
  1244. sqlend = ut_strcpyq(sqlend, ''', foreign->referenced_table_name);
  1245. *sqlend++ = ''', *sqlend++ = ',';
  1246. sqlend += sprintf(sqlend, "%010lu",
  1247. foreign->n_fields + (foreign->type << 24));
  1248. memcpy(sqlend, str2, (sizeof str2) - 1);
  1249. sqlend += (sizeof str2) - 1;
  1251. for (i = 0; i < foreign->n_fields; i++) {
  1252. /* INSERT INTO SYS_FOREIGN_COLS VALUES(...); */
  1253. memcpy(sqlend, str3, (sizeof str3) - 1);
  1254. sqlend += (sizeof str3) - 1;
  1255. *sqlend++ = ''';
  1256. sqlend = ut_strcpyq(sqlend, ''', foreign->id);
  1257. *sqlend++ = '''; *sqlend++ = ',';
  1258. sqlend += sprintf(sqlend, "%010lu", (ulong) i);
  1259. *sqlend++ = ','; *sqlend++ = ''';
  1260. sqlend = ut_strcpyq(sqlend, ''',
  1261. foreign->foreign_col_names[i]);
  1262. *sqlend++ = '''; *sqlend++ = ','; *sqlend++ = ''';
  1263. sqlend = ut_strcpyq(sqlend, ''',
  1264. foreign->referenced_col_names[i]);
  1265. *sqlend++ = ''';
  1266. memcpy(sqlend, str2, (sizeof str2) - 1);
  1267. sqlend += (sizeof str2) - 1;
  1268. }
  1270. memcpy(sqlend, str4, sizeof str4);
  1271. sqlend += sizeof str4;
  1273. ut_a(sqlend == sql + len + 1);
  1275. graph = pars_sql(sql);
  1277. ut_a(graph);
  1279. mem_free(sql);
  1281. graph->trx = trx;
  1282. trx->graph = NULL;
  1284. graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
  1286. ut_a(thr = que_fork_start_command(graph));
  1288. que_run_threads(thr);
  1290. error = trx->error_state;
  1292. que_graph_free(graph);
  1294. if (error == DB_DUPLICATE_KEY) {
  1295. mutex_enter(&dict_foreign_err_mutex);
  1296. rewind(ef);
  1297. ut_print_timestamp(ef);
  1298. fputs(" Error in foreign key constraint creation for table ",
  1299. ef);
  1300. ut_print_name(ef, trx, table->name);
  1301. fputs(".nA foreign key constraint of name ", ef);
  1302. ut_print_name(ef, trx, foreign->id);
  1303. fputs("nalready exists."
  1304. " (Note that internally InnoDB adds 'databasename/'n"
  1305. "in front of the user-defined constraint name).n",
  1306. ef);
  1307. fputs("Note that InnoDB's FOREIGN KEY system tables storen"
  1308.       "constraint names as case-insensitive, with then"
  1309.       "MySQL standard latin1_swedish_ci collation. If youn"
  1310.       "create tables or databases whose names differ only inn"
  1311.       "the character case, then collisions in constraintn"
  1312.       "names can occur. Workaround: name your constraintsn"
  1313.       "explicitly with unique names.n",
  1314. ef);
  1316. mutex_exit(&dict_foreign_err_mutex);
  1318. return(error);
  1319. }
  1321. if (error != DB_SUCCESS) {
  1322.         fprintf(stderr,
  1323. "InnoDB: Foreign key constraint creation failed:n"
  1324. "InnoDB: internal error number %lun", (ulong) error);
  1326. mutex_enter(&dict_foreign_err_mutex);
  1327. ut_print_timestamp(ef);
  1328. fputs(" Internal error in foreign key constraint creation"
  1329. " for table ", ef);
  1330. ut_print_name(ef, trx, table->name);
  1331. fputs(".n"
  1332. "See the MySQL .err log in the datadir for more information.n", ef);
  1333. mutex_exit(&dict_foreign_err_mutex);
  1335. return(error);
  1336. }
  1338. foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
  1340. goto loop;
  1341. }