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

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

MySQL数据库

开发平台：

Visual C++

que0que.c：源码内容
  1. /******************************************************
  2. Query graph
  4. (c) 1996 Innobase Oy
  6. Created 5/27/1996 Heikki Tuuri
  7. *******************************************************/
  9. #include "que0que.h"
  10.  
  11. #ifdef UNIV_NONINL
  12. #include "que0que.ic"
  13. #endif
  15. #include "srv0que.h"
  16. #include "usr0sess.h"
  17. #include "trx0trx.h"
  18. #include "trx0roll.h"
  19. #include "row0undo.h"
  20. #include "row0ins.h"
  21. #include "row0upd.h"
  22. #include "row0sel.h"
  23. #include "row0purge.h"
  24. #include "dict0crea.h"
  25. #include "log0log.h"
  26. #include "eval0proc.h"
  27. #include "eval0eval.h"
  29. #define QUE_PARALLELIZE_LIMIT (64 * 256 * 256 * 256)
  30. #define QUE_ROUND_ROBIN_LIMIT (64 * 256 * 256 * 256)
  31. #define QUE_MAX_LOOPS_WITHOUT_CHECK 16
  33. /* If the following flag is set TRUE, the module will print trace info
  34. of SQL execution in the UNIV_SQL_DEBUG version */
  35. ibool que_trace_on = FALSE;
  37. ibool que_always_false = FALSE;
  39. /* How a stored procedure containing COMMIT or ROLLBACK commands
  40. is executed?
  42. The commit or rollback can be seen as a subprocedure call.
  43. The problem is that if there are several query threads
  44. currently running within the transaction, their action could
  45. mess the commit or rollback operation. Or, at the least, the
  46. operation would be difficult to visualize and keep in control.
  48. Therefore the query thread requesting a commit or a rollback
  49. sends to the transaction a signal, which moves the transaction
  50. to TRX_QUE_SIGNALED state. All running query threads of the
  51. transaction will eventually notice that the transaction is now in
  52. this state and voluntarily suspend themselves. Only the last
  53. query thread which suspends itself will trigger handling of
  54. the signal.
  56. When the transaction starts to handle a rollback or commit
  57. signal, it builds a query graph which, when executed, will
  58. roll back or commit the incomplete transaction. The transaction
  59. is moved to the TRX_QUE_ROLLING_BACK or TRX_QUE_COMMITTING state.
  60. If specified, the SQL cursors opened by the transaction are closed.
  61. When the execution of the graph completes, it is like returning
  62. from a subprocedure: the query thread which requested the operation
  63. starts running again. */
  65. /**************************************************************************
  66. Moves a thread from another state to the QUE_THR_RUNNING state. Increments
  67. the n_active_thrs counters of the query graph and transaction.
  68. ***NOTE***: This is the only function in which such a transition is allowed
  69. to happen! */
  70. static
  71. void
  72. que_thr_move_to_run_state(
  73. /*======================*/
  74. que_thr_t* thr); /* in: an query thread */
  76. /***************************************************************************
  77. Adds a query graph to the session's list of graphs. */
  79. void
  80. que_graph_publish(
  81. /*==============*/
  82. que_t* graph, /* in: graph */
  83. sess_t* sess) /* in: session */
  84. {
  85. #ifdef UNIV_SYNC_DEBUG
  86. ut_ad(mutex_own(&kernel_mutex));
  87. #endif /* UNIV_SYNC_DEBUG */
  89. UT_LIST_ADD_LAST(graphs, sess->graphs, graph);
  90. }
  92. /***************************************************************************
  93. Creates a query graph fork node. */
  95. que_fork_t*
  96. que_fork_create(
  97. /*============*/
  98. /* out, own: fork node */
  99. que_t* graph, /* in: graph, if NULL then this
  100. fork node is assumed to be the
  101. graph root */
  102. que_node_t* parent, /* in: parent node */
  103. ulint fork_type, /* in: fork type */
  104. mem_heap_t* heap) /* in: memory heap where created */
  105. {
  106. que_fork_t* fork;
  108. ut_ad(heap);
  110. fork = mem_heap_alloc(heap, sizeof(que_fork_t));
  112. fork->common.type = QUE_NODE_FORK;
  113. fork->n_active_thrs = 0;
  115. fork->state = QUE_FORK_COMMAND_WAIT;
  117. if (graph != NULL) {
  118. fork->graph = graph;
  119. } else {
  120. fork->graph = fork;
  121. }
  123. fork->common.parent = parent;
  124. fork->fork_type = fork_type;
  126. fork->caller = NULL;
  128. UT_LIST_INIT(fork->thrs);
  130. fork->sym_tab = NULL;
  132. fork->heap = heap;
  134. return(fork);
  135. }
  137. /***************************************************************************
  138. Creates a query graph thread node. */
  140. que_thr_t*
  141. que_thr_create(
  142. /*===========*/
  143. /* out, own: query thread node */
  144. que_fork_t* parent, /* in: parent node, i.e., a fork node */
  145. mem_heap_t* heap) /* in: memory heap where created */
  146. {
  147. que_thr_t* thr;
  149. ut_ad(parent && heap);
  151. thr = mem_heap_alloc(heap, sizeof(que_thr_t));
  153. thr->common.type = QUE_NODE_THR;
  154. thr->common.parent = parent;
  156. thr->magic_n = QUE_THR_MAGIC_N;
  158. thr->graph = parent->graph;
  160. thr->state = QUE_THR_COMMAND_WAIT;
  162. thr->is_active = FALSE;
  164. thr->run_node = NULL;
  165. thr->resource = 0;
  167. UT_LIST_ADD_LAST(thrs, parent->thrs, thr);
  169. return(thr);
  170. }
  172. /**************************************************************************
  173. Moves a suspended query thread to the QUE_THR_RUNNING state and may release
  174. a single worker thread to execute it. This function should be used to end
  175. the wait state of a query thread waiting for a lock or a stored procedure
  176. completion. */
  178. void
  179. que_thr_end_wait(
  180. /*=============*/
  181. que_thr_t* thr, /* in: query thread in the
  182. QUE_THR_LOCK_WAIT,
  183. or QUE_THR_PROCEDURE_WAIT, or
  184. QUE_THR_SIG_REPLY_WAIT state */
  185. que_thr_t** next_thr) /* in/out: next query thread to run;
  186. if the value which is passed in is
  187. a pointer to a NULL pointer, then the
  188. calling function can start running
  189. a new query thread; if NULL is passed
  190. as the parameter, it is ignored */
  191. {
  192. ibool was_active;
  194. #ifdef UNIV_SYNC_DEBUG
  195. ut_ad(mutex_own(&kernel_mutex));
  196. #endif /* UNIV_SYNC_DEBUG */
  197. ut_ad(thr);
  198. ut_ad((thr->state == QUE_THR_LOCK_WAIT)
  199.       || (thr->state == QUE_THR_PROCEDURE_WAIT)
  200.       || (thr->state == QUE_THR_SIG_REPLY_WAIT));
  201. ut_ad(thr->run_node);
  203. thr->prev_node = thr->run_node;
  205. was_active = thr->is_active;
  207. que_thr_move_to_run_state(thr);
  209. if (was_active) {
  211. return;
  212. }
  214. if (next_thr && *next_thr == NULL) {
  215. *next_thr = thr;
  216. } else {
  217. ut_a(0);
  218. srv_que_task_enqueue_low(thr);
  219. }
  220. }
  222. /**************************************************************************
  223. Same as que_thr_end_wait, but no parameter next_thr available. */
  225. void
  226. que_thr_end_wait_no_next_thr(
  227. /*=========================*/
  228. que_thr_t* thr) /* in: query thread in the QUE_THR_LOCK_WAIT,
  229. or QUE_THR_PROCEDURE_WAIT, or
  230. QUE_THR_SIG_REPLY_WAIT state */
  231. {
  232. ibool was_active;
  234. ut_a(thr->state == QUE_THR_LOCK_WAIT); /* In MySQL this is the
  235. only possible state here */
  236. #ifdef UNIV_SYNC_DEBUG
  237. ut_ad(mutex_own(&kernel_mutex));
  238. #endif /* UNIV_SYNC_DEBUG */
  239. ut_ad(thr);
  240. ut_ad((thr->state == QUE_THR_LOCK_WAIT)
  241.       || (thr->state == QUE_THR_PROCEDURE_WAIT)
  242.       || (thr->state == QUE_THR_SIG_REPLY_WAIT));
  244. was_active = thr->is_active;
  246. que_thr_move_to_run_state(thr);
  248. if (was_active) {
  250. return;
  251. }
  253. /* In MySQL we let the OS thread (not just the query thread) to wait
  254. for the lock to be released: */
  256. srv_release_mysql_thread_if_suspended(thr);
  258. /* srv_que_task_enqueue_low(thr); */
  259. }
  261. /**************************************************************************
  262. Inits a query thread for a command. */
  263. UNIV_INLINE
  264. void
  265. que_thr_init_command(
  266. /*=================*/
  267. que_thr_t* thr) /* in: query thread */
  268. {
  269. thr->run_node = thr;
  270. thr->prev_node = thr->common.parent;
  272. que_thr_move_to_run_state(thr);
  273. }
  275. /**************************************************************************
  276. Starts execution of a command in a query fork. Picks a query thread which
  277. is not in the QUE_THR_RUNNING state and moves it to that state. If none
  278. can be chosen, a situation which may arise in parallelized fetches, NULL
  279. is returned. */
  281. que_thr_t*
  282. que_fork_start_command(
  283. /*===================*/
  284. /* out: a query thread of the graph moved to
  285. QUE_THR_RUNNING state, or NULL; the query
  286. thread should be executed by que_run_threads
  287. by the caller */
  288. que_fork_t*  fork) /* in: a query fork */
  289. {
  290. que_thr_t* thr;
  292. fork->state = QUE_FORK_ACTIVE;
  294. fork->last_sel_node = NULL;
  296. /* Choose the query thread to run: usually there is just one thread,
  297. but in a parallelized select, which necessarily is non-scrollable,
  298. there may be several to choose from */
  300. /*---------------------------------------------------------------
  301. First we try to find a query thread in the QUE_THR_COMMAND_WAIT state */
  303. thr = UT_LIST_GET_FIRST(fork->thrs);
  305. while (thr != NULL) {
  306. if (thr->state == QUE_THR_COMMAND_WAIT) {
  308. /* We have to send the initial message to query thread
  309. to start it */
  311. que_thr_init_command(thr);
  313. return(thr);
  314. }
  316. ut_ad(thr->state != QUE_THR_LOCK_WAIT);
  318. thr = UT_LIST_GET_NEXT(thrs, thr);
  319. }
  321. /*----------------------------------------------------------------
  322. Then we try to find a query thread in the QUE_THR_SUSPENDED state */
  324. thr = UT_LIST_GET_FIRST(fork->thrs);
  326. while (thr != NULL) {
  327. if (thr->state == QUE_THR_SUSPENDED) {
  328. /* In this case the execution of the thread was
  329. suspended: no initial message is needed because
  330. execution can continue from where it was left */
  332. que_thr_move_to_run_state(thr);
  334. return(thr);
  335. }
  337. thr = UT_LIST_GET_NEXT(thrs, thr);
  338. }
  340. /*-----------------------------------------------------------------
  341. Then we try to find a query thread in the QUE_THR_COMPLETED state */
  343. thr = UT_LIST_GET_FIRST(fork->thrs);
  345. while (thr != NULL) {
  346. if (thr->state == QUE_THR_COMPLETED) {
  347. que_thr_init_command(thr);
  349. return(thr);
  350. }
  352. thr = UT_LIST_GET_NEXT(thrs, thr);
  353. }
  355. /* Else we return NULL */
  356. return(NULL);
  357. }
  359. /**************************************************************************
  360. After signal handling is finished, returns control to a query graph error
  361. handling routine. (Currently, just returns the control to the root of the
  362. graph so that the graph can communicate an error message to the client.) */
  364. void
  365. que_fork_error_handle(
  366. /*==================*/
  367. trx_t* trx __attribute__((unused)), /* in: trx */
  368. que_t* fork) /* in: query graph which was run before signal
  369. handling started, NULL not allowed */
  370. {
  371. que_thr_t* thr;
  373. #ifdef UNIV_SYNC_DEBUG
  374. ut_ad(mutex_own(&kernel_mutex));
  375. #endif /* UNIV_SYNC_DEBUG */
  376. ut_ad(trx->sess->state == SESS_ERROR);
  377. ut_ad(UT_LIST_GET_LEN(trx->reply_signals) == 0);
  378. ut_ad(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
  380. thr = UT_LIST_GET_FIRST(fork->thrs);
  382. while (thr != NULL) {
  383. ut_ad(!thr->is_active);
  384. ut_ad(thr->state != QUE_THR_SIG_REPLY_WAIT);
  385. ut_ad(thr->state != QUE_THR_LOCK_WAIT);
  387. thr->run_node = thr;
  388. thr->prev_node = thr->child;
  389. thr->state = QUE_THR_COMPLETED;
  391. thr = UT_LIST_GET_NEXT(thrs, thr);
  392. }
  394. thr = UT_LIST_GET_FIRST(fork->thrs);
  396. que_thr_move_to_run_state(thr);
  398. ut_a(0);
  399. srv_que_task_enqueue_low(thr);
  400. }
  402. /********************************************************************
  403. Tests if all the query threads in the same fork have a given state. */
  404. UNIV_INLINE
  405. ibool
  406. que_fork_all_thrs_in_state(
  407. /*=======================*/
  408. /* out: TRUE if all the query threads in the
  409. same fork were in the given state */
  410. que_fork_t* fork, /* in: query fork */
  411. ulint state) /* in: state */
  412. {
  413. que_thr_t* thr_node;
  415. thr_node = UT_LIST_GET_FIRST(fork->thrs);
  417. while (thr_node != NULL) {
  418. if (thr_node->state != state) {
  420. return(FALSE);
  421. }
  423. thr_node = UT_LIST_GET_NEXT(thrs, thr_node);
  424. }
  426. return(TRUE);
  427. }
  429. /**************************************************************************
  430. Calls que_graph_free_recursive for statements in a statement list. */
  431. static
  432. void
  433. que_graph_free_stat_list(
  434. /*=====================*/
  435. que_node_t* node) /* in: first query graph node in the list */
  436. {
  437. while (node) {
  438. que_graph_free_recursive(node);
  440. node = que_node_get_next(node);
  441. }
  442. }
  444. /**************************************************************************
  445. Frees a query graph, but not the heap where it was created. Does not free
  446. explicit cursor declarations, they are freed in que_graph_free. */
  448. void
  449. que_graph_free_recursive(
  450. /*=====================*/
  451. que_node_t* node) /* in: query graph node */
  452. {
  453. que_fork_t* fork;
  454. que_thr_t* thr;
  455. undo_node_t* undo;
  456. sel_node_t* sel;
  457. ins_node_t* ins;
  458. upd_node_t* upd;
  459. tab_node_t* cre_tab;
  460. ind_node_t* cre_ind;
  462. if (node == NULL) {
  464. return;
  465. }
  467. switch (que_node_get_type(node)) {
  469. case QUE_NODE_FORK:
  470. fork = node;
  472. thr = UT_LIST_GET_FIRST(fork->thrs);
  474. while (thr) {
  475. que_graph_free_recursive(thr);
  477. thr = UT_LIST_GET_NEXT(thrs, thr);
  478. }
  480. break;
  481. case QUE_NODE_THR:
  483. thr = node;
  485. if (thr->magic_n != QUE_THR_MAGIC_N) {
  486. fprintf(stderr,
  487. "que_thr struct appears corrupt; magic n %lun",
  488. (unsigned long) thr->magic_n);
  489. mem_analyze_corruption((byte*)thr);
  490. ut_error;
  491. }
  493. thr->magic_n = QUE_THR_MAGIC_FREED;
  495. que_graph_free_recursive(thr->child);
  497. break;
  498. case QUE_NODE_UNDO:
  500. undo = node;
  502. mem_heap_free(undo->heap);
  504. break;
  505. case QUE_NODE_SELECT:
  507. sel = node;
  509. sel_node_free_private(sel);
  511. break;
  512. case QUE_NODE_INSERT:
  514. ins = node;
  516. que_graph_free_recursive(ins->select);
  518. mem_heap_free(ins->entry_sys_heap);
  520. break;
  521. case QUE_NODE_UPDATE:
  523. upd = node;
  525. if (upd->in_mysql_interface) {
  527. btr_pcur_free_for_mysql(upd->pcur);
  528. }
  530. que_graph_free_recursive(upd->cascade_node);
  532. if (upd->cascade_heap) {
  533. mem_heap_free(upd->cascade_heap);
  534. }
  536. que_graph_free_recursive(upd->select);
  538. mem_heap_free(upd->heap);
  540. break;
  541. case QUE_NODE_CREATE_TABLE:
  542. cre_tab = node;
  544. que_graph_free_recursive(cre_tab->tab_def);
  545. que_graph_free_recursive(cre_tab->col_def);
  546. que_graph_free_recursive(cre_tab->commit_node);
  548. mem_heap_free(cre_tab->heap);
  550. break;
  551. case QUE_NODE_CREATE_INDEX:
  552. cre_ind = node;
  554. que_graph_free_recursive(cre_ind->ind_def);
  555. que_graph_free_recursive(cre_ind->field_def);
  556. que_graph_free_recursive(cre_ind->commit_node);
  558. mem_heap_free(cre_ind->heap);
  560. break;
  561. case QUE_NODE_PROC:
  562. que_graph_free_stat_list(((proc_node_t*)node)->stat_list);
  564. break;
  565. case QUE_NODE_IF:
  566. que_graph_free_stat_list(((if_node_t*)node)->stat_list);
  567. que_graph_free_stat_list(((if_node_t*)node)->else_part);
  568. que_graph_free_stat_list(((if_node_t*)node)->elsif_list);
  570. break;
  571. case QUE_NODE_ELSIF:
  572. que_graph_free_stat_list(((elsif_node_t*)node)->stat_list);
  574. break;
  575. case QUE_NODE_WHILE:
  576. que_graph_free_stat_list(((while_node_t*)node)->stat_list);
  578. break;
  579. case QUE_NODE_FOR:
  580. que_graph_free_stat_list(((for_node_t*)node)->stat_list);
  582. break;
  584. case QUE_NODE_ASSIGNMENT:
  585. case QUE_NODE_RETURN:
  586. case QUE_NODE_COMMIT:
  587. case QUE_NODE_ROLLBACK:
  588. case QUE_NODE_LOCK:
  589. case QUE_NODE_FUNC:
  590. case QUE_NODE_ORDER:
  591. case QUE_NODE_ROW_PRINTF:
  592. case QUE_NODE_OPEN:
  593. case QUE_NODE_FETCH:
  594. /* No need to do anything */
  596. break;
  597. default:
  598. fprintf(stderr,
  599. "que_node struct appears corrupt; type %lun",
  600. (unsigned long) que_node_get_type(node));
  601. mem_analyze_corruption((byte*)node);
  602. ut_error;
  603. }
  604. }
  606. /**************************************************************************
  607. Frees a query graph. */
  609. void
  610. que_graph_free(
  611. /*===========*/
  612. que_t* graph) /* in: query graph; we assume that the memory
  613. heap where this graph was created is private
  614. to this graph: if not, then use
  615. que_graph_free_recursive and free the heap
  616. afterwards! */
  617. {
  618. ut_ad(graph);
  620. if (graph->sym_tab) {
  621. /* The following call frees dynamic memory allocated
  622. for variables etc. during execution. Frees also explicit
  623. cursor definitions. */
  625. sym_tab_free_private(graph->sym_tab);
  626. }
  628. que_graph_free_recursive(graph);
  630. mem_heap_free(graph->heap);
  631. }
  633. /**************************************************************************
  634. Checks if the query graph is in a state where it should be freed, and
  635. frees it in that case. If the session is in a state where it should be
  636. closed, also this is done. */
  638. ibool
  639. que_graph_try_free(
  640. /*===============*/
  641. /* out: TRUE if freed */
  642. que_t* graph) /* in: query graph */
  643. {
  644. sess_t* sess;
  646. #ifdef UNIV_SYNC_DEBUG
  647. ut_ad(mutex_own(&kernel_mutex));
  648. #endif /* UNIV_SYNC_DEBUG */
  650. sess = (graph->trx)->sess;
  652. if ((graph->state == QUE_FORK_BEING_FREED)
  653. && (graph->n_active_thrs == 0)) {
  655. UT_LIST_REMOVE(graphs, sess->graphs, graph);
  656. que_graph_free(graph);
  658. sess_try_close(sess);
  660. return(TRUE);
  661. }
  663. return(FALSE);
  664. }
  666. /**************************************************************************
  667. Handles an SQL error noticed during query thread execution. Currently,
  668. does nothing! */
  670. void
  671. que_thr_handle_error(
  672. /*=================*/
  673. que_thr_t* thr __attribute__((unused)),
  674. /* in: query thread */
  675. ulint err_no __attribute__((unused)),
  676. /* in: error number */
  677. byte* err_str __attribute__((unused)),
  678. /* in, own: error string or NULL; NOTE: the
  679. function will take care of freeing of the
  680. string! */
  681. ulint err_len __attribute__((unused)))
  682. /* in: error string length */
  683. {
  684. /* Does nothing */
  685. }
  687. /********************************************************************
  688. Performs an execution step on a thr node. */
  689. static
  690. que_thr_t*
  691. que_thr_node_step(
  692. /*==============*/
  693. /* out: query thread to run next, or NULL
  694. if none */
  695. que_thr_t* thr) /* in: query thread where run_node must
  696. be the thread node itself */
  697. {
  698. ut_ad(thr->run_node == thr);
  700. if (thr->prev_node == thr->common.parent) {
  701. /* If control to the node came from above, it is just passed
  702. on */
  704. thr->run_node = thr->child;
  706. return(thr);
  707. }
  709. mutex_enter(&kernel_mutex);
  711. if (que_thr_peek_stop(thr)) {
  713. mutex_exit(&kernel_mutex);
  715. return(thr);
  716. }
  718. /* Thread execution completed */
  720. thr->state = QUE_THR_COMPLETED;
  722. mutex_exit(&kernel_mutex);
  724. return(NULL);
  725. }
  727. /**************************************************************************
  728. Moves a thread from another state to the QUE_THR_RUNNING state. Increments
  729. the n_active_thrs counters of the query graph and transaction if thr was
  730. not active.
  731. ***NOTE***: This and ..._mysql are  the only functions in which such a
  732. transition is allowed to happen! */
  733. static
  734. void
  735. que_thr_move_to_run_state(
  736. /*======================*/
  737. que_thr_t* thr) /* in: an query thread */
  738. {
  739. trx_t* trx;
  741. ut_ad(thr->state != QUE_THR_RUNNING);
  743. trx = thr_get_trx(thr);
  745. if (!thr->is_active) {
  747. (thr->graph)->n_active_thrs++;
  749. trx->n_active_thrs++;
  751. thr->is_active = TRUE;
  753. ut_ad((thr->graph)->n_active_thrs == 1);
  754. ut_ad(trx->n_active_thrs == 1);
  755. }
  757. thr->state = QUE_THR_RUNNING;
  758. }
  760. /**************************************************************************
  761. Decrements the query thread reference counts in the query graph and the
  762. transaction. May start signal handling, e.g., a rollback.
  763. *** NOTE ***:
  764. This and que_thr_stop_for_mysql are
  765. the only functions where the reference count can be decremented and
  766. this function may only be called from inside que_run_threads or
  767. que_thr_check_if_switch! These restrictions exist to make the rollback code
  768. easier to maintain. */
  769. static
  770. void
  771. que_thr_dec_refer_count(
  772. /*====================*/
  773. que_thr_t* thr, /* in: query thread */
  774. que_thr_t** next_thr) /* in/out: next query thread to run;
  775. if the value which is passed in is
  776. a pointer to a NULL pointer, then the
  777. calling function can start running
  778. a new query thread */ 
  779. {
  780. que_fork_t* fork;
  781. trx_t* trx;
  782. sess_t* sess;
  783. ulint fork_type;
  784. ibool stopped;
  786. fork = thr->common.parent;
  787. trx = thr->graph->trx;
  788. sess = trx->sess;
  790. mutex_enter(&kernel_mutex);
  792. ut_a(thr->is_active);
  794. if (thr->state == QUE_THR_RUNNING) {
  796. stopped = que_thr_stop(thr);
  798. if (!stopped) {
  799. /* The reason for the thr suspension or wait was
  800. already canceled before we came here: continue
  801. running the thread */
  803. /* fputs("!!!!!!!! Wait already ended: continue thrn",
  804. stderr); */
  806. if (next_thr && *next_thr == NULL) {
  807. *next_thr = thr;
  808. } else {
  809. ut_a(0);
  810. srv_que_task_enqueue_low(thr);
  811. }
  813. mutex_exit(&kernel_mutex);
  815. return;
  816. }
  817. }
  819. ut_ad(fork->n_active_thrs == 1);
  820. ut_ad(trx->n_active_thrs == 1);
  822. fork->n_active_thrs--;
  823. trx->n_active_thrs--;
  825. thr->is_active = FALSE;
  827. if (trx->n_active_thrs > 0) {
  829. mutex_exit(&kernel_mutex);
  831. return;
  832. }
  834. fork_type = fork->fork_type;
  836. /* Check if all query threads in the same fork are completed */
  838. if (que_fork_all_thrs_in_state(fork, QUE_THR_COMPLETED)) {
  840. if (fork_type == QUE_FORK_ROLLBACK) {
  841. /* This is really the undo graph used in rollback,
  842. no roll_node in this graph */
  844. ut_ad(UT_LIST_GET_LEN(trx->signals) > 0);
  845. ut_ad(trx->handling_signals == TRUE);
  847. trx_finish_rollback_off_kernel(fork, trx, next_thr);
  849. } else if (fork_type == QUE_FORK_PURGE) {
  851. /* Do nothing */
  852. } else if (fork_type == QUE_FORK_RECOVERY) {
  854. /* Do nothing */
  855. } else if (fork_type == QUE_FORK_MYSQL_INTERFACE) {
  857. /* Do nothing */
  858. } else {
  859. ut_error; /* not used in MySQL */
  860. }
  861. }
  863. if (UT_LIST_GET_LEN(trx->signals) > 0 && trx->n_active_thrs == 0) {
  865.      /* If the trx is signaled and its query thread count drops to
  866. zero, then we start processing a signal; from it we may get
  867. a new query thread to run */
  869. trx_sig_start_handle(trx, next_thr);
  870. }
  872. if (trx->handling_signals && UT_LIST_GET_LEN(trx->signals) == 0) {
  874. trx_end_signal_handling(trx);
  875. }
  877. mutex_exit(&kernel_mutex);
  878. }
  880. /**************************************************************************
  881. Stops a query thread if graph or trx is in a state requiring it. The
  882. conditions are tested in the order (1) graph, (2) trx. The kernel mutex has
  883. to be reserved. */
  885. ibool
  886. que_thr_stop(
  887. /*=========*/
  888. /* out: TRUE if stopped */
  889. que_thr_t* thr) /* in: query thread */
  890. {
  891. trx_t* trx;
  892. que_t* graph;
  893. ibool ret = TRUE;
  895. #ifdef UNIV_SYNC_DEBUG
  896. ut_ad(mutex_own(&kernel_mutex));
  897. #endif /* UNIV_SYNC_DEBUG */
  899. graph = thr->graph;
  900. trx = graph->trx;
  902. if (graph->state == QUE_FORK_COMMAND_WAIT) {
  903. thr->state = QUE_THR_SUSPENDED;
  905. } else if (trx->que_state == TRX_QUE_LOCK_WAIT) {
  907. UT_LIST_ADD_FIRST(trx_thrs, trx->wait_thrs, thr);
  908. thr->state = QUE_THR_LOCK_WAIT;
  910. } else if (trx->error_state != DB_SUCCESS
  911. && trx->error_state != DB_LOCK_WAIT) {
  913. /* Error handling built for the MySQL interface */
  914. thr->state = QUE_THR_COMPLETED;
  916. } else if (UT_LIST_GET_LEN(trx->signals) > 0
  917. && graph->fork_type != QUE_FORK_ROLLBACK) {
  919. thr->state = QUE_THR_SUSPENDED;
  920. } else {
  921. ut_ad(graph->state == QUE_FORK_ACTIVE);
  923. ret = FALSE;
  924. }         
  926. return(ret);
  927. }
  929. /**************************************************************************
  930. A patch for MySQL used to 'stop' a dummy query thread used in MySQL. The
  931. query thread is stopped and made inactive, except in the case where
  932. it was put to the lock wait state in lock0lock.c, but the lock has already
  933. been granted or the transaction chosen as a victim in deadlock resolution. */
  935. void
  936. que_thr_stop_for_mysql(
  937. /*===================*/
  938. que_thr_t* thr) /* in: query thread */
  939. {
  940. trx_t* trx;
  942. trx = thr_get_trx(thr);
  944. mutex_enter(&kernel_mutex);
  946. if (thr->state == QUE_THR_RUNNING) {
  948. if (trx->error_state != DB_SUCCESS
  949.     && trx->error_state != DB_LOCK_WAIT) {
  951. /* Error handling built for the MySQL interface */
  952. thr->state = QUE_THR_COMPLETED;
  953. } else {
  954. /* It must have been a lock wait but the lock was
  955. already released, or this transaction was chosen
  956. as a victim in selective deadlock resolution */
  958. mutex_exit(&kernel_mutex);
  960. return;
  961. }
  962. }
  964. ut_ad(thr->is_active == TRUE);
  965. ut_ad(trx->n_active_thrs == 1);
  966. ut_ad(thr->graph->n_active_thrs == 1);
  968. thr->is_active = FALSE;
  969. (thr->graph)->n_active_thrs--;
  971. trx->n_active_thrs--;
  973. mutex_exit(&kernel_mutex);
  974. }
  976. /**************************************************************************
  977. Moves a thread from another state to the QUE_THR_RUNNING state. Increments
  978. the n_active_thrs counters of the query graph and transaction if thr was
  979. not active. */
  981. void
  982. que_thr_move_to_run_state_for_mysql(
  983. /*================================*/
  984. que_thr_t* thr, /* in: an query thread */
  985. trx_t* trx) /* in: transaction */
  986. {
  987. if (thr->magic_n != QUE_THR_MAGIC_N) {
  988. fprintf(stderr,
  989. "que_thr struct appears corrupt; magic n %lun",
  990. (unsigned long) thr->magic_n);
  992. mem_analyze_corruption((byte*)thr);
  994. ut_error;
  995. }
  997. if (!thr->is_active) {
  999. thr->graph->n_active_thrs++;
  1001. trx->n_active_thrs++;
  1003. thr->is_active = TRUE;
  1004. }
  1006. thr->state = QUE_THR_RUNNING;
  1007. }
  1009. /**************************************************************************
  1010. A patch for MySQL used to 'stop' a dummy query thread used in MySQL
  1011. select, when there is no error or lock wait. */
  1013. void
  1014. que_thr_stop_for_mysql_no_error(
  1015. /*============================*/
  1016. que_thr_t* thr, /* in: query thread */
  1017. trx_t* trx) /* in: transaction */
  1018. {
  1019. ut_ad(thr->state == QUE_THR_RUNNING);
  1020. ut_ad(thr->is_active == TRUE);
  1021. ut_ad(trx->n_active_thrs == 1);
  1022. ut_ad(thr->graph->n_active_thrs == 1);
  1024. if (thr->magic_n != QUE_THR_MAGIC_N) {
  1025. fprintf(stderr,
  1026. "que_thr struct appears corrupt; magic n %lun",
  1027. (unsigned long) thr->magic_n);
  1029. mem_analyze_corruption((byte*)thr);
  1031. ut_error;
  1032. }
  1034. thr->state = QUE_THR_COMPLETED;
  1036. thr->is_active = FALSE;
  1037. (thr->graph)->n_active_thrs--;
  1039. trx->n_active_thrs--;
  1040. }
  1042. /**************************************************************************
  1043. Prints info of an SQL query graph node. */
  1045. void
  1046. que_node_print_info(
  1047. /*================*/
  1048. que_node_t* node) /* in: query graph node */
  1049. {
  1050. ulint type;
  1051. const char* str;
  1053. type = que_node_get_type(node);
  1055. if (type == QUE_NODE_SELECT) {
  1056. str = "SELECT";
  1057. } else if (type == QUE_NODE_INSERT) {
  1058. str = "INSERT";
  1059. } else if (type == QUE_NODE_UPDATE) {
  1060. str = "UPDATE";
  1061. } else if (type == QUE_NODE_WHILE) {
  1062. str = "WHILE";
  1063. } else if (type == QUE_NODE_ASSIGNMENT) {
  1064. str = "ASSIGNMENT";
  1065. } else if (type == QUE_NODE_IF) {
  1066. str = "IF";
  1067. } else if (type == QUE_NODE_FETCH) {
  1068. str = "FETCH";
  1069. } else if (type == QUE_NODE_OPEN) {
  1070. str = "OPEN";
  1071. } else if (type == QUE_NODE_PROC) {
  1072. str = "STORED PROCEDURE";
  1073. } else if (type == QUE_NODE_FUNC) {
  1074. str = "FUNCTION";
  1075. } else if (type == QUE_NODE_LOCK) {
  1076. str = "LOCK";
  1077. } else if (type == QUE_NODE_THR) {
  1078. str = "QUERY THREAD";
  1079. } else if (type == QUE_NODE_COMMIT) {
  1080. str = "COMMIT";
  1081. } else if (type == QUE_NODE_UNDO) {
  1082. str = "UNDO ROW";
  1083. } else if (type == QUE_NODE_PURGE) {
  1084. str = "PURGE ROW";
  1085. } else if (type == QUE_NODE_ROLLBACK) {
  1086. str = "ROLLBACK";
  1087. } else if (type == QUE_NODE_CREATE_TABLE) {
  1088. str = "CREATE TABLE";
  1089. } else if (type == QUE_NODE_CREATE_INDEX) {
  1090. str = "CREATE INDEX";
  1091. } else if (type == QUE_NODE_FOR) {
  1092. str = "FOR LOOP";
  1093. } else if (type == QUE_NODE_RETURN) {
  1094. str = "RETURN";
  1095. } else {
  1096. str = "UNKNOWN NODE TYPE";
  1097. }
  1099. fprintf(stderr, "Node type %lu: %s, address %pn", (ulong) type, str, node);
  1100. }
  1102. /**************************************************************************
  1103. Performs an execution step on a query thread. */
  1104. UNIV_INLINE
  1105. que_thr_t*
  1106. que_thr_step(
  1107. /*=========*/
  1108. /* out: query thread to run next: it may
  1109. differ from the input parameter if, e.g., a
  1110. subprocedure call is made */ 
  1111. que_thr_t* thr) /* in: query thread */
  1112. {
  1113. que_node_t* node;
  1114. que_thr_t* old_thr;
  1115. trx_t* trx;
  1116. ulint type;
  1118. ut_ad(thr->state == QUE_THR_RUNNING);
  1120. thr->resource++;
  1122. type = que_node_get_type(thr->run_node);
  1123. node = thr->run_node;
  1125. old_thr = thr;
  1127. #ifdef UNIV_DEBUG
  1128. if (que_trace_on) {
  1129. fputs("To execute: ", stderr);
  1130. que_node_print_info(node);
  1131. }
  1132. #endif
  1133. if (type & QUE_NODE_CONTROL_STAT) {
  1134. if ((thr->prev_node != que_node_get_parent(node))
  1135. && que_node_get_next(thr->prev_node)) {
  1137. /* The control statements, like WHILE, always pass the
  1138. control to the next child statement if there is any
  1139. child left */
  1141. thr->run_node = que_node_get_next(thr->prev_node);
  1143. } else if (type == QUE_NODE_IF) {
  1144. if_step(thr);
  1145. } else if (type == QUE_NODE_FOR) {
  1146. for_step(thr);
  1147. } else if (type == QUE_NODE_PROC) {
  1149. /* We can access trx->undo_no without reserving
  1150. trx->undo_mutex, because there cannot be active query
  1151. threads doing updating or inserting at the moment! */
  1153. if (thr->prev_node == que_node_get_parent(node)) {
  1154. trx = thr_get_trx(thr);
  1155. trx->last_sql_stat_start.least_undo_no
  1156. = trx->undo_no;
  1157. }
  1159. proc_step(thr);
  1160. } else if (type == QUE_NODE_WHILE) {
  1161. while_step(thr);
  1162. }
  1163. } else if (type == QUE_NODE_ASSIGNMENT) {
  1164. assign_step(thr);
  1165. } else if (type == QUE_NODE_SELECT) {
  1166. thr = row_sel_step(thr);
  1167. } else if (type == QUE_NODE_INSERT) {
  1168. thr = row_ins_step(thr);
  1169. } else if (type == QUE_NODE_UPDATE) {
  1170. thr = row_upd_step(thr);
  1171. } else if (type == QUE_NODE_FETCH) {
  1172. thr = fetch_step(thr);
  1173. } else if (type == QUE_NODE_OPEN) {
  1174. thr = open_step(thr);
  1175. } else if (type == QUE_NODE_FUNC) {
  1176. proc_eval_step(thr);
  1178. } else if (type == QUE_NODE_LOCK) {
  1180. ut_error;
  1181. /*
  1182. thr = que_lock_step(thr);
  1183. */
  1184. } else if (type == QUE_NODE_THR) {
  1185. thr = que_thr_node_step(thr);
  1186. } else if (type == QUE_NODE_COMMIT) {
  1187. thr = trx_commit_step(thr);
  1188. } else if (type == QUE_NODE_UNDO) {
  1189. thr = row_undo_step(thr);
  1190. } else if (type == QUE_NODE_PURGE) {
  1191. thr = row_purge_step(thr);
  1192. } else if (type == QUE_NODE_RETURN) {
  1193. thr = return_step(thr);
  1194. } else if (type == QUE_NODE_ROLLBACK) {
  1195. thr = trx_rollback_step(thr);
  1196. } else if (type == QUE_NODE_CREATE_TABLE) {
  1197. thr = dict_create_table_step(thr);
  1198. } else if (type == QUE_NODE_CREATE_INDEX) {
  1199. thr = dict_create_index_step(thr);
  1200. } else if (type == QUE_NODE_ROW_PRINTF) {
  1201. thr = row_printf_step(thr);
  1202. } else {
  1203. ut_error;
  1204. }
  1206. old_thr->prev_node = node;
  1208. return(thr);
  1209. }
  1211. /**************************************************************************
  1212. Runs query threads. Note that the individual query thread which is run
  1213. within this function may change if, e.g., the OS thread executing this
  1214. function uses a threshold amount of resources. */
  1216. void
  1217. que_run_threads(
  1218. /*============*/
  1219. que_thr_t* thr) /* in: query thread which is run initially */
  1220. {
  1221. que_thr_t* next_thr;
  1222. ulint cumul_resource;
  1223. ulint loop_count;
  1225. ut_ad(thr->state == QUE_THR_RUNNING);
  1226. #ifdef UNIV_SYNC_DEBUG
  1227. ut_ad(!mutex_own(&kernel_mutex));
  1228. #endif /* UNIV_SYNC_DEBUG */
  1230. /* cumul_resource counts how much resources the OS thread (NOT the
  1231. query thread) has spent in this function */
  1233. loop_count = QUE_MAX_LOOPS_WITHOUT_CHECK;
  1234. cumul_resource = 0;
  1235. loop:
  1236. /* Check that there is enough space in the log to accommodate
  1237. possible log entries by this query step; if the operation can touch
  1238. more than about 4 pages, checks must be made also within the query
  1239. step! */
  1241. log_free_check();
  1243. /* Perform the actual query step: note that the query thread
  1244. may change if, e.g., a subprocedure call is made */
  1246. /*-------------------------*/
  1247. next_thr = que_thr_step(thr);
  1248. /*-------------------------*/
  1250. /* Test the effect on performance of adding extra mutex
  1251. reservations */
  1253. /* if (srv_test_extra_mutexes) {
  1254. mutex_enter(&kernel_mutex);
  1255. mutex_exit(&kernel_mutex);
  1256. }
  1257. */
  1258. loop_count++;
  1260. if (next_thr != thr) {
  1261. ut_a(next_thr == NULL);
  1262. que_thr_dec_refer_count(thr, &next_thr);
  1264. if (next_thr == NULL) {
  1266. return;
  1267. }
  1269. loop_count = QUE_MAX_LOOPS_WITHOUT_CHECK;
  1271. thr = next_thr;
  1272. }
  1274. goto loop;
  1275. }