que0que.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:17k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Query graph
  3. (c) 1996 Innobase Oy
  4. Created 5/27/1996 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef que0que_h
  7. #define que0que_h
  8. #include "univ.i"
  9. #include "data0data.h"
  10. #include "dict0types.h"
  11. #include "trx0trx.h"
  12. #include "srv0srv.h"
  13. #include "usr0types.h"
  14. #include "que0types.h"
  15. #include "row0types.h"
  16. #include "pars0types.h"
  17. /* If the following flag is set TRUE, the module will print trace info
  18. of SQL execution in the UNIV_SQL_DEBUG version */
  19. extern ibool que_trace_on;
  20. /***************************************************************************
  21. Adds a query graph to the session's list of graphs. */
  22. void
  23. que_graph_publish(
  24. /*==============*/
  25. que_t* graph, /* in: graph */
  26. sess_t* sess); /* in: session */
  27. /***************************************************************************
  28. Creates a query graph fork node. */
  29. que_fork_t*
  30. que_fork_create(
  31. /*============*/
  32. /* out, own: fork node */
  33. que_t* graph, /* in: graph, if NULL then this
  34. fork node is assumed to be the
  35. graph root */
  36. que_node_t* parent, /* in: parent node */
  37. ulint fork_type, /* in: fork type */
  38. mem_heap_t* heap); /* in: memory heap where created */
  39. /***************************************************************************
  40. Gets the first thr in a fork. */
  41. UNIV_INLINE
  42. que_thr_t*
  43. que_fork_get_first_thr(
  44. /*===================*/
  45. que_fork_t* fork);  /* in: query fork */
  46. /***************************************************************************
  47. Gets the child node of the first thr in a fork. */
  48. UNIV_INLINE
  49. que_node_t*
  50. que_fork_get_child(
  51. /*===============*/
  52. que_fork_t* fork); /* in: query fork */
  53. /***************************************************************************
  54. Sets the parent of a graph node. */
  55. UNIV_INLINE
  56. void
  57. que_node_set_parent(
  58. /*================*/
  59. que_node_t* node, /* in: graph node */
  60. que_node_t* parent);/* in: parent */
  61. /***************************************************************************
  62. Creates a query graph thread node. */
  63. que_thr_t*
  64. que_thr_create(
  65. /*===========*/
  66. /* out, own: query thread node */
  67. que_fork_t* parent, /* in: parent node, i.e., a fork node */
  68. mem_heap_t* heap); /* in: memory heap where created */
  69. /**************************************************************************
  70. Checks if the query graph is in a state where it should be freed, and
  71. frees it in that case. If the session is in a state where it should be
  72. closed, also this is done. */
  73. ibool
  74. que_graph_try_free(
  75. /*===============*/
  76. /* out: TRUE if freed */
  77. que_t* graph); /* in: query graph */
  78. /**************************************************************************
  79. Frees a query graph, but not the heap where it was created. Does not free
  80. explicit cursor declarations, they are freed in que_graph_free. */
  81. void
  82. que_graph_free_recursive(
  83. /*=====================*/
  84. que_node_t* node); /* in: query graph node */
  85. /**************************************************************************
  86. Frees a query graph. */
  87. void
  88. que_graph_free(
  89. /*===========*/
  90. que_t* graph); /* in: query graph; we assume that the memory
  91. heap where this graph was created is private
  92. to this graph: if not, then use
  93. que_graph_free_recursive and free the heap
  94. afterwards! */
  95. /**************************************************************************
  96. Stops a query thread if graph or trx is in a state requiring it. The
  97. conditions are tested in the order (1) graph, (2) trx. The kernel mutex has
  98. to be reserved. */
  99. ibool
  100. que_thr_stop(
  101. /*=========*/
  102. /* out: TRUE if stopped */
  103. que_thr_t* thr); /* in: query thread */
  104. /**************************************************************************
  105. Moves a thread from another state to the QUE_THR_RUNNING state. Increments
  106. the n_active_thrs counters of the query graph and transaction. */
  107. void
  108. que_thr_move_to_run_state_for_mysql(
  109. /*================================*/
  110. que_thr_t* thr, /* in: an query thread */
  111. trx_t* trx); /* in: transaction */
  112. /**************************************************************************
  113. A patch for MySQL used to 'stop' a dummy query thread used in MySQL
  114. select, when there is no error or lock wait. */
  115. void
  116. que_thr_stop_for_mysql_no_error(
  117. /*============================*/
  118. que_thr_t* thr, /* in: query thread */
  119. trx_t* trx); /* in: transaction */
  120. /**************************************************************************
  121. A patch for MySQL used to 'stop' a dummy query thread used in MySQL. The
  122. query thread is stopped and made inactive, except in the case where
  123. it was put to the lock wait state in lock0lock.c, but the lock has already
  124. been granted or the transaction chosen as a victim in deadlock resolution. */
  125. void
  126. que_thr_stop_for_mysql(
  127. /*===================*/
  128. que_thr_t* thr); /* in: query thread */
  129. /**************************************************************************
  130. Runs query threads. Note that the individual query thread which is run
  131. within this function may change if, e.g., the OS thread executing this
  132. function uses a threshold amount of resources. */
  133. void
  134. que_run_threads(
  135. /*============*/
  136. que_thr_t* thr); /* in: query thread which is run initially */
  137. /**************************************************************************
  138. After signal handling is finished, returns control to a query graph error
  139. handling routine. (Currently, just returns the control to the root of the
  140. graph so that the graph can communicate an error message to the client.) */
  141. void
  142. que_fork_error_handle(
  143. /*==================*/
  144. trx_t* trx, /* in: trx */
  145. que_t* fork); /* in: query graph which was run before signal
  146. handling started, NULL not allowed */
  147. /**************************************************************************
  148. Handles an SQL error noticed during query thread execution. At the moment,
  149. does nothing! */
  150. void
  151. que_thr_handle_error(
  152. /*=================*/
  153. que_thr_t* thr, /* in: query thread */
  154. ulint err_no, /* in: error number */
  155. byte* err_str,/* in, own: error string or NULL; NOTE: the
  156. function will take care of freeing of the
  157. string! */
  158. ulint err_len);/* in: error string length */
  159. /**************************************************************************
  160. Moves a suspended query thread to the QUE_THR_RUNNING state and releases
  161. a single worker thread to execute it. This function should be used to end
  162. the wait state of a query thread waiting for a lock or a stored procedure
  163. completion. */
  164. void
  165. que_thr_end_wait(
  166. /*=============*/
  167. que_thr_t* thr, /* in: query thread in the
  168. QUE_THR_LOCK_WAIT,
  169. or QUE_THR_PROCEDURE_WAIT, or
  170. QUE_THR_SIG_REPLY_WAIT state */
  171. que_thr_t** next_thr); /* in/out: next query thread to run;
  172. if the value which is passed in is
  173. a pointer to a NULL pointer, then the
  174. calling function can start running
  175. a new query thread */
  176. /**************************************************************************
  177. Same as que_thr_end_wait, but no parameter next_thr available. */
  178. void
  179. que_thr_end_wait_no_next_thr(
  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. /**************************************************************************
  186. Starts execution of a command in a query fork. Picks a query thread which
  187. is not in the QUE_THR_RUNNING state and moves it to that state. If none
  188. can be chosen, a situation which may arise in parallelized fetches, NULL
  189. is returned. */
  190. que_thr_t*
  191. que_fork_start_command(
  192. /*===================*/
  193. /* out: a query thread of the graph moved to
  194. QUE_THR_RUNNING state, or NULL; the query
  195. thread should be executed by que_run_threads
  196. by the caller */
  197. que_fork_t*  fork); /* in: a query fork */
  198. /***************************************************************************
  199. Gets the trx of a query thread. */
  200. UNIV_INLINE
  201. trx_t*
  202. thr_get_trx(
  203. /*========*/
  204. que_thr_t* thr); /* in: query thread */
  205. /***************************************************************************
  206. Gets the type of a graph node. */
  207. UNIV_INLINE
  208. ulint
  209. que_node_get_type(
  210. /*==============*/
  211. que_node_t* node); /* in: graph node */
  212. /***************************************************************************
  213. Gets pointer to the value data type field of a graph node. */
  214. UNIV_INLINE
  215. dtype_t*
  216. que_node_get_data_type(
  217. /*===================*/
  218. que_node_t* node); /* in: graph node */
  219. /***************************************************************************
  220. Gets pointer to the value dfield of a graph node. */
  221. UNIV_INLINE
  222. dfield_t*
  223. que_node_get_val(
  224. /*=============*/
  225. que_node_t* node); /* in: graph node */
  226. /***************************************************************************
  227. Gets the value buffer size of a graph node. */
  228. UNIV_INLINE
  229. ulint
  230. que_node_get_val_buf_size(
  231. /*======================*/
  232. /* out: val buffer size, not defined if
  233. val.data == NULL in node */
  234. que_node_t* node); /* in: graph node */
  235. /***************************************************************************
  236. Sets the value buffer size of a graph node. */
  237. UNIV_INLINE
  238. void
  239. que_node_set_val_buf_size(
  240. /*======================*/
  241. que_node_t* node, /* in: graph node */
  242. ulint size); /* in: size */
  243. /*************************************************************************
  244. Gets the next list node in a list of query graph nodes. */
  245. UNIV_INLINE
  246. que_node_t*
  247. que_node_get_next(
  248. /*==============*/
  249. que_node_t* node); /* in: node in a list */
  250. /*************************************************************************
  251. Gets the parent node of a query graph node. */
  252. UNIV_INLINE
  253. que_node_t*
  254. que_node_get_parent(
  255. /*================*/
  256. /* out: parent node or NULL */
  257. que_node_t* node); /* in: node */
  258. /*************************************************************************
  259. Catenates a query graph node to a list of them, possible empty list. */
  260. UNIV_INLINE
  261. que_node_t*
  262. que_node_list_add_last(
  263. /*===================*/
  264. /* out: one-way list of nodes */
  265. que_node_t* node_list, /* in: node list, or NULL */
  266. que_node_t* node); /* in: node */
  267. /*************************************************************************
  268. Gets a query graph node list length. */
  269. UNIV_INLINE
  270. ulint
  271. que_node_list_get_len(
  272. /*==================*/
  273. /* out: length, for NULL list 0 */
  274. que_node_t* node_list); /* in: node list, or NULL */
  275. /**************************************************************************
  276. Checks if graph, trx, or session is in a state where the query thread should
  277. be stopped. */
  278. UNIV_INLINE
  279. ibool
  280. que_thr_peek_stop(
  281. /*==============*/
  282. /* out: TRUE if should be stopped; NOTE that
  283. if the peek is made without reserving the
  284. kernel mutex, then another peek with the
  285. mutex reserved is necessary before deciding
  286. the actual stopping */
  287. que_thr_t* thr); /* in: query thread */
  288. /***************************************************************************
  289. Returns TRUE if the query graph is for a SELECT statement. */
  290. UNIV_INLINE
  291. ibool
  292. que_graph_is_select(
  293. /*================*/
  294. /* out: TRUE if a select */
  295. que_t* graph); /* in: graph */
  296. /**************************************************************************
  297. Prints info of an SQL query graph node. */
  298. void
  299. que_node_print_info(
  300. /*================*/
  301. que_node_t* node); /* in: query graph node */
  302. /* Query graph query thread node: the fields are protected by the kernel
  303. mutex with the exceptions named below */
  304. struct que_thr_struct{
  305. que_common_t common; /* type: QUE_NODE_THR */
  306. ulint magic_n; /* magic number to catch memory
  307. corruption */
  308. que_node_t* child; /* graph child node */
  309. que_t* graph; /* graph where this node belongs */
  310. ibool is_active; /* TRUE if the thread has been set
  311. to the run state in
  312. que_thr_move_to_run_state, but not
  313. deactivated in
  314. que_thr_dec_reference_count */
  315. ulint state; /* state of the query thread */
  316. UT_LIST_NODE_T(que_thr_t)
  317. thrs; /* list of thread nodes of the fork
  318. node */
  319. UT_LIST_NODE_T(que_thr_t)
  320. trx_thrs; /* lists of threads in wait list of
  321. the trx */
  322. UT_LIST_NODE_T(que_thr_t)
  323. queue; /* list of runnable thread nodes in
  324. the server task queue */
  325. /*------------------------------*/
  326. /* The following fields are private to the OS thread executing the
  327. query thread, and are not protected by the kernel mutex: */
  328. que_node_t* run_node; /* pointer to the node where the
  329. subgraph down from this node is
  330. currently executed */
  331. que_node_t* prev_node; /* pointer to the node from which
  332. the control came */
  333. ulint resource; /* resource usage of the query thread
  334. thus far */
  335. };
  336. #define QUE_THR_MAGIC_N 8476583
  337. #define QUE_THR_MAGIC_FREED 123461526
  338. /* Query graph fork node: its fields are protected by the kernel mutex */
  339. struct que_fork_struct{
  340. que_common_t common; /* type: QUE_NODE_FORK */
  341. que_t* graph; /* query graph of this node */
  342. ulint fork_type; /* fork type */
  343. ulint n_active_thrs; /* if this is the root of a graph, the
  344. number query threads that have been
  345. started in que_thr_move_to_run_state
  346. but for which que_thr_dec_refer_count
  347. has not yet been called */
  348. trx_t* trx; /* transaction: this is set only in
  349. the root node */
  350. ulint state; /* state of the fork node */
  351. que_thr_t* caller; /* pointer to a possible calling query
  352. thread */
  353. UT_LIST_BASE_NODE_T(que_thr_t)
  354. thrs; /* list of query threads */
  355. /*------------------------------*/
  356. /* The fields in this section are defined only in the root node */
  357. sym_tab_t* sym_tab; /* symbol table of the query,
  358. generated by the parser, or NULL
  359. if the graph was created 'by hand' */
  360. /* The following cur_... fields are relevant only in a select graph */
  361. ulint cur_end; /* QUE_CUR_NOT_DEFINED, QUE_CUR_START,
  362. QUE_CUR_END */
  363. ulint cur_pos; /* if there are n rows in the result
  364. set, values 0 and n + 1 mean before
  365. first row, or after last row, depending
  366. on cur_end; values 1...n mean a row
  367. index */
  368. ibool cur_on_row; /* TRUE if cursor is on a row, i.e.,
  369. it is not before the first row or
  370. after the last row */
  371. dulint n_inserts; /* number of rows inserted */
  372. dulint n_updates; /* number of rows updated */
  373. dulint n_deletes; /* number of rows deleted */
  374. sel_node_t* last_sel_node; /* last executed select node, or NULL
  375. if none */
  376. UT_LIST_NODE_T(que_fork_t)
  377. graphs; /* list of query graphs of a session
  378. or a stored procedure */
  379. /*------------------------------*/
  380. mem_heap_t* heap; /* memory heap where the fork was
  381. created */
  382. };
  383. /* Query fork (or graph) types */
  384. #define QUE_FORK_SELECT_NON_SCROLL 1 /* forward-only cursor */
  385. #define QUE_FORK_SELECT_SCROLL 2 /* scrollable cursor */
  386. #define QUE_FORK_INSERT 3
  387. #define QUE_FORK_UPDATE 4
  388. #define QUE_FORK_ROLLBACK 5
  389. /* This is really the undo graph used in rollback,
  390. no signal-sending roll_node in this graph */
  391. #define QUE_FORK_PURGE 6
  392. #define QUE_FORK_EXECUTE 7
  393. #define QUE_FORK_PROCEDURE 8
  394. #define QUE_FORK_PROCEDURE_CALL 9
  395. #define QUE_FORK_MYSQL_INTERFACE 10
  396. #define QUE_FORK_RECOVERY 11
  397. /* Query fork (or graph) states */
  398. #define QUE_FORK_ACTIVE 1
  399. #define QUE_FORK_COMMAND_WAIT 2
  400. #define QUE_FORK_INVALID 3
  401. #define QUE_FORK_BEING_FREED 4
  402. /* Flag which is ORed to control structure statement node types */
  403. #define QUE_NODE_CONTROL_STAT 1024
  404. /* Query graph node types */
  405. #define QUE_NODE_LOCK 1
  406. #define QUE_NODE_INSERT 2
  407. #define QUE_NODE_UPDATE 4
  408. #define QUE_NODE_CURSOR 5
  409. #define QUE_NODE_SELECT 6
  410. #define QUE_NODE_AGGREGATE 7
  411. #define QUE_NODE_FORK 8
  412. #define QUE_NODE_THR 9
  413. #define QUE_NODE_UNDO 10
  414. #define QUE_NODE_COMMIT 11
  415. #define QUE_NODE_ROLLBACK 12
  416. #define QUE_NODE_PURGE 13
  417. #define QUE_NODE_CREATE_TABLE 14
  418. #define QUE_NODE_CREATE_INDEX 15
  419. #define QUE_NODE_SYMBOL 16
  420. #define QUE_NODE_RES_WORD 17
  421. #define QUE_NODE_FUNC 18
  422. #define QUE_NODE_ORDER 19
  423. #define QUE_NODE_PROC (20 + QUE_NODE_CONTROL_STAT)
  424. #define QUE_NODE_IF (21 + QUE_NODE_CONTROL_STAT)
  425. #define QUE_NODE_WHILE (22 + QUE_NODE_CONTROL_STAT)
  426. #define QUE_NODE_ASSIGNMENT 23
  427. #define QUE_NODE_FETCH 24
  428. #define QUE_NODE_OPEN 25
  429. #define QUE_NODE_COL_ASSIGNMENT 26
  430. #define QUE_NODE_FOR (27 + QUE_NODE_CONTROL_STAT)
  431. #define QUE_NODE_RETURN 28
  432. #define QUE_NODE_ROW_PRINTF 29
  433. #define QUE_NODE_ELSIF 30
  434. #define QUE_NODE_CALL 31
  435. /* Query thread states */
  436. #define QUE_THR_RUNNING 1
  437. #define QUE_THR_PROCEDURE_WAIT 2
  438. #define QUE_THR_COMPLETED 3 /* in selects this means that the
  439. thread is at the end of its result set
  440. (or start, in case of a scroll cursor);
  441. in other statements, this means the
  442. thread has done its task */
  443. #define QUE_THR_COMMAND_WAIT 4
  444. #define QUE_THR_LOCK_WAIT 5
  445. #define QUE_THR_SIG_REPLY_WAIT 6
  446. #define QUE_THR_SUSPENDED 7
  447. #define QUE_THR_ERROR 8
  448. /* From where the cursor position is counted */
  449. #define QUE_CUR_NOT_DEFINED 1
  450. #define QUE_CUR_START 2
  451. #define QUE_CUR_END 3
  452. #ifndef UNIV_NONINL
  453. #include "que0que.ic"
  454. #endif
  455. #endif