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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The transaction
  3. (c) 1996 Innobase Oy
  4. Created 3/26/1996 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef trx0trx_h
  7. #define trx0trx_h
  8. #include "univ.i"
  9. #include "trx0types.h"
  10. #include "lock0types.h"
  11. #include "usr0types.h"
  12. #include "que0types.h"
  13. #include "mem0mem.h"
  14. #include "read0types.h"
  15. extern ulint trx_n_mysql_transactions;
  16. /************************************************************************
  17. Releases the search latch if trx has reserved it. */
  18. void
  19. trx_search_latch_release_if_reserved(
  20. /*=================================*/
  21.         trx_t*     trx); /* in: transaction */
  22. /********************************************************************
  23. Retrieves the error_info field from a trx. */
  24. void*
  25. trx_get_error_info(
  26. /*===============*/
  27.      /* out: the error info */
  28. trx_t*  trx); /* in: trx object */
  29. /********************************************************************
  30. Creates and initializes a transaction object. */
  31. trx_t*
  32. trx_create(
  33. /*=======*/
  34. /* out, own: the transaction */
  35. sess_t* sess); /* in: session or NULL */
  36. /************************************************************************
  37. Creates a transaction object for MySQL. */
  38. trx_t*
  39. trx_allocate_for_mysql(void);
  40. /*========================*/
  41. /* out, own: transaction object */
  42. /************************************************************************
  43. Creates a transaction object for background operations by the master thread. */
  44. trx_t*
  45. trx_allocate_for_background(void);
  46. /*=============================*/
  47. /* out, own: transaction object */
  48. /************************************************************************
  49. Frees a transaction object. */
  50. void
  51. trx_free(
  52. /*=====*/
  53. trx_t* trx); /* in, own: trx object */
  54. /************************************************************************
  55. Frees a transaction object for MySQL. */
  56. void
  57. trx_free_for_mysql(
  58. /*===============*/
  59. trx_t* trx); /* in, own: trx object */
  60. /************************************************************************
  61. Frees a transaction object of a background operation of the master thread. */
  62. void
  63. trx_free_for_background(
  64. /*====================*/
  65. trx_t* trx); /* in, own: trx object */
  66. /********************************************************************
  67. Creates trx objects for transactions and initializes the trx list of
  68. trx_sys at database start. Rollback segment and undo log lists must
  69. already exist when this function is called, because the lists of
  70. transactions to be rolled back or cleaned up are built based on the
  71. undo log lists. */
  72. void
  73. trx_lists_init_at_db_start(void);
  74. /*============================*/
  75. /********************************************************************
  76. Starts a new transaction. */
  77. ibool
  78. trx_start(
  79. /*======*/
  80. /* out: TRUE if success, FALSE if the rollback
  81. segment could not support this many transactions */
  82. trx_t*  trx, /* in: transaction */
  83. ulint rseg_id);/* in: rollback segment id; if ULINT_UNDEFINED
  84. is passed, the system chooses the rollback segment
  85. automatically in a round-robin fashion */
  86. /********************************************************************
  87. Starts a new transaction. */
  88. ibool
  89. trx_start_low(
  90. /*==========*/
  91. /* out: TRUE */
  92. trx_t*  trx, /* in: transaction */
  93. ulint rseg_id);/* in: rollback segment id; if ULINT_UNDEFINED
  94. is passed, the system chooses the rollback segment
  95. automatically in a round-robin fashion */
  96. /*****************************************************************
  97. Starts the transaction if it is not yet started. */
  98. UNIV_INLINE
  99. void
  100. trx_start_if_not_started(
  101. /*=====================*/
  102. trx_t* trx); /* in: transaction */
  103. /*****************************************************************
  104. Starts the transaction if it is not yet started. Assumes we have reserved
  105. the kernel mutex! */
  106. UNIV_INLINE
  107. void
  108. trx_start_if_not_started_low(
  109. /*=========================*/
  110. trx_t* trx); /* in: transaction */
  111. /*****************************************************************
  112. Starts the transaction if it is not yet started. */
  113. void
  114. trx_start_if_not_started_noninline(
  115. /*===============================*/
  116. trx_t* trx); /* in: transaction */
  117. /********************************************************************
  118. Commits a transaction. */
  119. void
  120. trx_commit_off_kernel(
  121. /*==================*/
  122. trx_t* trx); /* in: transaction */
  123. /********************************************************************
  124. Cleans up a transaction at database startup. The cleanup is needed if
  125. the transaction already got to the middle of a commit when the database
  126. crashed, andf we cannot roll it back. */
  127. void
  128. trx_cleanup_at_db_startup(
  129. /*======================*/
  130. trx_t* trx); /* in: transaction */
  131. /**************************************************************************
  132. Does the transaction commit for MySQL. */
  133. ulint
  134. trx_commit_for_mysql(
  135. /*=================*/
  136. /* out: 0 or error number */
  137. trx_t* trx); /* in: trx handle */
  138. /**************************************************************************
  139. If required, flushes the log to disk if we called trx_commit_for_mysql()
  140. with trx->flush_log_later == TRUE. */
  141. ulint
  142. trx_commit_complete_for_mysql(
  143. /*==========================*/
  144. /* out: 0 or error number */
  145. trx_t* trx); /* in: trx handle */
  146. /**************************************************************************
  147. Marks the latest SQL statement ended. */
  148. void
  149. trx_mark_sql_stat_end(
  150. /*==================*/
  151. trx_t* trx); /* in: trx handle */
  152. /************************************************************************
  153. Assigns a read view for a consistent read query. All the consistent reads
  154. within the same transaction will get the same read view, which is created
  155. when this function is first called for a new started transaction. */
  156. read_view_t*
  157. trx_assign_read_view(
  158. /*=================*/
  159. /* out: consistent read view */
  160. trx_t* trx); /* in: active transaction */
  161. /***************************************************************
  162. The transaction must be in the TRX_QUE_LOCK_WAIT state. Puts it to
  163. the TRX_QUE_RUNNING state and releases query threads which were
  164. waiting for a lock in the wait_thrs list. */
  165. void
  166. trx_end_lock_wait(
  167. /*==============*/
  168. trx_t* trx); /* in: transaction */
  169. /********************************************************************
  170. Sends a signal to a trx object. */
  171. ibool
  172. trx_sig_send(
  173. /*=========*/
  174. /* out: TRUE if the signal was
  175. successfully delivered */
  176. trx_t* trx, /* in: trx handle */
  177. ulint type, /* in: signal type */
  178. ulint sender, /* in: TRX_SIG_SELF or
  179. TRX_SIG_OTHER_SESS */
  180. que_thr_t* receiver_thr, /* in: query thread which wants the
  181. reply, or NULL; if type is
  182. TRX_SIG_END_WAIT, this must be NULL */
  183. trx_savept_t*  savept, /* in: possible rollback savepoint, or
  184. NULL */
  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 the parameter
  190. is NULL, it is ignored */
  191. /********************************************************************
  192. Send the reply message when a signal in the queue of the trx has
  193. been handled. */
  194. void
  195. trx_sig_reply(
  196. /*==========*/
  197. trx_sig_t* sig, /* in: signal */
  198. que_thr_t** next_thr); /* in/out: next query thread to run;
  199. if the value which is passed in is
  200. a pointer to a NULL pointer, then the
  201. calling function can start running
  202. a new query thread */
  203. /********************************************************************
  204. Removes the signal object from a trx signal queue. */
  205. void
  206. trx_sig_remove(
  207. /*===========*/
  208. trx_t* trx, /* in: trx handle */
  209. trx_sig_t* sig); /* in, own: signal */
  210. /********************************************************************
  211. Starts handling of a trx signal. */
  212. void
  213. trx_sig_start_handle(
  214. /*=================*/
  215. trx_t* trx, /* in: trx handle */
  216. que_thr_t** next_thr); /* in/out: next query thread to run;
  217. if the value which is passed in is
  218. a pointer to a NULL pointer, then the
  219. calling function can start running
  220. a new query thread */
  221. /********************************************************************
  222. Ends signal handling. If the session is in the error state, and
  223. trx->graph_before_signal_handling != NULL, returns control to the error
  224. handling routine of the graph (currently only returns the control to the
  225. graph root which then sends an error message to the client). */
  226. void
  227. trx_end_signal_handling(
  228. /*====================*/
  229. trx_t* trx); /* in: trx */
  230. /*************************************************************************
  231. Creates a commit command node struct. */
  232. commit_node_t*
  233. commit_node_create(
  234. /*===============*/
  235. /* out, own: commit node struct */
  236. mem_heap_t* heap); /* in: mem heap where created */
  237. /***************************************************************
  238. Performs an execution step for a commit type node in a query graph. */
  239. que_thr_t*
  240. trx_commit_step(
  241. /*============*/
  242. /* out: query thread to run next, or NULL */
  243. que_thr_t* thr); /* in: query thread */
  244. /**************************************************************************
  245. Prints info about a transaction to the standard output. The caller must
  246. own the kernel mutex and must have called
  247. innobase_mysql_prepare_print_arbitrary_thd(), unless he knows that MySQL or
  248. InnoDB cannot meanwhile change the info printed here. */
  249. void
  250. trx_print(
  251. /*======*/
  252. FILE* f, /* in: output stream */
  253. trx_t* trx); /* in: transaction */
  254. /* Signal to a transaction */
  255. struct trx_sig_struct{
  256. ulint type; /* signal type */
  257. ulint state; /* TRX_SIG_WAITING or
  258. TRX_SIG_BEING_HANDLED */
  259. ulint sender; /* TRX_SIG_SELF or
  260. TRX_SIG_OTHER_SESS */
  261. que_thr_t* receiver; /* non-NULL if the sender of the signal
  262. wants reply after the operation induced
  263. by the signal is completed */
  264. trx_savept_t savept; /* possible rollback savepoint */
  265. UT_LIST_NODE_T(trx_sig_t)
  266. signals; /* queue of pending signals to the
  267. transaction */
  268. UT_LIST_NODE_T(trx_sig_t)
  269. reply_signals; /* list of signals for which the sender
  270. transaction is waiting a reply */
  271. };
  272. #define TRX_MAGIC_N 91118598
  273. /* The transaction handle; every session has a trx object which is freed only
  274. when the session is freed; in addition there may be session-less transactions
  275. rolling back after a database recovery */
  276. struct trx_struct{
  277. ulint magic_n;
  278. /* All the next fields are protected by the kernel mutex, except the
  279. undo logs which are protected by undo_mutex */
  280. const char* op_info; /* English text describing the
  281. current operation, or an empty
  282. string */
  283. ulint type; /* TRX_USER, TRX_PURGE */
  284. ulint conc_state; /* state of the trx from the point
  285. of view of concurrency control:
  286. TRX_ACTIVE, TRX_COMMITTED_IN_MEMORY,
  287. ... */
  288.         time_t          start_time;     /* time the trx object was created
  289.                                         or the state last time became
  290.                                         TRX_ACTIVE */
  291. ulint isolation_level;/* TRX_ISO_REPEATABLE_READ, ... */
  292. ibool check_foreigns; /* normally TRUE, but if the user
  293. wants to suppress foreign key checks,
  294. (in table imports, for example) we
  295. set this FALSE */
  296. ibool check_unique_secondary;
  297. /* normally TRUE, but if the user
  298. wants to speed up inserts by
  299. suppressing unique key checks
  300. for secondary indexes when we decide
  301. if we can use the insert buffer for
  302. them, we set this FALSE */
  303. dulint id; /* transaction id */
  304. dulint no; /* transaction serialization number ==
  305. max trx id when the transaction is 
  306. moved to COMMITTED_IN_MEMORY state */
  307. ibool flush_log_later;/* when we commit the transaction
  308. in MySQL's binlog write, we will
  309. flush the log to disk later in
  310. a separate call */
  311. ibool must_flush_log_later;/* this flag is set to TRUE in
  312. trx_commit_off_kernel() if
  313. flush_log_later was TRUE, and there
  314. were modifications by the transaction;
  315. in that case we must flush the log
  316. in trx_commit_complete_for_mysql() */
  317. dulint commit_lsn; /* lsn at the time of the commit */
  318. ibool dict_operation; /* TRUE if the trx is used to create
  319. a table, create an index, or drop a
  320. table */
  321. dulint table_id; /* table id if the preceding field is
  322. TRUE */
  323. /*------------------------------*/
  324.         void*           mysql_thd;      /* MySQL thread handle corresponding
  325.                                         to this trx, or NULL */
  326. char** mysql_query_str;/* pointer to the field in mysqld_thd
  327. which contains the pointer to the
  328. current SQL query string */
  329. const char* mysql_log_file_name;
  330. /* if MySQL binlog is used, this field
  331. contains a pointer to the latest file
  332. name; this is NULL if binlog is not
  333. used */
  334. ib_longlong mysql_log_offset;/* if MySQL binlog is used, this field
  335. contains the end offset of the binlog
  336. entry */
  337. const char* mysql_master_log_file_name;
  338. /* if the database server is a MySQL
  339. replication slave, we have here the
  340. master binlog name up to which
  341. replication has processed; otherwise
  342. this is a pointer to a null
  343. character */
  344. ib_longlong mysql_master_log_pos;
  345. /* if the database server is a MySQL
  346. replication slave, this is the
  347. position in the log file up to which
  348. replication has processed */
  349. /* A MySQL variable mysql_thd->synchronous_repl tells if we have
  350. to use synchronous replication. See ha_innodb.cc. */
  351. char* repl_wait_binlog_name;/* NULL, or if synchronous MySQL
  352. replication is used, the binlog name
  353. up to which we must communicate the
  354. binlog to the slave, before returning
  355. from a commit; this is the same as
  356. mysql_log_file_name, but we allocate
  357. and copy the name to a separate buffer
  358. here */
  359. ib_longlong repl_wait_binlog_pos;/* see above at
  360. repl_wait_binlog_name */
  361. os_thread_id_t mysql_thread_id;/* id of the MySQL thread associated
  362. with this transaction object */
  363. ulint mysql_process_no;/* since in Linux, 'top' reports
  364. process id's and not thread id's, we
  365. store the process number too */
  366. /*------------------------------*/
  367. ulint n_mysql_tables_in_use; /* number of Innobase tables
  368. used in the processing of the current
  369. SQL statement in MySQL */
  370.         ulint           mysql_n_tables_locked;
  371.                                         /* how many tables the current SQL
  372. statement uses, except those
  373. in consistent read */
  374. ibool dict_operation_lock_mode;
  375. /* 0, RW_S_LATCH, or RW_X_LATCH:
  376. the latch mode trx currently holds
  377. on dict_operation_lock */
  378.         ibool           has_search_latch;
  379.                 /* TRUE if this trx has latched the
  380.                 search system latch in S-mode */
  381. ulint search_latch_timeout;
  382. /* If we notice that someone is
  383. waiting for our S-lock on the search
  384. latch to be released, we wait in
  385. row0sel.c for BTR_SEA_TIMEOUT new
  386. searches until we try to keep
  387. the search latch again over
  388. calls from MySQL; this is intended
  389. to reduce contention on the search
  390. latch */
  391. /*------------------------------*/
  392. ibool declared_to_be_inside_innodb;
  393. /* this is TRUE if we have declared
  394. this transaction in
  395. srv_conc_enter_innodb to be inside the
  396. InnoDB engine */
  397. ulint n_tickets_to_enter_innodb;
  398. /* this can be > 0 only when
  399. declared_to_... is TRUE; when we come
  400. to srv_conc_innodb_enter, if the value
  401. here is > 0, we decrement this by 1 */ 
  402. /*------------------------------*/
  403. lock_t* auto_inc_lock; /* possible auto-inc lock reserved by
  404. the transaction; note that it is also
  405. in the lock list trx_locks */
  406. ulint n_lock_table_exp;/* number of explicit table locks
  407. (LOCK TABLES) reserved by the
  408. transaction, stored in trx_locks */
  409. UT_LIST_NODE_T(trx_t)
  410. trx_list; /* list of transactions */
  411. UT_LIST_NODE_T(trx_t)
  412. mysql_trx_list; /* list of transactions created for
  413. MySQL */
  414. /*------------------------------*/
  415. ulint error_state; /* 0 if no error, otherwise error
  416. number; NOTE That ONLY the thread
  417. doing the transaction is allowed to
  418. set this field: this is NOT protected
  419. by the kernel mutex */
  420. void* error_info; /* if the error number indicates a
  421. duplicate key error, a pointer to
  422. the problematic index is stored here */
  423. sess_t* sess; /* session of the trx, NULL if none */
  424.   ulint que_state; /* TRX_QUE_RUNNING, TRX_QUE_LOCK_WAIT,
  425. ... */
  426. que_t* graph; /* query currently run in the session,
  427. or NULL if none; NOTE that the query
  428. belongs to the session, and it can
  429. survive over a transaction commit, if
  430. it is a stored procedure with a COMMIT
  431. WORK statement, for instance */
  432. ulint n_active_thrs; /* number of active query threads */
  433. ibool handling_signals;/* this is TRUE as long as the trx
  434. is handling signals */
  435. que_t* graph_before_signal_handling;
  436. /* value of graph when signal handling
  437. for this trx started: this is used to
  438. return control to the original query
  439. graph for error processing */
  440. trx_sig_t sig; /* one signal object can be allocated
  441. in this space, avoiding mem_alloc */
  442. UT_LIST_BASE_NODE_T(trx_sig_t)
  443. signals; /* queue of processed or pending
  444. signals to the trx */
  445. UT_LIST_BASE_NODE_T(trx_sig_t)
  446. reply_signals; /* list of signals sent by the query
  447. threads of this trx for which a thread
  448. is waiting for a reply; if this trx is
  449. killed, the reply requests in the list
  450. must be canceled */
  451. /*------------------------------*/
  452. lock_t* wait_lock; /* if trx execution state is
  453. TRX_QUE_LOCK_WAIT, this points to
  454. the lock request, otherwise this is
  455. NULL */
  456. ibool was_chosen_as_deadlock_victim;
  457. /* when the transaction decides to wait
  458. for a lock, this it sets this to FALSE;
  459. if another transaction chooses this
  460. transaction as a victim in deadlock
  461. resolution, it sets this to TRUE */
  462. time_t          wait_started;   /* lock wait started at this time */
  463. UT_LIST_BASE_NODE_T(que_thr_t)
  464. wait_thrs; /* query threads belonging to this
  465. trx that are in the QUE_THR_LOCK_WAIT
  466. state */
  467. ulint deadlock_mark; /* a mark field used in deadlock
  468. checking algorithm */
  469. /*------------------------------*/
  470. mem_heap_t* lock_heap; /* memory heap for the locks of the
  471. transaction */
  472. UT_LIST_BASE_NODE_T(lock_t) 
  473. trx_locks; /* locks reserved by the transaction */
  474. /*------------------------------*/
  475. mem_heap_t* read_view_heap; /* memory heap for the read view */
  476. read_view_t* read_view; /* consistent read view or NULL */
  477. /*------------------------------*/
  478. UT_LIST_BASE_NODE_T(trx_named_savept_t) 
  479. trx_savepoints; /* savepoints set with SAVEPOINT ...,
  480. oldest first */
  481. /*------------------------------*/
  482. mutex_t undo_mutex; /* mutex protecting the fields in this
  483. section (down to undo_no_arr), EXCEPT
  484. last_sql_stat_start, which can be
  485. accessed only when we know that there
  486. cannot be any activity in the undo
  487. logs! */
  488. dulint undo_no; /* next undo log record number to
  489. assign */
  490. trx_savept_t last_sql_stat_start;
  491. /* undo_no when the last sql statement
  492. was started: in case of an error, trx
  493. is rolled back down to this undo
  494. number; see note at undo_mutex! */
  495. trx_rseg_t* rseg; /* rollback segment assigned to the
  496. transaction, or NULL if not assigned
  497. yet */
  498. trx_undo_t* insert_undo; /* pointer to the insert undo log, or 
  499. NULL if no inserts performed yet */
  500. trx_undo_t*  update_undo; /* pointer to the update undo log, or
  501. NULL if no update performed yet */
  502. dulint roll_limit; /* least undo number to undo during
  503. a rollback */
  504. ulint pages_undone; /* number of undo log pages undone
  505. since the last undo log truncation */
  506. trx_undo_arr_t* undo_no_arr; /* array of undo numbers of undo log
  507. records which are currently processed
  508. by a rollback operation */
  509. };
  510. #define TRX_MAX_N_THREADS 32 /* maximum number of concurrent
  511. threads running a single operation of
  512. a transaction, e.g., a parallel query */
  513. /* Transaction types */
  514. #define TRX_USER 1 /* normal user transaction */
  515. #define TRX_PURGE 2 /* purge transaction: this is not
  516. inserted to the trx list of trx_sys
  517. and no rollback segment is assigned to
  518. this */
  519. /* Transaction concurrency states */
  520. #define TRX_NOT_STARTED 1
  521. #define TRX_ACTIVE 2
  522. #define TRX_COMMITTED_IN_MEMORY 3
  523. /* Transaction execution states when trx state is TRX_ACTIVE */
  524. #define TRX_QUE_RUNNING 1 /* transaction is running */
  525. #define TRX_QUE_LOCK_WAIT 2 /* transaction is waiting for a lock */
  526. #define TRX_QUE_ROLLING_BACK 3 /* transaction is rolling back */
  527. #define TRX_QUE_COMMITTING 4 /* transaction is committing */
  528. /* Transaction isolation levels */
  529. #define TRX_ISO_READ_UNCOMMITTED 1 /* dirty read: non-locking
  530. SELECTs are performed so that
  531. we do not look at a possible
  532. earlier version of a record;
  533. thus they are not 'consistent'
  534. reads under this isolation
  535. level; otherwise like level
  536. 2 */
  537. #define TRX_ISO_READ_COMMITTED 2 /* somewhat Oracle-like
  538. isolation, except that in
  539. range UPDATE and DELETE we
  540. must block phantom rows
  541. with next-key locks;
  542. SELECT ... FOR UPDATE and ...
  543. LOCK IN SHARE MODE only lock
  544. the index records, NOT the
  545. gaps before them, and thus
  546. allow free inserting;
  547. each consistent read reads its
  548. own snapshot */
  549. #define TRX_ISO_REPEATABLE_READ 3 /* this is the default;
  550. all consistent reads in the
  551. same trx read the same
  552. snapshot;
  553. full next-key locking used
  554. in locking reads to block
  555. insertions into gaps */
  556. #define TRX_ISO_SERIALIZABLE 4 /* all plain SELECTs are
  557. converted to LOCK IN SHARE
  558. MODE reads */
  559. /* Types of a trx signal */
  560. #define TRX_SIG_NO_SIGNAL 100
  561. #define TRX_SIG_TOTAL_ROLLBACK 1
  562. #define TRX_SIG_ROLLBACK_TO_SAVEPT 2
  563. #define TRX_SIG_COMMIT 3
  564. #define TRX_SIG_ERROR_OCCURRED 4
  565. #define TRX_SIG_BREAK_EXECUTION 5
  566. /* Sender types of a signal */
  567. #define TRX_SIG_SELF 1 /* sent by the session itself, or
  568. by an error occurring within this
  569. session */
  570. #define TRX_SIG_OTHER_SESS 2 /* sent by another session (which
  571. must hold rights to this) */
  572. /* Signal states */
  573. #define TRX_SIG_WAITING 1
  574. #define TRX_SIG_BEING_HANDLED 2
  575. /* Commit command node in a query graph */
  576. struct commit_node_struct{
  577. que_common_t common; /* node type: QUE_NODE_COMMIT */
  578. ulint state; /* node execution state */
  579. };
  580. /* Commit node states */
  581. #define COMMIT_NODE_SEND 1
  582. #define COMMIT_NODE_WAIT 2
  583. #ifndef UNIV_NONINL
  584. #include "trx0trx.ic"
  585. #endif
  586. #endif