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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
row0mysql.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：26k
源码类别：

MySQL数据库

开发平台：

Visual C++

row0mysql.c：源码内容
  1. /******************************************************
  2. Interface between Innobase row operations and MySQL.
  3. Contains also create table and other data dictionary operations.
  5. (c) 2000 Innobase Oy
  7. Created 9/17/2000 Heikki Tuuri
  8. *******************************************************/
  10. #include "row0mysql.h"
  12. #ifdef UNIV_NONINL
  13. #include "row0mysql.ic"
  14. #endif
  16. #include "row0ins.h"
  17. #include "row0sel.h"
  18. #include "row0upd.h"
  19. #include "row0row.h"
  20. #include "que0que.h"
  21. #include "pars0pars.h"
  22. #include "dict0dict.h"
  23. #include "dict0crea.h"
  24. #include "trx0roll.h"
  25. #include "trx0purge.h"
  26. #include "lock0lock.h"
  28. /***********************************************************************
  29. Reads a MySQL format variable-length field (like VARCHAR) length and
  30. returns pointer to the field data. */
  32. byte*
  33. row_mysql_read_var_ref_noninline(
  34. /*=============================*/
  35. /* out: field + 2 */
  36. ulint* len, /* out: variable-length field length */
  37. byte* field) /* in: field */
  38. {
  39. return(row_mysql_read_var_ref(len, field));
  40. }
  42. /***********************************************************************
  43. Stores a reference to a BLOB in the MySQL format. */
  45. void
  46. row_mysql_store_blob_ref(
  47. /*=====================*/
  48. byte* dest, /* in: where to store */
  49. ulint col_len, /* in: dest buffer size: determines into
  50. how many bytes the BLOB length is stored,
  51. this may vary from 1 to 4 bytes */
  52. byte* data, /* in: BLOB data */
  53. ulint len) /* in: BLOB length */
  54. {
  55. /* In dest there are 1 - 4 bytes reserved for the BLOB length,
  56. and after that 8 bytes reserved for the pointer to the data.
  57. In 32-bit architectures we only use the first 4 bytes of the pointer
  58. slot. */
  60. mach_write_to_n_little_endian(dest, col_len - 8, len);
  62. ut_memcpy(dest + col_len - 8, (byte*)&data, sizeof(byte*));
  63. }
  65. /***********************************************************************
  66. Reads a reference to a BLOB in the MySQL format. */
  68. byte*
  69. row_mysql_read_blob_ref(
  70. /*====================*/
  71. /* out: pointer to BLOB data */
  72. ulint* len, /* out: BLOB length */
  73. byte* ref, /* in: BLOB reference in the MySQL format */
  74. ulint col_len) /* in: BLOB reference length (not BLOB
  75. length) */
  76. {
  77. byte* data;
  79. *len = mach_read_from_n_little_endian(ref, col_len - 8);
  81. ut_memcpy((byte*)&data, ref + col_len - 8, sizeof(byte*));
  83. return(data);
  84. }
  86. /******************************************************************
  87. Convert a row in the MySQL format to a row in the Innobase format. */
  88. static
  89. void
  90. row_mysql_convert_row_to_innobase(
  91. /*==============================*/
  92. dtuple_t* row, /* in/out: Innobase row where the
  93. field type information is already
  94. copied there, or will be copied
  95. later */
  96. row_prebuilt_t* prebuilt, /* in: prebuilt struct where template
  97. must be of type ROW_MYSQL_WHOLE_ROW */
  98. byte* mysql_rec) /* in: row in the MySQL format;
  99. NOTE: do not discard as long as
  100. row is used, as row may contain
  101. pointers to this record! */
  102. {
  103. mysql_row_templ_t* templ;
  104. dfield_t* dfield;
  105. ulint i;
  107. ut_ad(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);
  108. ut_ad(prebuilt->mysql_template);
  110. for (i = 0; i < prebuilt->n_template; i++) {
  112. templ = prebuilt->mysql_template + i;
  113. dfield = dtuple_get_nth_field(row, i);
  115. if (templ->mysql_null_bit_mask != 0) {
  116. /* Column may be SQL NULL */
  118. if (mysql_rec[templ->mysql_null_byte_offset] &
  119.   (byte) (templ->mysql_null_bit_mask)) {
  121. /* It is SQL NULL */
  123. dfield_set_data(dfield, NULL, UNIV_SQL_NULL);
  125. goto next_column;
  126. }
  127. }
  129. row_mysql_store_col_in_innobase_format(dfield,
  130. prebuilt->ins_upd_rec_buff
  131. + templ->mysql_col_offset,
  132. mysql_rec + templ->mysql_col_offset,
  133. templ->mysql_col_len,
  134. templ->type, templ->is_unsigned);
  135. next_column:
  136. ;
  137. } 
  138. }
  140. /********************************************************************
  141. Handles user errors and lock waits detected by the database engine. */
  143. ibool
  144. row_mysql_handle_errors(
  145. /*====================*/
  146. /* out: TRUE if it was a lock wait and
  147. we should continue running the query thread */
  148. ulint* new_err,/* out: possible new error encountered in
  149. rollback, or the old error which was
  150. during the function entry */
  151. trx_t* trx, /* in: transaction */
  152. que_thr_t* thr, /* in: query thread */
  153. trx_savept_t* savept) /* in: savepoint */
  154. {
  155. ibool timeout_expired;
  156. ulint err;
  158. handle_new_error:
  159. err = trx->error_state;
  161. ut_a(err != DB_SUCCESS);
  163. trx->error_state = DB_SUCCESS;
  165. if (err == DB_DUPLICATE_KEY) {
  166. if (savept) {
  167. /* Roll back the latest, possibly incomplete
  168. insertion or update */
  170. trx_general_rollback_for_mysql(trx, TRUE, savept);
  171. }
  172. } else if (err == DB_TOO_BIG_RECORD) {
  173. if (savept) {
  174. /* Roll back the latest, possibly incomplete
  175. insertion or update */
  177. trx_general_rollback_for_mysql(trx, TRUE, savept);
  178. }
  179. } else if (err == DB_LOCK_WAIT) {
  181. timeout_expired = srv_suspend_mysql_thread(thr);
  183. if (timeout_expired) {
  184. trx->error_state = DB_DEADLOCK;
  186. que_thr_stop_for_mysql(thr);
  188. goto handle_new_error;
  189. }
  191. *new_err = err;
  193. return(TRUE);
  195. } else if (err == DB_DEADLOCK) {
  197. /* Roll back the whole transaction */
  199. trx_general_rollback_for_mysql(trx, FALSE, NULL);
  201. } else if (err == DB_OUT_OF_FILE_SPACE) {
  203. /* Roll back the whole transaction */
  205. trx_general_rollback_for_mysql(trx, FALSE, NULL);
  206. } else if (err == DB_MUST_GET_MORE_FILE_SPACE) {
  208. ut_a(0); /* TODO: print something to MySQL error log */
  209. } else {
  210. ut_a(0);
  211. }
  213. if (trx->error_state != DB_SUCCESS) {
  214. *new_err = trx->error_state;
  215. } else {
  216. *new_err = err;
  217. }
  219. trx->error_state = DB_SUCCESS;
  221. return(FALSE);
  222. }
  224. /************************************************************************
  225. Create a prebuilt struct for a MySQL table handle. */
  227. row_prebuilt_t*
  228. row_create_prebuilt(
  229. /*================*/
  230. /* out, own: a prebuilt struct */
  231. dict_table_t* table) /* in: Innobase table handle */
  232. {
  233. row_prebuilt_t* prebuilt;
  234. mem_heap_t* heap;
  235. dict_index_t* clust_index;
  236. dtuple_t* ref;
  237. ulint ref_len;
  238. ulint i;
  240. heap = mem_heap_create(128);
  242. prebuilt = mem_heap_alloc(heap, sizeof(row_prebuilt_t));
  244. prebuilt->table = table;
  246. prebuilt->trx = NULL;
  248. prebuilt->sql_stat_start = TRUE;
  250. prebuilt->index = NULL;
  251. prebuilt->n_template = 0;
  252. prebuilt->mysql_template = NULL;
  254. prebuilt->heap = heap;
  255. prebuilt->ins_node = NULL;
  257. prebuilt->ins_upd_rec_buff = NULL;
  259. prebuilt->upd_node = NULL;
  260. prebuilt->ins_graph = NULL;
  261. prebuilt->upd_graph = NULL;
  263.    prebuilt->pcur = btr_pcur_create_for_mysql();
  264.    prebuilt->clust_pcur = btr_pcur_create_for_mysql();
  266. prebuilt->select_lock_type = LOCK_NONE;
  268. prebuilt->sel_graph = NULL;
  270. prebuilt->search_tuple = dtuple_create(heap,
  271. dict_table_get_n_cols(table));
  273. clust_index = dict_table_get_first_index(table);
  275. ref_len = dict_index_get_n_unique(clust_index);
  277. ref = dtuple_create(heap, ref_len);
  279. dict_index_copy_types(ref, clust_index, ref_len);
  281. prebuilt->clust_ref = ref;
  283. for (i = 0; i < MYSQL_FETCH_CACHE_SIZE; i++) {
  284. prebuilt->fetch_cache[i] = NULL;
  285. }
  287. prebuilt->n_fetch_cached = 0;
  289. prebuilt->blob_heap = NULL;
  291. prebuilt->old_vers_heap = NULL;
  293. return(prebuilt);
  294. }
  296. /************************************************************************
  297. Free a prebuilt struct for a MySQL table handle. */
  299. void
  300. row_prebuilt_free(
  301. /*==============*/
  302. row_prebuilt_t* prebuilt) /* in, own: prebuilt struct */
  303. {
  304. ulint i;
  306. btr_pcur_free_for_mysql(prebuilt->pcur);
  307. btr_pcur_free_for_mysql(prebuilt->clust_pcur);
  309. if (prebuilt->mysql_template) {
  310. mem_free(prebuilt->mysql_template);
  311. }
  313. if (prebuilt->ins_graph) {
  314. que_graph_free_recursive(prebuilt->ins_graph);
  315. }
  317. if (prebuilt->sel_graph) {
  318. que_graph_free_recursive(prebuilt->sel_graph);
  319. }
  321. if (prebuilt->upd_graph) {
  322. que_graph_free_recursive(prebuilt->upd_graph);
  323. }
  325. if (prebuilt->blob_heap) {
  326. mem_heap_free(prebuilt->blob_heap);
  327. }
  329. if (prebuilt->old_vers_heap) {
  330. mem_heap_free(prebuilt->old_vers_heap);
  331. }
  333. for (i = 0; i < MYSQL_FETCH_CACHE_SIZE; i++) {
  334. if (prebuilt->fetch_cache[i] != NULL) {
  335. mem_free(prebuilt->fetch_cache[i]);
  336. }
  337. }
  339. mem_heap_free(prebuilt->heap);
  340. }
  342. /*************************************************************************
  343. Updates the transaction pointers in query graphs stored in the prebuilt
  344. struct. */
  346. void
  347. row_update_prebuilt_trx(
  348. /*====================*/
  349. /* out: prebuilt dtuple */
  350. row_prebuilt_t* prebuilt, /* in: prebuilt struct in MySQL
  351. handle */
  352. trx_t* trx) /* in: transaction handle */
  353. {
  354. prebuilt->trx = trx;
  356. if (prebuilt->ins_graph) {
  357. prebuilt->ins_graph->trx = trx;
  358. }
  360. if (prebuilt->upd_graph) {
  361. prebuilt->upd_graph->trx = trx;
  362. }
  364. if (prebuilt->sel_graph) {
  365. prebuilt->sel_graph->trx = trx;
  366. }
  367. }
  369. /*************************************************************************
  370. Gets pointer to a prebuilt dtuple used in insertions. If the insert graph
  371. has not yet been built in the prebuilt struct, then this function first
  372. builds it. */
  373. static
  374. dtuple_t*
  375. row_get_prebuilt_insert_row(
  376. /*========================*/
  377. /* out: prebuilt dtuple */
  378. row_prebuilt_t* prebuilt) /* in: prebuilt struct in MySQL
  379. handle */
  380. {
  381. ins_node_t* node;
  382. dtuple_t* row;
  383. dict_table_t* table = prebuilt->table;
  385. ut_ad(prebuilt && table && prebuilt->trx);
  387. if (prebuilt->ins_node == NULL) {
  389. /* Not called before for this handle: create an insert node
  390. and query graph to the prebuilt struct */
  392. node = ins_node_create(INS_DIRECT, table, prebuilt->heap);
  394. prebuilt->ins_node = node;
  396. if (prebuilt->ins_upd_rec_buff == NULL) {
  397. prebuilt->ins_upd_rec_buff = mem_heap_alloc(
  398. prebuilt->heap,
  399. prebuilt->mysql_row_len);
  400. }
  402. row = dtuple_create(prebuilt->heap,
  403. dict_table_get_n_cols(table));
  405. dict_table_copy_types(row, table);
  407. ins_node_set_new_row(node, row);
  409. prebuilt->ins_graph =
  410. que_node_get_parent(
  411. pars_complete_graph_for_exec(node,
  412. prebuilt->trx,
  413. prebuilt->heap));
  414. prebuilt->ins_graph->state = QUE_FORK_ACTIVE;
  415. }
  417. return(prebuilt->ins_node->row);
  418. }
  420. /*************************************************************************
  421. Updates the table modification counter and calculates new estimates
  422. for table and index statistics if necessary. */
  423. UNIV_INLINE
  424. void
  425. row_update_statistics_if_needed(
  426. /*============================*/
  427. row_prebuilt_t* prebuilt) /* in: prebuilt struct */
  428. {
  429. ulint counter;
  430. ulint old_counter;
  432. counter = prebuilt->table->stat_modif_counter;
  434. counter += prebuilt->mysql_row_len;
  435. prebuilt->table->stat_modif_counter = counter;
  437. old_counter = prebuilt->table->stat_last_estimate_counter;
  439. if (counter - old_counter >= DICT_STAT_CALCULATE_INTERVAL
  440.     || counter - old_counter >=
  441. (UNIV_PAGE_SIZE
  442. * prebuilt->table->stat_clustered_index_size / 2)) {
  444. dict_update_statistics(prebuilt->table);
  445. }
  446. }
  448. /*************************************************************************
  449. Does an insert for MySQL. */
  451. int
  452. row_insert_for_mysql(
  453. /*=================*/
  454. /* out: error code or DB_SUCCESS */
  455. byte* mysql_rec, /* in: row in the MySQL format */
  456. row_prebuilt_t* prebuilt) /* in: prebuilt struct in MySQL
  457. handle */
  458. {
  459. trx_savept_t savept;
  460. que_thr_t* thr;
  461. ulint err;
  462. ibool was_lock_wait;
  463. trx_t* trx  = prebuilt->trx;
  464. ins_node_t* node = prebuilt->ins_node;
  466. ut_ad(trx);
  467. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  469. if (node == NULL) {
  470. row_get_prebuilt_insert_row(prebuilt);
  471. node = prebuilt->ins_node;
  472. }
  474. row_mysql_convert_row_to_innobase(node->row, prebuilt, mysql_rec);
  476. savept = trx_savept_take(trx);
  478. thr = que_fork_get_first_thr(prebuilt->ins_graph);
  480. if (prebuilt->sql_stat_start) {
  481. node->state = INS_NODE_SET_IX_LOCK;
  482. prebuilt->sql_stat_start = FALSE;
  483. } else {
  484. node->state = INS_NODE_ALLOC_ROW_ID;
  485. }
  487. que_thr_move_to_run_state_for_mysql(thr, trx);
  489. run_again:
  490. thr->run_node = node;
  491. thr->prev_node = node;
  493. row_ins_step(thr);
  495. err = trx->error_state;
  497. if (err != DB_SUCCESS) {
  498. que_thr_stop_for_mysql(thr);
  500. was_lock_wait = row_mysql_handle_errors(&err, trx, thr,
  501. &savept);
  502. if (was_lock_wait) {
  503. goto run_again;
  504. }
  506. return(err);
  507. }
  509. que_thr_stop_for_mysql_no_error(thr, trx);
  511. prebuilt->table->stat_n_rows++;
  513. if (prebuilt->table->stat_n_rows == 0) {
  514. /* Avoid wrap-over */
  515. prebuilt->table->stat_n_rows--;
  516. }
  518. row_update_statistics_if_needed(prebuilt);
  520. return((int) err);
  521. }
  523. /*************************************************************************
  524. Builds a dummy query graph used in selects. */
  526. void
  527. row_prebuild_sel_graph(
  528. /*===================*/
  529. row_prebuilt_t* prebuilt) /* in: prebuilt struct in MySQL
  530. handle */
  531. {
  532. sel_node_t* node;
  534. ut_ad(prebuilt && prebuilt->trx);
  536. if (prebuilt->sel_graph == NULL) {
  538. node = sel_node_create(prebuilt->heap);
  540. prebuilt->sel_graph =
  541. que_node_get_parent(
  542. pars_complete_graph_for_exec(node,
  543. prebuilt->trx,
  544. prebuilt->heap));
  546. prebuilt->sel_graph->state = QUE_FORK_ACTIVE;
  547. }
  548. }
  550. /*************************************************************************
  551. Gets pointer to a prebuilt update vector used in updates. If the update
  552. graph has not yet been built in the prebuilt struct, then this function
  553. first builds it. */
  555. upd_t*
  556. row_get_prebuilt_update_vector(
  557. /*===========================*/
  558. /* out: prebuilt update vector */
  559. row_prebuilt_t* prebuilt) /* in: prebuilt struct in MySQL
  560. handle */
  561. {
  562. dict_table_t* table = prebuilt->table;
  563. upd_node_t* node;
  565. ut_ad(prebuilt && table && prebuilt->trx);
  567. if (prebuilt->upd_node == NULL) {
  569. /* Not called before for this handle: create an update node
  570. and query graph to the prebuilt struct */
  572. node = upd_node_create(prebuilt->heap);
  574. prebuilt->upd_node = node;
  576. node->in_mysql_interface = TRUE;
  577. node->is_delete = FALSE;
  578. node->searched_update = FALSE;
  579. node->select_will_do_update = FALSE;
  580. node->select = NULL;
  581. node->pcur = btr_pcur_create_for_mysql();
  582. node->table = table;
  584. node->update = upd_create(dict_table_get_n_cols(table),
  585. prebuilt->heap);
  586. UT_LIST_INIT(node->columns);
  587. node->has_clust_rec_x_lock = TRUE;
  588. node->cmpl_info = 0;
  590. node->table_sym = NULL;
  591. node->col_assign_list = NULL;
  593. prebuilt->upd_graph =
  594. que_node_get_parent(
  595. pars_complete_graph_for_exec(node,
  596. prebuilt->trx,
  597. prebuilt->heap));
  598. prebuilt->upd_graph->state = QUE_FORK_ACTIVE;
  599. }
  601. return(prebuilt->upd_node->update);
  602. }
  604. /*************************************************************************
  605. Does an update or delete of a row for MySQL. */
  607. int
  608. row_update_for_mysql(
  609. /*=================*/
  610. /* out: error code or DB_SUCCESS */
  611. byte* mysql_rec, /* in: the row to be updated, in
  612. the MySQL format */
  613. row_prebuilt_t* prebuilt) /* in: prebuilt struct in MySQL
  614. handle */
  615. {
  616. trx_savept_t savept;
  617. ulint err;
  618. que_thr_t* thr;
  619. ibool was_lock_wait;
  620. dict_index_t* clust_index; 
  621. /* ulint ref_len; */
  622. upd_node_t* node;
  623. dict_table_t* table = prebuilt->table;
  624. trx_t* trx = prebuilt->trx;
  625. /* mem_heap_t* heap;
  626. dtuple_t* search_tuple;
  627. dtuple_t* row_tuple;
  628. mtr_t mtr; */
  630. ut_ad(prebuilt && trx);
  631. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  633. node = prebuilt->upd_node;
  635. clust_index = dict_table_get_first_index(table);
  637. if (prebuilt->pcur->btr_cur.index == clust_index) {
  638. btr_pcur_copy_stored_position(node->pcur, prebuilt->pcur);
  639. } else {
  640. btr_pcur_copy_stored_position(node->pcur, prebuilt->clust_pcur);
  641. }
  643. ut_a(node->pcur->rel_pos == BTR_PCUR_ON);
  644.  
  645. /* MySQL seems to call rnd_pos before updating each row it
  646. has cached: we can get the correct cursor position from
  647. prebuilt->pcur; NOTE that we cannot build the row reference
  648. from mysql_rec if the clustered index was automatically
  649. generated for the table: MySQL does not know anything about
  650. the row id used as the clustered index key */
  652. #ifdef notdefined
  653. /* We have to search for the correct cursor position */
  655. ref_len = dict_index_get_n_unique(clust_index);
  657. heap = mem_heap_create(450);
  659. row_tuple = dtuple_create(heap, dict_table_get_n_cols(table));
  660. dict_table_copy_types(row_tuple, table);
  662. if (prebuilt->ins_upd_rec_buff == NULL) {
  663. prebuilt->ins_upd_rec_buff = mem_heap_alloc(prebuilt->heap,
  664. prebuilt->mysql_row_len);
  665. }
  667. row_mysql_convert_row_to_innobase(row_tuple, prebuilt, mysql_rec);
  669. search_tuple = dtuple_create(heap, ref_len);
  671. row_build_row_ref_from_row(search_tuple, table, row_tuple);
  673. mtr_start(&mtr);
  675. btr_pcur_open_with_no_init(clust_index, search_tuple, PAGE_CUR_LE,
  676. BTR_SEARCH_LEAF, node->pcur, 0, &mtr);
  678. btr_pcur_store_position(node->pcur, &mtr);
  680. mtr_commit(&mtr);
  682. mem_heap_free(heap);
  683. #endif
  684. savept = trx_savept_take(trx);
  686. thr = que_fork_get_first_thr(prebuilt->upd_graph);
  688. node->state = UPD_NODE_UPDATE_CLUSTERED;
  690. ut_ad(!prebuilt->sql_stat_start);
  692. que_thr_move_to_run_state_for_mysql(thr, trx);
  693. run_again:
  694. thr->run_node = node;
  695. thr->prev_node = node;
  697. row_upd_step(thr);
  699. err = trx->error_state;
  701. if (err != DB_SUCCESS) {
  702. que_thr_stop_for_mysql(thr);
  704. if (err == DB_RECORD_NOT_FOUND) {
  705. trx->error_state = DB_SUCCESS;
  707. return((int) err);
  708. }
  710. was_lock_wait = row_mysql_handle_errors(&err, trx, thr,
  711. &savept);
  712. if (was_lock_wait) {
  713. goto run_again;
  714. }
  716. return(err);
  717. }
  719. que_thr_stop_for_mysql_no_error(thr, trx);
  721. if (prebuilt->upd_node->is_delete) {
  722. if (prebuilt->table->stat_n_rows > 0) {
  723. prebuilt->table->stat_n_rows--;
  724. }
  725. }
  727. row_update_statistics_if_needed(prebuilt);
  729. return((int) err);
  730. }
  732. /*************************************************************************
  733. Checks if a table is such that we automatically created a clustered
  734. index on it (on row id). */
  736. ibool
  737. row_table_got_default_clust_index(
  738. /*==============================*/
  739. dict_table_t* table)
  740. {
  741. dict_index_t* clust_index;
  743. clust_index = dict_table_get_first_index(table);
  745. if (dtype_get_mtype(dict_index_get_nth_type(clust_index, 0))
  746.   == DATA_SYS) {
  747.   return(TRUE);
  748. }
  750. return(FALSE);
  751. }
  753. /*************************************************************************
  754. Calculates the key number used inside MySQL for an Innobase index. We have
  755. to take into account if we generated a default clustered index for the table */
  757. ulint
  758. row_get_mysql_key_number_for_index(
  759. /*===============================*/
  760. dict_index_t* index)
  761. {
  762. dict_index_t* ind;
  763. ulint i;
  765. ut_a(index);
  767. i = 0;
  768. ind = dict_table_get_first_index(index->table);
  770. while (index != ind) {
  771. ind = dict_table_get_next_index(ind);
  772. i++;
  773. }
  775. if (row_table_got_default_clust_index(index->table)) {
  776. ut_a(i > 0);
  777. i--;
  778. }
  780. return(i);
  781. }
  783. /*************************************************************************
  784. Does a table creation operation for MySQL. */
  786. int
  787. row_create_table_for_mysql(
  788. /*=======================*/
  789. /* out: error code or DB_SUCCESS */
  790. dict_table_t* table, /* in: table definition */
  791. trx_t* trx) /* in: transaction handle */
  792. {
  793. tab_node_t* node;
  794. mem_heap_t* heap;
  795. que_thr_t* thr;
  796. ulint err;
  798. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  800. /* Serialize data dictionary operations with dictionary mutex:
  801. no deadlocks can occur then in these operations */
  803. mutex_enter(&(dict_sys->mutex));
  805. heap = mem_heap_create(512);
  807. trx->dict_operation = TRUE;
  809. node = tab_create_graph_create(table, heap);
  811. thr = pars_complete_graph_for_exec(node, trx, heap);
  813. ut_a(thr == que_fork_start_command(que_node_get_parent(thr),
  814. SESS_COMM_EXECUTE, 0));
  815. que_run_threads(thr);
  817. err = trx->error_state;
  819. if (err != DB_SUCCESS) {
  820. /* We have special error handling here */
  822. trx->error_state = DB_SUCCESS;
  824. trx_general_rollback_for_mysql(trx, FALSE, NULL);
  826. if (err == DB_OUT_OF_FILE_SPACE) {
  827.          row_drop_table_for_mysql(table->name, trx, TRUE);
  828. } else {
  829.          assert(err == DB_DUPLICATE_KEY);
  830.  fprintf(stderr, 
  831.      "Innobase: error: table %s already exists in Innobase data dictionaryn",
  832.  table->name);
  833. }
  835. trx->error_state = DB_SUCCESS;
  836. }
  838. mutex_exit(&(dict_sys->mutex));
  839. que_graph_free((que_t*) que_node_get_parent(thr));
  841. return((int) err);
  842. }
  844. /*************************************************************************
  845. Does an index creation operation for MySQL. TODO: currently failure
  846. to create an index results in dropping the whole table! This is no problem
  847. currently as all indexes must be created at the same time as the table. */
  849. int
  850. row_create_index_for_mysql(
  851. /*=======================*/
  852. /* out: error number or DB_SUCCESS */
  853. dict_index_t* index, /* in: index defintion */
  854. trx_t* trx) /* in: transaction handle */
  855. {
  856. ind_node_t* node;
  857. mem_heap_t* heap;
  858. que_thr_t* thr;
  859. ulint err;
  861. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  863. /* Serialize data dictionary operations with dictionary mutex:
  864. no deadlocks can occur then in these operations */
  866. mutex_enter(&(dict_sys->mutex));
  868. heap = mem_heap_create(512);
  870. trx->dict_operation = TRUE;
  872. node = ind_create_graph_create(index, heap);
  874. thr = pars_complete_graph_for_exec(node, trx, heap);
  876. ut_a(thr == que_fork_start_command(que_node_get_parent(thr),
  877. SESS_COMM_EXECUTE, 0));
  878. que_run_threads(thr);
  880. err = trx->error_state;
  882. if (err != DB_SUCCESS) {
  883. /* We have special error handling here */
  884. ut_a(err == DB_OUT_OF_FILE_SPACE);
  886. trx->error_state = DB_SUCCESS;
  888. trx_general_rollback_for_mysql(trx, FALSE, NULL);
  890. row_drop_table_for_mysql(index->table_name, trx, TRUE);
  892. trx->error_state = DB_SUCCESS;
  893. }
  895. mutex_exit(&(dict_sys->mutex));
  897. que_graph_free((que_t*) que_node_get_parent(thr));
  899. return((int) err);
  900. }
  902. /*************************************************************************
  903. Drops a table for MySQL. */
  905. int
  906. row_drop_table_for_mysql(
  907. /*=====================*/
  908. /* out: error code or DB_SUCCESS */
  909. char* name, /* in: table name */
  910. trx_t* trx, /* in: transaction handle */
  911. ibool has_dict_mutex) /* in: TRUE if the caller already owns the
  912. dictionary system mutex */
  913. {
  914. dict_table_t* table;
  915. que_thr_t* thr;
  916. que_t* graph;
  917. ulint err;
  918. char* str1;
  919. char* str2;
  920. ulint len;
  921. char buf[10000];
  922. retry:
  923. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  924. ut_a(name != NULL);
  926. /* We use the private SQL parser of Innobase to generate the
  927. query graphs needed in deleting the dictionary data from system
  928. tables in Innobase. Deleting a row from SYS_INDEXES table also
  929. frees the file segments of the B-tree associated with the index. */
  931. str1 =
  932. "PROCEDURE DROP_TABLE_PROC () ISn"
  933. "table_id CHAR;n"
  934. "index_id CHAR;n"
  935. "found INT;n"
  936. "BEGINn"
  937. "SELECT ID INTO table_idn"
  938. "FROM SYS_TABLESn"
  939. "WHERE NAME ='";
  941. str2 = 
  942. "';n"
  943. "IF (SQL % NOTFOUND) THENn"
  944. " COMMIT WORK;n"
  945. " RETURN;n"
  946. "END IF;n"
  947. "found := 1;n"
  948. "WHILE found = 1 LOOPn"
  949. " SELECT ID INTO index_idn"
  950. " FROM SYS_INDEXESn"
  951. " WHERE TABLE_ID = table_id;n"
  952. " IF (SQL % NOTFOUND) THENn"
  953. " found := 0;n"
  954. " ELSE"
  955. " DELETE FROM SYS_FIELDS WHERE INDEX_ID = index_id;n"
  956. " DELETE FROM SYS_INDEXES WHERE ID = index_id;n"
  957. " END IF;n"
  958. "END LOOP;n"
  959. "DELETE FROM SYS_COLUMNS WHERE TABLE_ID = table_id;n"
  960. "DELETE FROM SYS_TABLES WHERE ID = table_id;n"
  961. "COMMIT WORK;n"
  962. "END;n";
  964. len = ut_strlen(str1);
  966. ut_memcpy(buf, str1, len);
  967. ut_memcpy(buf + len, name, ut_strlen(name));
  969. len += ut_strlen(name);
  971. ut_memcpy(buf + len, str2, ut_strlen(str2) + 1);
  973. /* Serialize data dictionary operations with dictionary mutex:
  974. no deadlocks can occur then in these operations */
  976. if (!has_dict_mutex) {
  977. mutex_enter(&(dict_sys->mutex));
  978. }
  980. graph = pars_sql(buf);
  982. ut_a(graph);
  984. graph->trx = trx;
  985. trx->graph = NULL;
  987. graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
  989. /* Prevent purge from running while we are dropping the table */
  990. rw_lock_s_lock(&(purge_sys->purge_is_running));
  992. table = dict_table_get_low(name);
  994. if (!table) {
  995. err = DB_TABLE_NOT_FOUND;
  997. goto funct_exit;
  998. }
  1000. /* Check if there are any locks on the table: if yes, it cannot
  1001. be dropped: we have to wait for the locks to be released  */
  1003. if (lock_is_on_table(table)) {
  1005. err = DB_TABLE_IS_BEING_USED;
  1007. goto funct_exit;
  1008. }
  1010. /* TODO: check that MySQL prevents users from accessing the table
  1011. after this function row_drop_table_for_mysql has been called:
  1012. otherwise anyone with an open handle to the table could, for example,
  1013. come to read the table! */
  1015. trx->dict_operation = TRUE;
  1016. trx->table_id = table->id;
  1018. ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
  1020. que_run_threads(thr);
  1022. err = trx->error_state;
  1024. if (err != DB_SUCCESS) {
  1025. ut_a(err == DB_OUT_OF_FILE_SPACE);
  1027. err = DB_MUST_GET_MORE_FILE_SPACE;
  1029. row_mysql_handle_errors(&err, trx, thr, NULL);
  1031. ut_a(0);
  1032. } else {
  1033. dict_table_remove_from_cache(table);
  1034. }
  1035. funct_exit:
  1036. rw_lock_s_unlock(&(purge_sys->purge_is_running));
  1038. if (!has_dict_mutex) {
  1039. mutex_exit(&(dict_sys->mutex));
  1040. }
  1042. que_graph_free(graph);
  1044. if (err == DB_TABLE_IS_BEING_USED) {
  1045. os_thread_sleep(200000);
  1047. goto retry;
  1048. }
  1050. return((int) err);
  1051. }
  1053. /*************************************************************************
  1054. Renames a table for MySQL. */
  1056. int
  1057. row_rename_table_for_mysql(
  1058. /*=======================*/
  1059. /* out: error code or DB_SUCCESS */
  1060. char* old_name, /* in: old table name */
  1061. char* new_name, /* in: new table name */
  1062. trx_t* trx) /* in: transaction handle */
  1063. {
  1064. dict_table_t* table;
  1065. que_thr_t* thr;
  1066. que_t* graph;
  1067. ulint err;
  1068. char* str1;
  1069. char* str2;
  1070. char* str3;
  1071. ulint len;
  1072. char buf[10000];
  1074. ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
  1075. ut_a(old_name != NULL);
  1076. ut_a(new_name != NULL);
  1078. str1 =
  1079. "PROCEDURE RENAME_TABLE_PROC () ISn"
  1080. "BEGINn"
  1081. "UPDATE SYS_TABLES SET NAME ='";
  1083. str2 = 
  1084. "' WHERE NAME = '";
  1086. str3 =
  1087. "';n"
  1088. "COMMIT WORK;n"
  1089. "END;n";
  1091. len = ut_strlen(str1);
  1093. ut_memcpy(buf, str1, len);
  1095. ut_memcpy(buf + len, new_name, ut_strlen(new_name));
  1097. len += ut_strlen(new_name);
  1099. ut_memcpy(buf + len, str2, ut_strlen(str2));
  1101. len += ut_strlen(str2);
  1103. ut_memcpy(buf + len, old_name, ut_strlen(old_name));
  1105. len += ut_strlen(old_name);
  1107. ut_memcpy(buf + len, str3, ut_strlen(str3) + 1);
  1109. /* Serialize data dictionary operations with dictionary mutex:
  1110. no deadlocks can occur then in these operations */
  1112. mutex_enter(&(dict_sys->mutex));
  1114. table = dict_table_get_low(old_name);
  1116. graph = pars_sql(buf);
  1118. ut_a(graph);
  1120. graph->trx = trx;
  1121. trx->graph = NULL;
  1123. graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
  1125. if (!table) {
  1126. err = DB_TABLE_NOT_FOUND;
  1128. goto funct_exit;
  1129. }
  1131. ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
  1133. que_run_threads(thr);
  1135. err = trx->error_state;
  1137. if (err != DB_SUCCESS) {
  1138. row_mysql_handle_errors(&err, trx, thr, NULL);
  1139. } else {
  1140. ut_a(dict_table_rename_in_cache(table, new_name));
  1141. }
  1142. funct_exit:
  1143. mutex_exit(&(dict_sys->mutex));
  1145. que_graph_free(graph);
  1147. return((int) err);
  1148. }