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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The index tree cursor
  3. (c) 1994-1996 Innobase Oy
  4. Created 10/16/1994 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef btr0cur_h
  7. #define btr0cur_h
  8. #include "univ.i"
  9. #include "dict0dict.h"
  10. #include "data0data.h"
  11. #include "page0cur.h"
  12. #include "btr0types.h"
  13. #include "que0types.h"
  14. #include "row0types.h"
  15. #include "ha0ha.h"
  16. /* Mode flags for btr_cur operations; these can be ORed */
  17. #define BTR_NO_UNDO_LOG_FLAG 1 /* do no undo logging */
  18. #define BTR_NO_LOCKING_FLAG 2 /* do no record lock checking */
  19. #define BTR_KEEP_SYS_FLAG 4 /* sys fields will be found from the
  20. update vector or inserted entry */
  21. #define BTR_CUR_ADAPT
  22. #define BTR_CUR_HASH_ADAPT
  23. /*************************************************************
  24. Returns the page cursor component of a tree cursor. */
  25. UNIV_INLINE
  26. page_cur_t*
  27. btr_cur_get_page_cur(
  28. /*=================*/
  29. /* out: pointer to page cursor component */
  30. btr_cur_t* cursor); /* in: tree cursor */
  31. /*************************************************************
  32. Returns the record pointer of a tree cursor. */
  33. UNIV_INLINE
  34. rec_t*
  35. btr_cur_get_rec(
  36. /*============*/
  37. /* out: pointer to record */
  38. btr_cur_t* cursor); /* in: tree cursor */
  39. /*************************************************************
  40. Invalidates a tree cursor by setting record pointer to NULL. */
  41. UNIV_INLINE
  42. void
  43. btr_cur_invalidate(
  44. /*===============*/
  45. btr_cur_t* cursor); /* in: tree cursor */
  46. /*************************************************************
  47. Returns the page of a tree cursor. */
  48. UNIV_INLINE
  49. page_t*
  50. btr_cur_get_page(
  51. /*=============*/
  52. /* out: pointer to page */
  53. btr_cur_t* cursor); /* in: tree cursor */
  54. /*************************************************************
  55. Returns the tree of a cursor. */
  56. UNIV_INLINE
  57. dict_tree_t*
  58. btr_cur_get_tree(
  59. /*=============*/
  60. /* out: tree */
  61. btr_cur_t* cursor); /* in: tree cursor */
  62. /*************************************************************
  63. Positions a tree cursor at a given record. */
  64. UNIV_INLINE
  65. void
  66. btr_cur_position(
  67. /*=============*/
  68. dict_index_t* index,  /* in: index */
  69. rec_t* rec, /* in: record in tree */
  70. btr_cur_t* cursor);/* in: cursor */
  71. /************************************************************************
  72. Searches an index tree and positions a tree cursor on a given level.
  73. NOTE: n_fields_cmp in tuple must be set so that it cannot be compared
  74. to node pointer page number fields on the upper levels of the tree!
  75. Note that if mode is PAGE_CUR_LE, which is used in inserts, then
  76. cursor->up_match and cursor->low_match both will have sensible values.
  77. If mode is PAGE_CUR_GE, then up_match will a have a sensible value. */
  78. void
  79. btr_cur_search_to_nth_level(
  80. /*========================*/
  81. dict_index_t* index, /* in: index */
  82. ulint level, /* in: the tree level of search */
  83. dtuple_t* tuple, /* in: data tuple; NOTE: n_fields_cmp in
  84. tuple must be set so that it cannot get
  85. compared to the node ptr page number field! */
  86. ulint mode, /* in: PAGE_CUR_L, ...;
  87. NOTE that if the search is made using a unique
  88. prefix of a record, mode should be PAGE_CUR_LE,
  89. not PAGE_CUR_GE, as the latter may end up on
  90. the previous page of the record! Inserts
  91. should always be made using PAGE_CUR_LE to
  92. search the position! */
  93. ulint latch_mode, /* in: BTR_SEARCH_LEAF, ..., ORed with
  94. BTR_INSERT and BTR_ESTIMATE;
  95. cursor->left_page is used to store a pointer
  96. to the left neighbor page, in the cases
  97. BTR_SEARCH_PREV and BTR_MODIFY_PREV;
  98. NOTE that if has_search_latch
  99. is != 0, we maybe do not have a latch set
  100. on the cursor page, we assume
  101. the caller uses his search latch
  102. to protect the record! */
  103. btr_cur_t* cursor, /* in/out: tree cursor; the cursor page is
  104. s- or x-latched, but see also above! */
  105. ulint has_search_latch,/* in: latch mode the caller
  106. currently has on btr_search_latch:
  107. RW_S_LATCH, or 0 */
  108. mtr_t* mtr); /* in: mtr */
  109. /*********************************************************************
  110. Opens a cursor at either end of an index. */
  111. void
  112. btr_cur_open_at_index_side(
  113. /*=======================*/
  114. ibool from_left, /* in: TRUE if open to the low end,
  115. FALSE if to the high end */
  116. dict_index_t* index, /* in: index */
  117. ulint latch_mode, /* in: latch mode */
  118. btr_cur_t* cursor, /* in: cursor */
  119. mtr_t* mtr); /* in: mtr */
  120. /**************************************************************************
  121. Positions a cursor at a randomly chosen position within a B-tree. */
  122. void
  123. btr_cur_open_at_rnd_pos(
  124. /*====================*/
  125. dict_index_t* index, /* in: index */
  126. ulint latch_mode, /* in: BTR_SEARCH_LEAF, ... */
  127. btr_cur_t* cursor, /* in/out: B-tree cursor */
  128. mtr_t* mtr); /* in: mtr */
  129. /*****************************************************************
  130. Tries to perform an insert to a page in an index tree, next to cursor.
  131. It is assumed that mtr holds an x-latch on the page. The operation does
  132. not succeed if there is too little space on the page. If there is just
  133. one record on the page, the insert will always succeed; this is to
  134. prevent trying to split a page with just one record. */
  135. ulint
  136. btr_cur_optimistic_insert(
  137. /*======================*/
  138. /* out: DB_SUCCESS, DB_WAIT_LOCK,
  139. DB_FAIL, or error number */
  140. ulint flags, /* in: undo logging and locking flags: if not
  141. zero, the parameters index and thr should be
  142. specified */
  143. btr_cur_t* cursor, /* in: cursor on page after which to insert;
  144. cursor stays valid */
  145. dtuple_t* entry, /* in: entry to insert */
  146. rec_t** rec, /* out: pointer to inserted record if
  147. succeed */
  148. big_rec_t** big_rec,/* out: big rec vector whose fields have to
  149. be stored externally by the caller, or
  150. NULL */
  151. que_thr_t* thr, /* in: query thread or NULL */
  152. mtr_t* mtr); /* in: mtr */
  153. /*****************************************************************
  154. Performs an insert on a page of an index tree. It is assumed that mtr
  155. holds an x-latch on the tree and on the cursor page. If the insert is
  156. made on the leaf level, to avoid deadlocks, mtr must also own x-latches
  157. to brothers of page, if those brothers exist. */
  158. ulint
  159. btr_cur_pessimistic_insert(
  160. /*=======================*/
  161. /* out: DB_SUCCESS or error number */
  162. ulint flags, /* in: undo logging and locking flags: if not
  163. zero, the parameter thr should be
  164. specified; if no undo logging is specified,
  165. then the caller must have reserved enough
  166. free extents in the file space so that the
  167. insertion will certainly succeed */
  168. btr_cur_t* cursor, /* in: cursor after which to insert;
  169. cursor stays valid */
  170. dtuple_t* entry, /* in: entry to insert */
  171. rec_t** rec, /* out: pointer to inserted record if
  172. succeed */
  173. big_rec_t** big_rec,/* out: big rec vector whose fields have to
  174. be stored externally by the caller, or
  175. NULL */
  176. que_thr_t* thr, /* in: query thread or NULL */
  177. mtr_t* mtr); /* in: mtr */
  178. /*****************************************************************
  179. Updates a record when the update causes no size changes in its fields. */
  180. ulint
  181. btr_cur_update_in_place(
  182. /*====================*/
  183. /* out: DB_SUCCESS or error number */
  184. ulint flags, /* in: undo logging and locking flags */
  185. btr_cur_t* cursor, /* in: cursor on the record to update;
  186. cursor stays valid and positioned on the
  187. same record */
  188. upd_t* update, /* in: update vector */
  189. ulint cmpl_info,/* in: compiler info on secondary index
  190. updates */
  191. que_thr_t* thr, /* in: query thread */
  192. mtr_t* mtr); /* in: mtr */
  193. /*****************************************************************
  194. Tries to update a record on a page in an index tree. It is assumed that mtr
  195. holds an x-latch on the page. The operation does not succeed if there is too
  196. little space on the page or if the update would result in too empty a page,
  197. so that tree compression is recommended. */
  198. ulint
  199. btr_cur_optimistic_update(
  200. /*======================*/
  201. /* out: DB_SUCCESS, or DB_OVERFLOW if the
  202. updated record does not fit, DB_UNDERFLOW
  203. if the page would become too empty */
  204. ulint flags, /* in: undo logging and locking flags */
  205. btr_cur_t* cursor, /* in: cursor on the record to update;
  206. cursor stays valid and positioned on the
  207. same record */
  208. upd_t* update, /* in: update vector; this must also
  209. contain trx id and roll ptr fields */
  210. ulint cmpl_info,/* in: compiler info on secondary index
  211. updates */
  212. que_thr_t* thr, /* in: query thread */
  213. mtr_t* mtr); /* in: mtr */
  214. /*****************************************************************
  215. Performs an update of a record on a page of a tree. It is assumed
  216. that mtr holds an x-latch on the tree and on the cursor page. If the
  217. update is made on the leaf level, to avoid deadlocks, mtr must also
  218. own x-latches to brothers of page, if those brothers exist. */
  219. ulint
  220. btr_cur_pessimistic_update(
  221. /*=======================*/
  222. /* out: DB_SUCCESS or error code */
  223. ulint flags, /* in: undo logging, locking, and rollback
  224. flags */
  225. btr_cur_t* cursor, /* in: cursor on the record to update */
  226. big_rec_t** big_rec,/* out: big rec vector whose fields have to
  227. be stored externally by the caller, or NULL */
  228. upd_t* update, /* in: update vector; this is allowed also
  229. contain trx id and roll ptr fields, but
  230. the values in update vector have no effect */
  231. ulint cmpl_info,/* in: compiler info on secondary index
  232. updates */
  233. que_thr_t* thr, /* in: query thread */
  234. mtr_t* mtr); /* in: mtr */
  235. /***************************************************************
  236. Marks a clustered index record deleted. Writes an undo log record to
  237. undo log on this delete marking. Writes in the trx id field the id
  238. of the deleting transaction, and in the roll ptr field pointer to the
  239. undo log record created. */
  240. ulint
  241. btr_cur_del_mark_set_clust_rec(
  242. /*===========================*/
  243. /* out: DB_SUCCESS, DB_LOCK_WAIT, or error
  244. number */
  245. ulint flags, /* in: undo logging and locking flags */
  246. btr_cur_t* cursor, /* in: cursor */
  247. ibool val, /* in: value to set */
  248. que_thr_t* thr, /* in: query thread */
  249. mtr_t* mtr); /* in: mtr */
  250. /***************************************************************
  251. Sets a secondary index record delete mark to TRUE or FALSE. */
  252. ulint
  253. btr_cur_del_mark_set_sec_rec(
  254. /*=========================*/
  255. /* out: DB_SUCCESS, DB_LOCK_WAIT, or error
  256. number */
  257. ulint flags, /* in: locking flag */
  258. btr_cur_t* cursor, /* in: cursor */
  259. ibool val, /* in: value to set */
  260. que_thr_t* thr, /* in: query thread */
  261. mtr_t* mtr); /* in: mtr */
  262. /***************************************************************
  263. Sets a secondary index record delete mark to FALSE. This function is
  264. only used by the insert buffer insert merge mechanism. */
  265. void
  266. btr_cur_del_unmark_for_ibuf(
  267. /*========================*/
  268. rec_t* rec, /* in: record to delete unmark */
  269. mtr_t* mtr); /* in: mtr */
  270. /*****************************************************************
  271. Tries to compress a page of the tree on the leaf level. It is assumed
  272. that mtr holds an x-latch on the tree and on the cursor page. To avoid
  273. deadlocks, mtr must also own x-latches to brothers of page, if those
  274. brothers exist. NOTE: it is assumed that the caller has reserved enough
  275. free extents so that the compression will always succeed if done! */
  276. void
  277. btr_cur_compress(
  278. /*=============*/
  279. btr_cur_t* cursor, /* in: cursor on the page to compress;
  280. cursor does not stay valid */
  281. mtr_t* mtr); /* in: mtr */
  282. /*****************************************************************
  283. Tries to compress a page of the tree if it seems useful. It is assumed
  284. that mtr holds an x-latch on the tree and on the cursor page. To avoid
  285. deadlocks, mtr must also own x-latches to brothers of page, if those
  286. brothers exist. NOTE: it is assumed that the caller has reserved enough
  287. free extents so that the compression will always succeed if done! */
  288. ibool
  289. btr_cur_compress_if_useful(
  290. /*=======================*/
  291. /* out: TRUE if compression occurred */
  292. btr_cur_t* cursor, /* in: cursor on the page to compress;
  293. cursor does not stay valid if compression
  294. occurs */
  295. mtr_t* mtr); /* in: mtr */
  296. /***********************************************************
  297. Removes the record on which the tree cursor is positioned. It is assumed
  298. that the mtr has an x-latch on the page where the cursor is positioned,
  299. but no latch on the whole tree. */
  300. ibool
  301. btr_cur_optimistic_delete(
  302. /*======================*/
  303. /* out: TRUE if success, i.e., the page
  304. did not become too empty */
  305. btr_cur_t* cursor, /* in: cursor on the record to delete;
  306. cursor stays valid: if deletion succeeds,
  307. on function exit it points to the successor
  308. of the deleted record */
  309. mtr_t* mtr); /* in: mtr */
  310. /*****************************************************************
  311. Removes the record on which the tree cursor is positioned. Tries
  312. to compress the page if its fillfactor drops below a threshold
  313. or if it is the only page on the level. It is assumed that mtr holds
  314. an x-latch on the tree and on the cursor page. To avoid deadlocks,
  315. mtr must also own x-latches to brothers of page, if those brothers
  316. exist. */
  317. ibool
  318. btr_cur_pessimistic_delete(
  319. /*=======================*/
  320. /* out: TRUE if compression occurred */
  321. ulint* err, /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE;
  322. the latter may occur because we may have
  323. to update node pointers on upper levels,
  324. and in the case of variable length keys
  325. these may actually grow in size */
  326. ibool has_reserved_extents, /* in: TRUE if the
  327. caller has already reserved enough free
  328. extents so that he knows that the operation
  329. will succeed */
  330. btr_cur_t* cursor, /* in: cursor on the record to delete;
  331. if compression does not occur, the cursor
  332. stays valid: it points to successor of
  333. deleted record on function exit */
  334. ibool in_rollback,/* in: TRUE if called in rollback */
  335. mtr_t* mtr); /* in: mtr */
  336. /***************************************************************
  337. Parses a redo log record of updating a record in-place. */
  338. byte*
  339. btr_cur_parse_update_in_place(
  340. /*==========================*/
  341. /* out: end of log record or NULL */
  342. byte* ptr, /* in: buffer */
  343. byte* end_ptr,/* in: buffer end */
  344. page_t* page); /* in: page or NULL */
  345. /********************************************************************
  346. Parses the redo log record for delete marking or unmarking of a clustered
  347. index record. */
  348. byte*
  349. btr_cur_parse_del_mark_set_clust_rec(
  350. /*=================================*/
  351. /* out: end of log record or NULL */
  352. byte* ptr, /* in: buffer */
  353. byte* end_ptr,/* in: buffer end */
  354. page_t* page); /* in: page or NULL */
  355. /********************************************************************
  356. Parses the redo log record for delete marking or unmarking of a secondary
  357. index record. */
  358. byte*
  359. btr_cur_parse_del_mark_set_sec_rec(
  360. /*===============================*/
  361. /* out: end of log record or NULL */
  362. byte* ptr, /* in: buffer */
  363. byte* end_ptr,/* in: buffer end */
  364. page_t* page); /* in: page or NULL */
  365. /***********************************************************************
  366. Estimates the number of rows in a given index range. */
  367. ib_longlong
  368. btr_estimate_n_rows_in_range(
  369. /*=========================*/
  370. /* out: estimated number of rows */
  371. dict_index_t* index, /* in: index */
  372. dtuple_t* tuple1, /* in: range start, may also be empty tuple */
  373. ulint mode1, /* in: search mode for range start */
  374. dtuple_t* tuple2, /* in: range end, may also be empty tuple */
  375. ulint mode2); /* in: search mode for range end */
  376. /***********************************************************************
  377. Estimates the number of different key values in a given index, for
  378. each n-column prefix of the index where n <= dict_index_get_n_unique(index).
  379. The estimates are stored in the array index->stat_n_diff_key_vals. */
  380. void
  381. btr_estimate_number_of_different_key_vals(
  382. /*======================================*/
  383. dict_index_t* index); /* in: index */
  384. /***********************************************************************
  385. Marks not updated extern fields as not-owned by this record. The ownership
  386. is transferred to the updated record which is inserted elsewhere in the
  387. index tree. In purge only the owner of externally stored field is allowed
  388. to free the field. */
  389. void
  390. btr_cur_mark_extern_inherited_fields(
  391. /*=================================*/
  392. rec_t* rec, /* in: record in a clustered index */
  393. upd_t* update, /* in: update vector */
  394. mtr_t* mtr); /* in: mtr */
  395. /***********************************************************************
  396. The complement of the previous function: in an update entry may inherit
  397. some externally stored fields from a record. We must mark them as inherited
  398. in entry, so that they are not freed in a rollback. */
  399. void
  400. btr_cur_mark_dtuple_inherited_extern(
  401. /*=================================*/
  402. dtuple_t* entry, /* in: updated entry to be inserted to
  403. clustered index */
  404. ulint* ext_vec, /* in: array of extern fields in the
  405. original record */
  406. ulint n_ext_vec, /* in: number of elements in ext_vec */
  407. upd_t* update); /* in: update vector */
  408. /***********************************************************************
  409. Marks all extern fields in a dtuple as owned by the record. */
  410. void
  411. btr_cur_unmark_dtuple_extern_fields(
  412. /*================================*/
  413. dtuple_t* entry, /* in: clustered index entry */
  414. ulint* ext_vec, /* in: array of numbers of fields
  415. which have been stored externally */
  416. ulint n_ext_vec); /* in: number of elements in ext_vec */
  417. /***********************************************************************
  418. Stores the fields in big_rec_vec to the tablespace and puts pointers to
  419. them in rec. The fields are stored on pages allocated from leaf node
  420. file segment of the index tree. */
  421. ulint
  422. btr_store_big_rec_extern_fields(
  423. /*============================*/
  424. /* out: DB_SUCCESS or error */
  425. dict_index_t* index, /* in: index of rec; the index tree
  426. MUST be X-latched */
  427. rec_t* rec, /* in: record */
  428. big_rec_t* big_rec_vec, /* in: vector containing fields
  429. to be stored externally */
  430. mtr_t* local_mtr); /* in: mtr containing the latch to
  431. rec and to the tree */
  432. /***********************************************************************
  433. Frees the space in an externally stored field to the file space
  434. management if the field in data is owned the externally stored field,
  435. in a rollback we may have the additional condition that the field must
  436. not be inherited. */
  437. void
  438. btr_free_externally_stored_field(
  439. /*=============================*/
  440. dict_index_t* index, /* in: index of the data, the index
  441. tree MUST be X-latched; if the tree
  442. height is 1, then also the root page
  443. must be X-latched! (this is relevant
  444. in the case this function is called
  445. from purge where 'data' is located on
  446. an undo log page, not an index
  447. page) */
  448. byte* data, /* in: internally stored data
  449. + reference to the externally
  450. stored part */
  451. ulint local_len, /* in: length of data */
  452. ibool do_not_free_inherited,/* in: TRUE if called in a
  453. rollback and we do not want to free
  454. inherited fields */
  455. mtr_t* local_mtr); /* in: mtr containing the latch to
  456. data an an X-latch to the index
  457. tree */
  458. /***************************************************************
  459. Frees the externally stored fields for a record. */
  460. void
  461. btr_rec_free_externally_stored_fields(
  462. /*==================================*/
  463. dict_index_t* index, /* in: index of the data, the index
  464. tree MUST be X-latched */
  465. rec_t* rec, /* in: record */
  466. ibool do_not_free_inherited,/* in: TRUE if called in a
  467. rollback and we do not want to free
  468. inherited fields */
  469. mtr_t* mtr); /* in: mini-transaction handle which contains
  470. an X-latch to record page and to the index
  471. tree */
  472. /***********************************************************************
  473. Copies an externally stored field of a record to mem heap. */
  474. byte*
  475. btr_rec_copy_externally_stored_field(
  476. /*=================================*/
  477. /* out: the field copied to heap */
  478. rec_t* rec, /* in: record */
  479. ulint no, /* in: field number */
  480. ulint* len, /* out: length of the field */
  481. mem_heap_t* heap); /* in: mem heap */
  482. /***********************************************************************
  483. Copies an externally stored field of a record to mem heap. Parameter
  484. data contains a pointer to 'internally' stored part of the field:
  485. possibly some data, and the reference to the externally stored part in
  486. the last 20 bytes of data. */
  487. byte*
  488. btr_copy_externally_stored_field(
  489. /*=============================*/
  490. /* out: the whole field copied to heap */
  491. ulint* len, /* out: length of the whole field */
  492. byte* data, /* in: 'internally' stored part of the
  493. field containing also the reference to
  494. the external part */
  495. ulint local_len,/* in: length of data */
  496. mem_heap_t* heap); /* in: mem heap */
  497. /***********************************************************************
  498. Stores the positions of the fields marked as extern storage in the update
  499. vector, and also those fields who are marked as extern storage in rec
  500. and not mentioned in updated fields. We use this function to remember
  501. which fields we must mark as extern storage in a record inserted for an
  502. update. */
  503. ulint
  504. btr_push_update_extern_fields(
  505. /*==========================*/
  506. /* out: number of values stored in ext_vect */
  507. ulint* ext_vect, /* in: array of ulints, must be preallocated
  508. to have place for all fields in rec */
  509. rec_t* rec, /* in: record */
  510. upd_t* update); /* in: update vector */
  511. /*######################################################################*/
  512. /* In the pessimistic delete, if the page data size drops below this
  513. limit, merging it to a neighbor is tried */
  514. #define BTR_CUR_PAGE_COMPRESS_LIMIT (UNIV_PAGE_SIZE / 2)
  515. /* A slot in the path array. We store here info on a search path down the
  516. tree. Each slot contains data on a single level of the tree. */
  517. typedef struct btr_path_struct btr_path_t;
  518. struct btr_path_struct{
  519. ulint nth_rec; /* index of the record
  520. where the page cursor stopped on
  521. this level (index in alphabetical
  522. order); value ULINT_UNDEFINED
  523. denotes array end */
  524. ulint n_recs; /* number of records on the page */
  525. };
  526. #define BTR_PATH_ARRAY_N_SLOTS 250 /* size of path array (in slots) */
  527. /* The tree cursor: the definition appears here only for the compiler
  528. to know struct size! */
  529. struct btr_cur_struct {
  530. dict_index_t* index; /* index where positioned */
  531. page_cur_t page_cur; /* page cursor */
  532. page_t* left_page; /* this field is used to store a pointer
  533. to the left neighbor page, in the cases
  534. BTR_SEARCH_PREV and BTR_MODIFY_PREV */
  535. /*------------------------------*/
  536. que_thr_t* thr; /* this field is only used when
  537. btr_cur_search_... is called for an
  538. index entry insertion: the calling
  539. query thread is passed here to be
  540. used in the insert buffer */
  541. /*------------------------------*/
  542. /* The following fields are used in btr_cur_search... to pass
  543. information: */
  544. ulint flag; /* BTR_CUR_HASH, BTR_CUR_HASH_FAIL,
  545. BTR_CUR_BINARY, or
  546. BTR_CUR_INSERT_TO_IBUF */
  547. ulint tree_height; /* Tree height if the search is done
  548. for a pessimistic insert or update
  549. operation */
  550. ulint up_match; /* If the search mode was PAGE_CUR_LE,
  551. the number of matched fields to the
  552. the first user record to the right of
  553. the cursor record after
  554. btr_cur_search_...;
  555. for the mode PAGE_CUR_GE, the matched
  556. fields to the first user record AT THE
  557. CURSOR or to the right of it;
  558. NOTE that the up_match and low_match
  559. values may exceed the correct values
  560. for comparison to the adjacent user
  561. record if that record is on a
  562. different leaf page! (See the note in
  563. row_ins_duplicate_key.) */
  564. ulint up_bytes; /* number of matched bytes to the
  565. right at the time cursor positioned;
  566. only used internally in searches: not
  567. defined after the search */
  568. ulint low_match; /* if search mode was PAGE_CUR_LE,
  569. the number of matched fields to the
  570. first user record AT THE CURSOR or
  571. to the left of it after
  572. btr_cur_search_...;
  573. NOT defined for PAGE_CUR_GE or any
  574. other search modes; see also the NOTE
  575. in up_match! */
  576. ulint low_bytes; /* number of matched bytes to the
  577. right at the time cursor positioned;
  578. only used internally in searches: not
  579. defined after the search */
  580. ulint n_fields; /* prefix length used in a hash
  581. search if hash_node != NULL */
  582. ulint n_bytes; /* hash prefix bytes if hash_node !=
  583. NULL */
  584. ulint fold; /* fold value used in the search if
  585. flag is BTR_CUR_HASH */
  586. /*------------------------------*/
  587. btr_path_t* path_arr; /* in estimating the number of
  588. rows in range, we store in this array
  589. information of the path through
  590. the tree */
  591. };
  592. /* Values for the flag documenting the used search method */
  593. #define BTR_CUR_HASH 1 /* successful shortcut using the hash
  594. index */
  595. #define BTR_CUR_HASH_FAIL 2 /* failure using hash, success using
  596. binary search: the misleading hash
  597. reference is stored in the field
  598. hash_node, and might be necessary to
  599. update */
  600. #define BTR_CUR_BINARY 3 /* success using the binary search */
  601. #define BTR_CUR_INSERT_TO_IBUF 4 /* performed the intended insert to
  602. the insert buffer */
  603. /* If pessimistic delete fails because of lack of file space,
  604. there is still a good change of success a little later: try this many times,
  605. and sleep this many microseconds in between */
  606. #define BTR_CUR_RETRY_DELETE_N_TIMES 100
  607. #define BTR_CUR_RETRY_SLEEP_TIME 50000
  608. /* The reference in a field for which data is stored on a different page.
  609. The reference is at the end of the 'locally' stored part of the field.
  610. 'Locally' means storage in the index record.
  611. We store locally a long enough prefix of each column so that we can determine
  612. the ordering parts of each index record without looking into the externally
  613. stored part. */
  614. /*--------------------------------------*/
  615. #define BTR_EXTERN_SPACE_ID 0 /* space id where stored */
  616. #define BTR_EXTERN_PAGE_NO 4 /* page no where stored */
  617. #define BTR_EXTERN_OFFSET 8 /* offset of BLOB header
  618. on that page */
  619. #define BTR_EXTERN_LEN 12 /* 8 bytes containing the
  620. length of the externally
  621. stored part of the BLOB.
  622. The 2 highest bits are
  623. reserved to the flags below. */
  624. /*--------------------------------------*/
  625. #define BTR_EXTERN_FIELD_REF_SIZE 20
  626. /* The highest bit of BTR_EXTERN_LEN (i.e., the highest bit of the byte
  627. at lowest address) is set to 1 if this field does not 'own' the externally
  628. stored field; only the owner field is allowed to free the field in purge!
  629. If the 2nd highest bit is 1 then it means that the externally stored field
  630. was inherited from an earlier version of the row. In rollback we are not
  631. allowed to free an inherited external field. */
  632. #define BTR_EXTERN_OWNER_FLAG 128
  633. #define BTR_EXTERN_INHERITED_FLAG 64
  634. extern ulint btr_cur_n_non_sea;
  635. extern ulint btr_cur_n_sea;
  636. extern ulint btr_cur_n_non_sea_old;
  637. extern ulint btr_cur_n_sea_old;
  638. #ifndef UNIV_NONINL
  639. #include "btr0cur.ic"
  640. #endif
  641. #endif