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

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

MySQL数据库

开发平台：

Visual C++

Dbacc.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef DBACC_H
  18. #define DBACC_H
  22. #include <pc.hpp>
  23. #include <SimulatedBlock.hpp>
  25. #ifdef DBACC_C
  26. // Debug Macros
  27. #define dbgWord32(ptr, ind, val) 
  29. /*
  30. #define dbgWord32(ptr, ind, val) 
  31. if(debug_jan){ 
  32. tmp_val = val; 
  33. switch(ind){ 
  34. case 1: strcpy(tmp_string, "ZPOS_PAGE_TYPE   "); 
  35. break; 
  36. case 2: strcpy(tmp_string, "ZPOS_NO_ELEM_IN_PAGE"); 
  37. break; 
  38. case 3: strcpy(tmp_string, "ZPOS_CHECKSUM    "); 
  39. break; 
  40. case 4: strcpy(tmp_string, "ZPOS_OVERFLOWREC  "); 
  41. break; 
  42. case 5: strcpy(tmp_string, "ZPOS_FREE_AREA_IN_PAGE"); 
  43. break; 
  44. case 6: strcpy(tmp_string, "ZPOS_LAST_INDEX   "); 
  45. break; 
  46. case 7: strcpy(tmp_string, "ZPOS_INSERT_INDEX  "); 
  47. break; 
  48. case 8: strcpy(tmp_string, "ZPOS_ARRAY_POS    "); 
  49. break; 
  50. case 9: strcpy(tmp_string, "ZPOS_NEXT_FREE_INDEX"); 
  51. break; 
  52. case 10: strcpy(tmp_string, "ZPOS_NEXT_PAGE   "); 
  53. break; 
  54. case 11: strcpy(tmp_string, "ZPOS_PREV_PAGE   "); 
  55. break; 
  56. default: sprintf(tmp_string, "%-20d", ind);
  57. } 
  58. ndbout << "Ptr: " << ptr.p->word32 << " tIndex: " << tmp_string << " tValue: " << tmp_val << " tLINE: " << __LINE__ << endl; 
  59. }
  60. */
  62. #define dbgUndoword(ptr, ind, val)
  64. // Constants
  65. /** ------------------------------------------------------------------------ 
  66.  *   THESE ARE CONSTANTS THAT ARE USED FOR DEFINING THE SIZE OF BUFFERS, THE
  67.  *   SIZE OF PAGE HEADERS, THE NUMBER OF BUFFERS IN A PAGE AND A NUMBER OF 
  68.  *   OTHER CONSTANTS WHICH ARE CHANGED WHEN THE BUFFER SIZE IS CHANGED. 
  69.  * ----------------------------------------------------------------------- */
  70. #define ZHEAD_SIZE 32
  71. #define ZCON_HEAD_SIZE 2
  72. #define ZBUF_SIZE 28
  73. #define ZEMPTYLIST 72
  74. #define ZUP_LIMIT 14
  75. #define ZDOWN_LIMIT 12
  76. #define ZSHIFT_PLUS 5
  77. #define ZSHIFT_MINUS 2
  78. #define ZFREE_LIMIT 65
  79. #define ZNO_CONTAINERS 64
  80. #define ZELEM_HEAD_SIZE 1
  81. /* ------------------------------------------------------------------------- */
  82. /*  THESE CONSTANTS DEFINE THE USE OF THE PAGE HEADER IN THE INDEX PAGES.    */
  83. /* ------------------------------------------------------------------------- */
  84. #define ZPOS_PAGE_ID 0
  85. #define ZPOS_PAGE_TYPE 1
  86. #define ZPOS_PAGE_TYPE_BIT 14
  87. #define ZPOS_EMPTY_LIST 1
  88. #define ZPOS_ALLOC_CONTAINERS 2
  89. #define ZPOS_CHECKSUM 3
  90. #define ZPOS_OVERFLOWREC 4
  91. #define ZPOS_NO_ELEM_IN_PAGE 2
  92. #define ZPOS_FREE_AREA_IN_PAGE 5
  93. #define ZPOS_LAST_INDEX 6
  94. #define ZPOS_INSERT_INDEX 7
  95. #define ZPOS_ARRAY_POS 8
  96. #define ZPOS_NEXT_FREE_INDEX 9
  97. #define ZPOS_NEXT_PAGE 10
  98. #define ZPOS_PREV_PAGE 11
  99. #define ZNORMAL_PAGE_TYPE 0
  100. #define ZOVERFLOW_PAGE_TYPE 1
  101. #define ZLONG_PAGE_TYPE 2
  102. #define ZDEFAULT_LIST 3
  103. #define ZWORDS_IN_PAGE 2048
  104. /* --------------------------------------------------------------------------------- */
  105. /*       CONSTANTS FOR THE ZERO PAGES                                                */
  106. /* --------------------------------------------------------------------------------- */
  107. #define ZPAGEZERO_PREV_UNDOP 8
  108. #define ZPAGEZERO_NO_OVER_PAGE 9
  109. #define ZPAGEZERO_TABID 10
  110. #define ZPAGEZERO_FRAGID0 11
  111. #define ZPAGEZERO_FRAGID1 12
  112. #define ZPAGEZERO_HASH_CHECK 13
  113. #define ZPAGEZERO_DIRSIZE 14
  114. #define ZPAGEZERO_EXPCOUNTER 15
  115. #define ZPAGEZERO_NEXT_UNDO_FILE 16
  116. #define ZPAGEZERO_SLACK 17
  117. #define ZPAGEZERO_NO_PAGES 18
  118. #define ZPAGEZERO_HASHCHECKBIT 19
  119. #define ZPAGEZERO_K 20
  120. #define ZPAGEZERO_LHFRAGBITS 21
  121. #define ZPAGEZERO_LHDIRBITS 22
  122. #define ZPAGEZERO_LOCALKEYLEN 23
  123. #define ZPAGEZERO_MAXP 24
  124. #define ZPAGEZERO_MAXLOADFACTOR 25
  125. #define ZPAGEZERO_MINLOADFACTOR 26
  126. #define ZPAGEZERO_MYFID 27
  127. #define ZPAGEZERO_LAST_OVER_INDEX 28
  128. #define ZPAGEZERO_P 29
  129. #define ZPAGEZERO_NO_OF_ELEMENTS 30
  130. #define ZPAGEZERO_ELEMENT_LENGTH 31
  131. #define ZPAGEZERO_KEY_LENGTH 32
  132. #define ZPAGEZERO_NODETYPE 33
  133. #define ZPAGEZERO_SLACK_CHECK 34
  134. /* --------------------------------------------------------------------------------- */
  135. /*       CONSTANTS FOR THE LONG KEY PAGES                                            */
  136. /* --------------------------------------------------------------------------------- */
  137. /* --------------------------------------------------------------------------------- */
  138. // Maximum number of elements in long key page = (ZWORDS_IN_PAGE - ZHEAD_SIZE) /
  139. // (MinKeySize + IndexSize) = (2048 - 32) / (8 + 1) = 224. MinKeySize is actually 9
  140. // because 8 is the largest normal key size.
  141. #define ZMAX_NO_OF_LONGKEYS_IN_PAGE 225
  142. #define ZMAX_LONG_KEY_ARRAY_INDEX 3
  143. #define ZACTIVE_LONG_KEY_LEN 1
  144. /* --------------------------------------------------------------------------------- */
  145. /*       CONSTANTS IN ALPHABETICAL ORDER                                             */
  146. /* --------------------------------------------------------------------------------- */
  147. #define ZADDFRAG 0
  148. #define ZCOPY_NEXT 1
  149. #define ZCOPY_NEXT_COMMIT 2
  150. #define ZCOPY_COMMIT 3
  151. #define ZCOPY_REPEAT 4
  152. #define ZCOPY_ABORT 5
  153. #define ZCOPY_CLOSE 6
  154. #define ZDIRARRAY 68
  155. #define ZDIRRANGESIZE 65
  156. //#define ZEMPTY_FRAGMENT 0
  157. #define ZFRAGMENTSIZE 64
  158. #define ZFIRSTTIME 1
  159. #define ZFS_CONNECTSIZE 300
  160. #define ZFS_OPSIZE 100
  161. #define ZKEYINKEYREQ 4
  162. #define ZLCP_CONNECTSIZE 30
  163. #define ZLEFT 1
  164. #define ZLOCALLOGFILE 2
  165. #define ZLOCKED 0
  166. #define ZMAXSCANSIGNALLEN 20
  167. #define ZMAINKEYLEN 8
  168. #define ZMAX_UNDO_VERSION 4
  169. #define ZNO_OF_DISK_VERSION 3
  170. #define ZNO_OF_OP_PER_SIGNAL 20
  171. //#define ZNOT_EMPTY_FRAGMENT 1
  172. #define ZNR_OF_UNDO_PAGE_GROUP 16
  173. #define ZOP_HEAD_INFO_LN 3
  174. #define ZOPRECSIZE 740
  175. #define ZOVERFLOWRECSIZE 5
  176. #define ZPAGE8_BASE_ADD 1
  177. #define ZPAGESIZE 128
  178. #define ZPARALLEL_QUEUE 1
  179. #define ZPDIRECTORY 1
  180. #define ZSCAN_MAX_LOCK 4
  181. #define ZSERIAL_QUEUE 2
  182. #define ZSPH1 1
  183. #define ZSPH2 2
  184. #define ZSPH3 3
  185. #define ZSPH6 6
  186. #define ZREADLOCK 0
  187. #define ZRIGHT 2
  188. #define ZROOTFRAGMENTSIZE 32
  189. #define ZSCAN_LOCK_ALL 3
  190. #define ZSCAN_OP 5
  191. #define ZSCAN_REC_SIZE 256
  192. #define ZSR_VERSION_REC_SIZE 16
  193. #define ZSTAND_BY 2
  194. #define ZTABLESIZE 16
  195. #define ZTABMAXINDEX 3
  196. #define ZUNDEFINED_OP 6
  197. #define ZUNDOHEADSIZE 7
  198. #define ZUNLOCKED 1
  199. #define ZUNDOPAGE_BASE_ADD 2
  200. #define ZUNDOPAGEINDEXBITS 13
  201. #define ZUNDOPAGEINDEX_MASK 0x1fff
  202. #define ZWRITEPAGESIZE 8
  203. #define ZWRITE_UNDOPAGESIZE 2
  204. #define ZMIN_UNDO_PAGES_AT_COMMIT 4
  205. #define ZMIN_UNDO_PAGES_AT_OPERATION 10
  206. #define ZMIN_UNDO_PAGES_AT_EXPAND 16
  208. /* --------------------------------------------------------------------------------- */
  209. /* CONTINUEB CODES                                                                   */
  210. /* --------------------------------------------------------------------------------- */
  211. #define ZLOAD_BAL_LCP_TIMER 0
  212. #define ZINITIALISE_RECORDS 1
  213. #define ZSR_READ_PAGES_ALLOC 2
  214. #define ZSTART_UNDO 3
  215. #define ZSEND_SCAN_HBREP 4
  216. #define ZREL_ROOT_FRAG 5
  217. #define ZREL_FRAG 6
  218. #define ZREL_DIR 7
  219. #define ZREPORT_MEMORY_USAGE 8
  220. #define ZLCP_OP_WRITE_RT_BREAK 9
  222. /* ------------------------------------------------------------------------- */
  223. /* ERROR CODES                                                               */
  224. /* ------------------------------------------------------------------------- */
  225. #define ZLIMIT_OF_ERROR 600 // Limit check for error codes
  226. #define ZCHECKROOT_ERROR 601 // Delete fragment error code
  227. #define ZCONNECT_SIZE_ERROR 602 // ACC_SEIZEREF
  228. #define ZDIR_RANGE_ERROR 603 // Add fragment error code
  229. #define ZFULL_FRAGRECORD_ERROR 604 // Add fragment error code
  230. #define ZFULL_ROOTFRAGRECORD_ERROR 605 // Add fragment error code
  231. #define ZROOTFRAG_STATE_ERROR 606 // Add fragment
  232. #define ZOVERTAB_REC_ERROR 607 // Add fragment
  234. #define ZSCAN_REFACC_CONNECT_ERROR 608 // ACC_SCANREF
  235. #define ZFOUR_ACTIVE_SCAN_ERROR 609 // ACC_SCANREF
  236. #define ZNULL_SCAN_REC_ERROR 610 // ACC_SCANREF
  238. #define ZDIRSIZE_ERROR 623
  239. #define ZOVER_REC_ERROR 624 // Insufficient Space
  240. #define ZPAGESIZE_ERROR 625
  241. #define ZTUPLE_DELETED_ERROR 626
  242. #define ZREAD_ERROR 626
  243. #define ZWRITE_ERROR 630
  244. #define ZTO_OP_STATE_ERROR 631
  245. #define ZTOO_EARLY_ACCESS_ERROR 632
  246. #define ZTEMPORARY_ACC_UNDO_FAILURE 677
  247. #endif
  249. class ElementHeader {
  250.   /**
  251.    * 
  252.    * l = Locked    -- If true contains operation else scan bits + hash value
  253.    * s = Scan bits
  254.    * h = Hash value
  255.    * o = Operation ptr I
  256.    *
  257.    *           1111111111222222222233
  258.    * 01234567890123456789012345678901
  259.    * lssssssssssss   hhhhhhhhhhhhhhhh
  260.    *  ooooooooooooooooooooooooooooooo
  261.    */
  262. public:
  263.   STATIC_CONST( HASH_VALUE_PART_MASK = 0xFFFF );
  264.   
  265.   static bool getLocked(Uint32 data);
  266.   static bool getUnlocked(Uint32 data);
  267.   static Uint32 getScanBits(Uint32 data);
  268.   static Uint32 getHashValuePart(Uint32 data);
  269.   static Uint32 getOpPtrI(Uint32 data);
  271.   static Uint32 setLocked(Uint32 opPtrI);
  272.   static Uint32 setUnlocked(Uint32 hashValuePart, Uint32 scanBits);
  273.   static Uint32 setScanBit(Uint32 header, Uint32 scanBit);
  274.   static Uint32 clearScanBit(Uint32 header, Uint32 scanBit);
  275. };
  277. inline 
  278. bool
  279. ElementHeader::getLocked(Uint32 data){
  280.   return (data & 1) == 0;
  281. }
  283. inline 
  284. bool
  285. ElementHeader::getUnlocked(Uint32 data){
  286.   return (data & 1) == 1;
  287. }
  289. inline 
  290. Uint32 
  291. ElementHeader::getScanBits(Uint32 data){
  292.   assert(getUnlocked(data));
  293.   return (data >> 1) & ((1 << MAX_PARALLEL_SCANS_PER_FRAG) - 1);
  294. }
  296. inline 
  297. Uint32 
  298. ElementHeader::getHashValuePart(Uint32 data){
  299.   assert(getUnlocked(data));
  300.   return data >> 16;
  301. }
  303. inline
  304. Uint32 
  305. ElementHeader::getOpPtrI(Uint32 data){
  306.   assert(getLocked(data));
  307.   return data >> 1;
  308. }
  310. inline 
  311. Uint32 
  312. ElementHeader::setLocked(Uint32 opPtrI){
  313.   return (opPtrI << 1) + 0;
  314. }
  315. inline
  316. Uint32 
  317. ElementHeader::setUnlocked(Uint32 hashValue, Uint32 scanBits){
  318.   return (hashValue << 16) + (scanBits << 1) + 1;
  319. }
  321. inline
  322. Uint32 
  323. ElementHeader::setScanBit(Uint32 header, Uint32 scanBit){
  324.   assert(getUnlocked(header));
  325.   return header | (scanBit << 1);
  326. }
  328. inline
  329. Uint32 
  330. ElementHeader::clearScanBit(Uint32 header, Uint32 scanBit){
  331.   assert(getUnlocked(header));
  332.   return header & (~(scanBit << 1));
  333. }
  336. class Dbacc: public SimulatedBlock {
  337. public:
  338. // State values
  339. enum State {
  340.   FREEFRAG = 0,
  341.   ACTIVEFRAG = 1,
  342.   SEND_QUE_OP = 2,
  343.   WAIT_ACC_LCPREQ = 3,
  344.   LCP_SEND_PAGES = 4,
  345.   LCP_SEND_OVER_PAGES = 5,
  346.   LCP_SEND_ZERO_PAGE = 6,
  347.   SR_READ_PAGES = 7,
  348.   SR_READ_OVER_PAGES = 8,
  349.   WAIT_ZERO_PAGE_STORED = 9,
  350.   WAIT_NOTHING = 10,
  351.   WAIT_OPEN_UNDO_LCP = 11,
  352.   WAIT_OPEN_UNDO_LCP_NEXT = 12,
  353.   WAIT_OPEN_DATA_FILE_FOR_READ = 13,
  354.   WAIT_OPEN_DATA_FILE_FOR_WRITE = 14,
  355.   OPEN_UNDO_FILE_SR = 15,
  356.   READ_UNDO_PAGE = 16,
  357.   READ_UNDO_PAGE_AND_CLOSE = 17,
  358.   WAIT_READ_DATA = 18,
  359.   WAIT_READ_PAGE_ZERO = 19,
  360.   WAIT_WRITE_DATA = 20,
  361.   WAIT_WRITE_UNDO = 21,
  362.   WAIT_WRITE_UNDO_EXIT = 22,
  363.   WAIT_CLOSE_UNDO = 23,
  364.   LCP_CLOSE_DATA = 24,
  365.   SR_CLOSE_DATA = 25,
  366.   WAIT_ONE_CONF = 26,
  367.   WAIT_TWO_CONF = 27,
  368.   LCP_FREE = 28,
  369.   LCP_ACTIVE = 29,
  370.   FREE_OP = 30,
  371.   WAIT_EXE_OP = 32,
  372.   WAIT_IN_QUEUE = 34,
  373.   EXE_OP = 35,
  374.   SCAN_ACTIVE = 36,
  375.   SCAN_WAIT_IN_QUEUE = 37,
  376.   IDLE = 39,
  377.   ACTIVE = 40,
  378.   WAIT_COMMIT_ABORT = 41,
  379.   ABORT = 42,
  380.   ABORTADDFRAG = 43,
  381.   REFUSEADDFRAG = 44,
  382.   DELETEFRAG = 45,
  383.   DELETETABLE = 46,
  384.   UNDEFINEDROOT = 47,
  385.   ADDFIRSTFRAG = 48,
  386.   ADDSECONDFRAG = 49,
  387.   DELETEFIRSTFRAG = 50,
  388.   DELETESECONDFRAG = 51,
  389.   ACTIVEROOT = 52,
  390.   LCP_CREATION = 53
  391. };
  393. // Records
  396. //---------------------------------------------------------------------------------- 
  397. // LONGKEY PAGE RECORD                                                          
  398. //     
  399. // A long key page consist of a header part, a key data part and an index part. The 
  400. // page starts with a header of size HEAD_SIZE. As you can see below, not every word 
  401. // in the header is used. After the header comes the data part, where the actual 
  402. // keys are stored. A key is always inserted after the existing keys in the data 
  403. // part. If we have a fragmented data part and a new key doesn't fit after the 
  404. // existing keys we reorganize the keys. The index part starts at the end of the 
  405. // page and grows towards the end of the data part. This means that the limit 
  406. // between the data part and the index part is floating. Each inserted key have a 
  407. // word in the index part that describes size and position of the key in the data 
  408. // part. The free indexes in the index part are single linked.
  409. //---------------------------------------------------------------------------------- 
  410.   union LongKeyPage {
  411.     struct {
  412.       Uint32 pageId; // ZPOS_PAGE_ID 0
  413.       Uint32 b;
  414.       // The number of keys in page.
  415.       Uint32 noOfElements; // ZPOS_NO_ELEM_IN_PAGE 2
  416.       Uint32 d;
  417.       Uint32 e;
  418.       // The free area in the data part of page.
  419.       Uint32 freeArea; // ZPOS_FREE_AREA_IN_PAGE 5
  420.       // The index position, which defines the limit between the data and the index part.
  421.       Uint32 highestIndex;  // ZPOS_LAST_INDEX 6
  422.       // The position where to insert the actual key in the data part.
  423.       Uint32 insertPos; // ZPOS_INSERT_INDEX 7
  424.       // Position in a page array where the pages are stored in a double linked list.
  425.       // Based on the free area in the page.  Values 0 to 3.
  426.       Uint32 pageArrayPos; // ZPOS_ARRAY_POS 8
  427.       // Next free position in the index part.
  428.       Uint32 nextFreeIndex; // ZPOS_NEXT_FREE_INDEX 9
  429.       // Next page in the double linked list.
  430.       Uint32 nextPage; // ZPOS_NEXT_PAGE  10
  431.       // Previous page in the double linked list.
  432.       Uint32 prevPage; // ZPOS_PREV_PAGE 11
  433.     } header;
  434.     // This is kept to keep the logic and to make changes to a minimum.
  435.     Uint32 word32[2048];
  436.   };
  438. /* --------------------------------------------------------------------------------- */
  439. /* UNDO HEADER RECORD                                                                */
  440. /* --------------------------------------------------------------------------------- */
  442.   struct UndoHeader {
  443.     enum UndoHeaderType{
  444.       ZPAGE_INFO = 0,
  445.       ZOVER_PAGE_INFO = 1,
  446.       ZOP_INFO = 2,
  447.       ZUNDO_INSERT_LONG_KEY = 3,
  448.       ZUNDO_DELETE_LONG_KEY = 4,
  449.       ZNO_UNDORECORD_TYPES = 5
  450.     };
  451.     UintR tableId;
  452.     UintR rootFragId;
  453.     UintR localFragId;
  454.     UintR variousInfo;
  455.     UintR logicalPageId;
  456.     UintR prevUndoAddressForThisFrag;
  457.     UintR prevUndoAddress;
  458.   };
  460. /* --------------------------------------------------------------------------------- */
  461. /* DIRECTORY RANGE                                                                   */
  462. /* --------------------------------------------------------------------------------- */
  463.   struct DirRange {
  464.     Uint32 dirArray[256];
  465.   }; /* p2c: size = 1024 bytes */
  466.   
  467.   typedef Ptr<DirRange> DirRangePtr;
  469. /* --------------------------------------------------------------------------------- */
  470. /* DIRECTORYARRAY                                                                    */
  471. /* --------------------------------------------------------------------------------- */
  472. struct Directoryarray {
  473.   Uint32 pagep[256];
  474. }; /* p2c: size = 1024 bytes */
  476.   typedef Ptr<Directoryarray> DirectoryarrayPtr;
  478. /* --------------------------------------------------------------------------------- */
  479. /* FRAGMENTREC. ALL INFORMATION ABOUT FRAMENT AND HASH TABLE IS SAVED IN FRAGMENT    */
  480. /*         REC  A POINTER TO FRAGMENT RECORD IS SAVED IN ROOTFRAGMENTREC FRAGMENT    */
  481. /* --------------------------------------------------------------------------------- */
  482. struct Fragmentrec {
  483. //-----------------------------------------------------------------------------
  484. // References to long key pages with free area. Some type of buddy structure
  485. // where references in higher index have more free space.
  486. //-----------------------------------------------------------------------------
  487.   Uint32 longKeyPageArray[4];
  489. //-----------------------------------------------------------------------------
  490. // These variables keep track of allocated pages, the number of them and the
  491. // start file page of them. Used during local checkpoints.
  492. //-----------------------------------------------------------------------------
  493.   Uint32 datapages[8];
  494.   Uint32 activeDataPage;
  495.   Uint32 activeDataFilePage;
  497. //-----------------------------------------------------------------------------
  498. // Temporary variables used during shrink and expand process.
  499. //-----------------------------------------------------------------------------
  500.   Uint32 expReceivePageptr;
  501.   Uint32 expReceiveIndex;
  502.   Uint32 expReceiveForward;
  503.   Uint32 expSenderDirIndex;
  504.   Uint32 expSenderDirptr;
  505.   Uint32 expSenderIndex;
  506.   Uint32 expSenderPageptr;
  508. //-----------------------------------------------------------------------------
  509. // List of lock owners and list of lock waiters to support LCP handling
  510. //-----------------------------------------------------------------------------
  511.   Uint32 lockOwnersList;
  512.   Uint32 firstWaitInQueOp;
  513.   Uint32 lastWaitInQueOp;
  514.   Uint32 sentWaitInQueOp;
  516. //-----------------------------------------------------------------------------
  517. // References to Directory Ranges (which in turn references directories, which
  518. // in its turn references the pages) for the bucket pages and the overflow
  519. // bucket pages.
  520. //-----------------------------------------------------------------------------
  521.   Uint32 directory;
  522.   Uint32 dirsize;
  523.   Uint32 overflowdir;
  524.   Uint32 lastOverIndex;
  526. //-----------------------------------------------------------------------------
  527. // These variables are used to support LCP and Restore from disk.
  528. // lcpDirIndex: used during LCP as the frag page id currently stored.
  529. // lcpMaxDirIndex: The dirsize at start of LCP.
  530. // lcpMaxOverDirIndex: The xx at start of LCP
  531. // During a LCP one writes the minimum of the number of pages in the directory
  532. // and the number of pages at the start of the LCP.
  533. // noStoredPages: Number of bucket pages written in LCP used at restore
  534. // noOfOverStoredPages: Number of overflow pages written in LCP used at restore
  535. // This variable is also used during LCP to calculate this number.
  536. //-----------------------------------------------------------------------------
  537.   Uint32 lcpDirIndex;
  538.   Uint32 lcpMaxDirIndex;
  539.   Uint32 lcpMaxOverDirIndex;
  540.   Uint32 noStoredPages;
  541.   Uint32 noOfStoredOverPages;
  543. //-----------------------------------------------------------------------------
  544. // We have a list of overflow pages with free areas. We have a special record,
  545. // the overflow record representing these pages. The reason is that the
  546. // same record is also used to represent pages in the directory array that have
  547. // been released since they were empty (there were however higher indexes with
  548. // data in them). These are put in the firstFreeDirIndexRec-list.
  549. // An overflow record representing a page can only be in one of these lists.
  550. //-----------------------------------------------------------------------------
  551.   Uint32 firstOverflowRec;
  552.   Uint32 lastOverflowRec;
  553.   Uint32 firstFreeDirindexRec;
  555. //-----------------------------------------------------------------------------
  556. // localCheckpId is used during execution of UNDO log to ensure that we only
  557. // apply UNDO log records from the restored LCP of the fragment.
  558. // lcpLqhPtr keeps track of LQH record for this fragment to checkpoint
  559. //-----------------------------------------------------------------------------
  560.   Uint32 localCheckpId;
  561.   Uint32 lcpLqhPtr;
  563. //-----------------------------------------------------------------------------
  564. // Counter keeping track of how many times we have expanded. We need to ensure
  565. // that we do not shrink so many times that this variable becomes negative.
  566. //-----------------------------------------------------------------------------
  567.   Uint32 expandCounter;
  568. //-----------------------------------------------------------------------------
  569. // Reference to record for open file at LCP and restore
  570. //-----------------------------------------------------------------------------
  571.   Uint32 fsConnPtr;
  573. //-----------------------------------------------------------------------------
  574. // These variables are important for the linear hashing algorithm.
  575. // localkeylen is the size of the local key (1 and 2 is currently supported)
  576. // maxloadfactor is the factor specifying when to expand
  577. // minloadfactor is the factor specifying when to shrink (hysteresis model)
  578. // maxp and p
  579. // maxp and p is the variables most central to linear hashing. p + maxp + 1 is the
  580. // current number of buckets. maxp is the largest value of the type 2**n - 1
  581. // which is smaller than the number of buckets. These values are used to find
  582. // correct bucket with the aid of the hash value.
  583. //
  584. // slack is the variable keeping track of whether we have inserted more than
  585. // the current size is suitable for or less. Slack together with the boundaries
  586. // set by maxloadfactor and minloadfactor decides when to expand/shrink
  587. // slackCheck When slack goes over this value it is time to expand.
  588. // slackCheck = (maxp + p + 1)*(maxloadfactor - minloadfactor) or 
  589. // bucketSize * hysteresis
  590. //-----------------------------------------------------------------------------
  591.   Uint32 localkeylen;
  592.   Uint32 maxp;
  593.   Uint32 maxloadfactor;
  594.   Uint32 minloadfactor;
  595.   Uint32 p;
  596.   Uint32 slack;
  597.   Uint32 slackCheck;
  599. //-----------------------------------------------------------------------------
  600. // myfid is the fragment id of the fragment
  601. // myroot is the reference to the root fragment record
  602. // nextfreefrag is the next free fragment if linked into a free list
  603. //-----------------------------------------------------------------------------
  604.   Uint32 myfid;
  605.   Uint32 myroot;
  606.   Uint32 myTableId;
  607.   Uint32 nextfreefrag;
  609. //-----------------------------------------------------------------------------
  610. // This variable is used during restore to keep track of page id of read pages.
  611. // During read of bucket pages this is used to calculate the page id and also
  612. // to verify that the page id of the read page is correct. During read of over-
  613. // flow pages it is only used to keep track of the number of pages read.
  614. //-----------------------------------------------------------------------------
  615.   Uint32 nextAllocPage;
  617. //-----------------------------------------------------------------------------
  618. // Keeps track of undo position for fragment during LCP and restore.
  619. //-----------------------------------------------------------------------------
  620.   Uint32 prevUndoposition;
  622. //-----------------------------------------------------------------------------
  623. // Page reference during LCP and restore of page zero where fragment data is
  624. // saved
  625. //-----------------------------------------------------------------------------
  626.   Uint32 zeroPagePtr;
  628. //-----------------------------------------------------------------------------
  629. // Number of pages read from file during restore
  630. //-----------------------------------------------------------------------------
  631.   Uint32 noOfExpectedPages;
  633. //-----------------------------------------------------------------------------
  634. // Fragment State, mostly applicable during LCP and restore
  635. //-----------------------------------------------------------------------------
  636.   State fragState;
  638. //-----------------------------------------------------------------------------
  639. // Keep track of number of outstanding writes of UNDO log records to ensure that
  640. // we have saved all UNDO info before concluding local checkpoint.
  641. //-----------------------------------------------------------------------------
  642.   Uint32 nrWaitWriteUndoExit;
  644. //-----------------------------------------------------------------------------
  645. // lastUndoIsStored is used to handle parallel writes of UNDO log and pages to
  646. // know when LCP is completed
  647. //-----------------------------------------------------------------------------
  648.   Uint8 lastUndoIsStored;
  650. //-----------------------------------------------------------------------------
  651. // Set to ZTRUE when local checkpoint freeze occurs and set to ZFALSE when
  652. // local checkpoint concludes.
  653. //-----------------------------------------------------------------------------
  654.   Uint8 createLcp;
  656. //-----------------------------------------------------------------------------
  657. // Flag indicating whether we are in the load phase of restore still.
  658. //-----------------------------------------------------------------------------
  659.   Uint8 loadingFlag;
  661. //-----------------------------------------------------------------------------
  662. // elementLength: Length of element in bucket and overflow pages
  663. // keyLength: Length of key (== 0 if long key or variable key length)
  664. //-----------------------------------------------------------------------------
  665.   Uint8 elementLength;
  666.   Uint8 keyLength;
  668. //-----------------------------------------------------------------------------
  669. // This flag is used to avoid sending a big number of expand or shrink signals
  670. // when simultaneously committing many inserts or deletes.
  671. //-----------------------------------------------------------------------------
  672.   Uint8 expandFlag;
  674. //-----------------------------------------------------------------------------
  675. // hashcheckbit is the bit to check whether to send element to split bucket or not
  676. // k (== 6) is the number of buckets per page
  677. // lhfragbits is the number of bits used to calculate the fragment id
  678. // lhdirbits is the number of bits used to calculate the page id
  679. //-----------------------------------------------------------------------------
  680.   Uint8 hashcheckbit;
  681.   Uint8 k;
  682.   Uint8 lhfragbits;
  683.   Uint8 lhdirbits;
  685. //-----------------------------------------------------------------------------
  686. // nodetype can only be STORED in this release. Is currently only set, never read
  687. // stopQueOp is indicator that locked operations will not start until LCP have
  688. // released the lock on the fragment
  689. //-----------------------------------------------------------------------------
  690.   Uint8 nodetype;
  691.   Uint8 stopQueOp;
  692. };
  694.   typedef Ptr<Fragmentrec> FragmentrecPtr;
  696. /* --------------------------------------------------------------------------------- */
  697. /* FS_CONNECTREC                                                                     */
  698. /* --------------------------------------------------------------------------------- */
  699. struct FsConnectrec {
  700.   Uint32 fsNext;
  701.   Uint32 fsPrev;
  702.   Uint32 fragrecPtr;
  703.   Uint32 fsPtr;
  704.   State fsState;
  705.   Uint8 activeFragId;
  706.   Uint8 fsPart;
  707. }; /* p2c: size = 24 bytes */
  709.   typedef Ptr<FsConnectrec> FsConnectrecPtr;
  711. /* --------------------------------------------------------------------------------- */
  712. /* FS_OPREC                                                                          */
  713. /* --------------------------------------------------------------------------------- */
  714. struct FsOprec {
  715.   Uint32 fsOpnext;
  716.   Uint32 fsOpfragrecPtr;
  717.   Uint32 fsConptr;
  718.   State fsOpstate;
  719.   Uint16 fsOpMemPage;
  720. }; /* p2c: size = 20 bytes */
  722.   typedef Ptr<FsOprec> FsOprecPtr;
  724. /* --------------------------------------------------------------------------------- */
  725. /* LCP_CONNECTREC                                                                    */
  726. /* --------------------------------------------------------------------------------- */
  727. struct LcpConnectrec {
  728.   Uint32 nextLcpConn;
  729.   Uint32 lcpUserptr;
  730.   Uint32 rootrecptr;
  731.   State syncUndopageState;
  732.   State lcpstate;
  733.   Uint32 lcpUserblockref;
  734.   Uint16 localCheckPid;
  735.   Uint8 noOfLcpConf;
  736. };
  737.   typedef Ptr<LcpConnectrec> LcpConnectrecPtr;
  739. /* --------------------------------------------------------------------------------- */
  740. /* OPERATIONREC                                                                      */
  741. /* --------------------------------------------------------------------------------- */
  742. struct Operationrec {
  743.   Uint32 keydata[8];
  744.   Uint32 localdata[2];
  745.   Uint32 elementIsforward;
  746.   Uint32 elementPage;
  747.   Uint32 elementPointer;
  748.   Uint32 fid;
  749.   Uint32 fragptr;
  750.   Uint32 hashvaluePart;
  751.   Uint32 hashValue;
  752.   Uint32 insertDeleteLen;
  753.   Uint32 keyinfoPage;
  754.   Uint32 nextLockOwnerOp;
  755.   Uint32 nextOp;
  756.   Uint32 nextParallelQue;
  757.   Uint32 nextQueOp;
  758.   Uint32 nextSerialQue;
  759.   Uint32 prevOp;
  760.   Uint32 prevLockOwnerOp;
  761.   Uint32 prevParallelQue;
  762.   Uint32 prevQueOp;
  763.   Uint32 prevSerialQue;
  764.   Uint32 scanRecPtr;
  765.   Uint32 transId1;
  766.   Uint32 transId2;
  767.   Uint32 longPagePtr;
  768.   Uint32 longKeyPageIndex;
  769.   State opState;
  770.   Uint32 userptr;
  771.   State transactionstate;
  772.   Uint16 elementContainer;
  773.   Uint16 tupkeylen;
  774.   Uint32 userblockref;
  775.   Uint32 scanBits;
  776.   Uint8 elementIsDisappeared;
  777.   Uint8 insertIsDone;
  778.   Uint8 lockMode;
  779.   Uint8 lockOwner;
  780.   Uint8 nodeType;
  781.   Uint8 operation;
  782.   Uint8 opSimple;
  783.   Uint8 dirtyRead;
  784.   Uint8 commitDeleteCheckFlag;
  785.   Uint8 isAccLockReq;
  786.   Uint32 nextOpList;
  787. }; /* p2c: size = 168 bytes */
  789.   typedef Ptr<Operationrec> OperationrecPtr;
  791. /* --------------------------------------------------------------------------------- */
  792. /* OVERFLOW_RECORD                                                                   */
  793. /* --------------------------------------------------------------------------------- */
  794. struct OverflowRecord {
  795.   Uint32 dirindex;
  796.   Uint32 nextOverRec;
  797.   Uint32 nextOverList;
  798.   Uint32 prevOverRec;
  799.   Uint32 prevOverList;
  800.   Uint32 overpage;
  801.   Uint32 nextfreeoverrec;
  802. };
  804.   typedef Ptr<OverflowRecord> OverflowRecordPtr;
  806. /* --------------------------------------------------------------------------------- */
  807. /* PAGE8                                                                             */
  808. /* --------------------------------------------------------------------------------- */
  809. struct Page8 {
  810.   Uint32 word32[2048];
  811. }; /* p2c: size = 8192 bytes */
  813.   typedef Ptr<Page8> Page8Ptr;
  815. /* --------------------------------------------------------------------------------- */
  816. /* ROOTFRAGMENTREC                                                                   */
  817. /*          DURING EXPAND FRAGMENT PROCESS, EACH FRAGMEND WILL BE EXPAND INTO TWO    */
  818. /*          NEW FRAGMENTS.TO MAKE THIS PROCESS EASIER, DURING ADD FRAGMENT PROCESS   */
  819. /*          NEXT FRAGMENT IDENTIIES WILL BE CALCULATED, AND TWO FRAGMENTS WILL BE    */
  820. /*          ADDED IN (NDBACC). THEREBY EXPAND OF FRAGMENT CAN BE PERFORMED QUICK AND */
  821. /*          EASY.THE NEW FRAGMENT ID SENDS TO TUP MANAGER FOR ALL OPERATION PROCESS. */
  822. /* --------------------------------------------------------------------------------- */
  823. struct Rootfragmentrec {
  824.   Uint32 scan[MAX_PARALLEL_SCANS_PER_FRAG];
  825.   Uint32 fragmentptr[2];
  826.   Uint32 fragmentid[2];
  827.   Uint32 lcpPtr;
  828.   Uint32 mytabptr;
  829.   Uint32 nextroot;
  830.   Uint32 roothashcheck;
  831.   Uint32 noOfElements;
  832.   Uint32 m_commit_count;
  833.   State rootState;
  834. }; /* p2c: size = 72 bytes */
  836.   typedef Ptr<Rootfragmentrec> RootfragmentrecPtr;
  838. /* --------------------------------------------------------------------------------- */
  839. /* SCAN_REC                                                                          */
  840. /* --------------------------------------------------------------------------------- */
  841. struct ScanRec {
  842.   enum ScanState {
  843.     WAIT_NEXT,  
  844.     SCAN_DISCONNECT
  845.   };
  846.   enum ScanBucketState {
  847.     FIRST_LAP,
  848.     SECOND_LAP,
  849.     SCAN_COMPLETED
  850.   };
  851.   Uint32 activeLocalFrag;
  852.   Uint32 rootPtr;
  853.   Uint32 nextBucketIndex;
  854.   Uint32 scanNextfreerec;
  855.   Uint32 scanFirstActiveOp;
  856.   Uint32 scanFirstLockedOp;
  857.   Uint32 scanLastLockedOp;
  858.   Uint32 scanFirstQueuedOp;
  859.   Uint32 scanLastQueuedOp;
  860.   Uint32 scanUserptr;
  861.   Uint32 scanTrid1;
  862.   Uint32 scanTrid2;
  863.   Uint32 startNoOfBuckets;
  864.   Uint32 minBucketIndexToRescan;
  865.   Uint32 maxBucketIndexToRescan;
  866.   Uint32 scanOpsAllocated;
  867.   ScanBucketState scanBucketState;
  868.   ScanState scanState;
  869.   Uint16 scanLockHeld;
  870.   Uint32 scanUserblockref;
  871.   Uint32 scanMask;
  872.   Uint8 scanLockMode;
  873.   Uint8 scanKeyinfoFlag;
  874.   Uint8 scanTimer;
  875.   Uint8 scanContinuebCounter;
  876.   Uint8 scanReadCommittedFlag;
  877. }; 
  879.   typedef Ptr<ScanRec> ScanRecPtr;
  881. /* --------------------------------------------------------------------------------- */
  882. /* SR_VERSION_REC                                                                    */
  883. /* --------------------------------------------------------------------------------- */
  884. struct SrVersionRec {
  885.   Uint32 nextFreeSr;
  886.   Uint32 checkPointId;
  887.   Uint32 prevAddress;
  888.   Uint32 srUnused; /* p2c: Not used */
  889. }; /* p2c: size = 16 bytes */
  891.   typedef Ptr<SrVersionRec> SrVersionRecPtr;
  893. /* --------------------------------------------------------------------------------- */
  894. /* TABREC                                                                            */
  895. /* --------------------------------------------------------------------------------- */
  896. struct Tabrec {
  897.   Uint32 fragholder[MAX_FRAG_PER_NODE];
  898.   Uint32 fragptrholder[MAX_FRAG_PER_NODE];
  899.   Uint32 tabUserPtr;
  900.   BlockReference tabUserRef;
  901. };
  902.   typedef Ptr<Tabrec> TabrecPtr;
  904. /* --------------------------------------------------------------------------------- */
  905. /* UNDOPAGE                                                                          */
  906. /* --------------------------------------------------------------------------------- */
  907. struct Undopage {
  908.   Uint32 undoword[8192];
  909. }; /* p2c: size = 32768 bytes */
  911.   typedef Ptr<Undopage> UndopagePtr;
  913. public:
  914.   Dbacc(const class Configuration &);
  915.   virtual ~Dbacc();
  917. private:
  918.   BLOCK_DEFINES(Dbacc);
  920.   // Transit signals
  921.   void execDEBUG_SIG(Signal* signal);
  922.   void execCONTINUEB(Signal* signal);
  923.   void execACC_CHECK_SCAN(Signal* signal);
  924.   void execEXPANDCHECK2(Signal* signal);
  925.   void execSHRINKCHECK2(Signal* signal);
  926.   void execACC_OVER_REC(Signal* signal);
  927.   void execACC_SAVE_PAGES(Signal* signal);
  928.   void execNEXTOPERATION(Signal* signal);
  929.   void execREAD_PSUEDO_REQ(Signal* signal);
  931.   // Received signals
  932.   void execSTTOR(Signal* signal);
  933.   void execSR_FRAGIDREQ(Signal* signal);
  934.   void execLCP_FRAGIDREQ(Signal* signal);
  935.   void execLCP_HOLDOPREQ(Signal* signal);
  936.   void execEND_LCPREQ(Signal* signal);
  937.   void execACC_LCPREQ(Signal* signal);
  938.   void execSTART_RECREQ(Signal* signal);
  939.   void execACC_CONTOPREQ(Signal* signal);
  940.   void execACCKEYREQ(Signal* signal);
  941.   void execACCSEIZEREQ(Signal* signal);
  942.   void execACCFRAGREQ(Signal* signal);
  943.   void execACC_SRREQ(Signal* signal);
  944.   void execNEXT_SCANREQ(Signal* signal);
  945.   void execACC_ABORTREQ(Signal* signal);
  946.   void execACC_SCANREQ(Signal* signal);
  947.   void execACCMINUPDATE(Signal* signal);
  948.   void execACC_COMMITREQ(Signal* signal);
  949.   void execACC_TO_REQ(Signal* signal);
  950.   void execACC_LOCKREQ(Signal* signal);
  951.   void execFSOPENCONF(Signal* signal);
  952.   void execFSCLOSECONF(Signal* signal);
  953.   void execFSWRITECONF(Signal* signal);
  954.   void execFSREADCONF(Signal* signal);
  955.   void execNDB_STTOR(Signal* signal);
  956.   void execDROP_TAB_REQ(Signal* signal);
  957.   void execFSREMOVECONF(Signal* signal);
  958.   void execREAD_CONFIG_REQ(Signal* signal);
  959.   void execSET_VAR_REQ(Signal* signal);
  960.   void execDUMP_STATE_ORD(Signal* signal);
  962.   // Statement blocks
  963.   void ACCKEY_error(Uint32 fromWhere);
  965.   void commitDeleteCheck();
  967.   void initRootFragPageZero(RootfragmentrecPtr, Page8Ptr);
  968.   void initRootFragSr(RootfragmentrecPtr, Page8Ptr);
  969.   void initFragAdd(Signal*, Uint32 rootFragIndex, Uint32 rootIndex, FragmentrecPtr);
  970.   void initFragPageZero(FragmentrecPtr, Page8Ptr);
  971.   void initFragSr(FragmentrecPtr, Page8Ptr);
  972.   void initFragGeneral(FragmentrecPtr);
  973.   void verifyFragCorrect(FragmentrecPtr regFragPtr);
  974.   void sendFSREMOVEREQ(Signal* signal, Uint32 tableId);
  975.   void sendDROP_TABFILECONF(Signal* signal, TabrecPtr tabPtr);
  976.   void releaseFragResources(Signal* signal, Uint32 fragIndex);
  977.   void releaseRootFragRecord(Signal* signal, RootfragmentrecPtr rootPtr);
  978.   void sendREL_TABMEMCONF(Signal* signal, TabrecPtr tabPtr);
  979.   void releaseRootFragResources(Signal* signal, Uint32 tableId);
  980.   void releaseDirResources(Signal* signal,
  981.                            Uint32 fragIndex,
  982.                            Uint32 dirIndex,
  983.                            Uint32 startIndex);
  984.   void releaseDirectoryResources(Signal* signal,
  985.                                  Uint32 fragIndex,
  986.                                  Uint32 dirIndex,
  987.                                  Uint32 startIndex,
  988.                                  Uint32 directoryIndex);
  989.   void releaseOverflowResources(Signal* signal, FragmentrecPtr regFragPtr);
  990.   void releaseDirIndexResources(Signal* signal, FragmentrecPtr regFragPtr);
  991.   void releaseFragRecord(Signal* signal, FragmentrecPtr regFragPtr);
  992.   Uint32 remainingUndoPages();
  993.   void updateLastUndoPageIdWritten(Signal* signal, Uint32 aNewValue);
  994.   void updateUndoPositionPage(Signal* signal, Uint32 aNewValue);
  995.   void srCheckPage(Signal* signal);
  996.   void srCheckContainer(Signal* signal);
  997.   void initScanFragmentPart(Signal* signal);
  998.   Uint32 checkScanExpand(Signal* signal);
  999.   Uint32 checkScanShrink(Signal* signal);
  1000.   void initialiseDirRec(Signal* signal);
  1001.   void initialiseDirRangeRec(Signal* signal);
  1002.   void initialiseFragRec(Signal* signal);
  1003.   void initialiseFsConnectionRec(Signal* signal);
  1004.   void initialiseFsOpRec(Signal* signal);
  1005.   void initialiseLcpConnectionRec(Signal* signal);
  1006.   void initialiseOperationRec(Signal* signal);
  1007.   void initialiseOverflowRec(Signal* signal);
  1008.   void initialisePageRec(Signal* signal);
  1009.   void initialiseLcpPages(Signal* signal);
  1010.   void initialiseRootfragRec(Signal* signal);
  1011.   void initialiseScanRec(Signal* signal);
  1012.   void initialiseSrVerRec(Signal* signal);
  1013.   void initialiseTableRec(Signal* signal);
  1014.   bool addfragtotab(Signal* signal, Uint32 rootIndex, Uint32 fragId);
  1015.   void initOpRec(Signal* signal);
  1016.   void sendAcckeyconf(Signal* signal);
  1017.   Uint32 placeReadInLockQueue(Signal* signal);
  1018.   void placeSerialQueueRead(Signal* signal);
  1019.   void checkOnlyReadEntry(Signal* signal);
  1020.   Uint32 getNoParallelTransaction(const Operationrec*);
  1021.   void moveLastParallelQueue(Signal* signal);
  1022.   void moveLastParallelQueueWrite(Signal* signal);
  1023.   Uint32 placeWriteInLockQueue(Signal* signal);
  1024.   void placeSerialQueueWrite(Signal* signal);
  1025.   void expandcontainer(Signal* signal);
  1026.   void shrinkcontainer(Signal* signal);
  1027.   void nextcontainerinfoExp(Signal* signal);
  1028.   void lcpCopyPage(Signal* signal);
  1029.   void lcpUpdatePage(Signal* signal);
  1030.   void checkUndoPages(Signal* signal);
  1031.   void undoWritingProcess(Signal* signal);
  1032.   void writeUndoDataInfo(Signal* signal);
  1033.   void writeUndoHeader(Signal* signal, 
  1034.                        Uint32 logicalPageId, 
  1035.                        UndoHeader::UndoHeaderType pageType);
  1036.   void writeUndoOpInfo(Signal* signal);
  1037.   void checksumControl(Signal* signal, Uint32 checkPage);
  1038.   void startActiveUndo(Signal* signal);
  1039.   void releaseAndCommitActiveOps(Signal* signal);
  1040.   void releaseAndCommitQueuedOps(Signal* signal);
  1041.   void releaseAndAbortLockedOps(Signal* signal);
  1042.   void containerinfo(Signal* signal);
  1043.   bool getScanElement(Signal* signal);
  1044.   void initScanOpRec(Signal* signal);
  1045.   void nextcontainerinfo(Signal* signal);
  1046.   void putActiveScanOp(Signal* signal);
  1047.   void putOpScanLockQue();
  1048.   void putReadyScanQueue(Signal* signal, Uint32 scanRecIndex);
  1049.   void releaseScanBucket(Signal* signal);
  1050.   void releaseScanContainer(Signal* signal);
  1051.   void releaseScanRec(Signal* signal);
  1052.   bool searchScanContainer(Signal* signal);
  1053.   void sendNextScanConf(Signal* signal);
  1054.   void sendScaninfo(Signal* signal);
  1055.   void setlock(Signal* signal);
  1056.   void takeOutActiveScanOp(Signal* signal);
  1057.   void takeOutScanLockQueue(Uint32 scanRecIndex);
  1058.   void takeOutReadyScanQueue(Signal* signal);
  1059.   void insertElement(Signal* signal);
  1060.   void insertContainer(Signal* signal);
  1061.   void addnewcontainer(Signal* signal);
  1062.   void getfreelist(Signal* signal);
  1063.   void increaselistcont(Signal* signal);
  1064.   void seizeLeftlist(Signal* signal);
  1065.   void seizeRightlist(Signal* signal);
  1066.   void allocLongOverflowPage(Signal* signal);
  1067.   void allocSpecificLongOverflowPage(Signal* signal);
  1068.   void getLongKeyPage(Signal* signal);
  1069.   void initLongOverpage(Signal* signal);
  1070.   void storeLongKeys(Signal* signal);
  1071.   void storeLongKeysAtPos(Signal* signal);
  1072.   void reorgLongPage(Signal* signal);
  1073.   void getElement(Signal* signal);
  1074.   void searchLongKey(Signal* signal, bool verify);
  1075.   void getdirindex(Signal* signal);
  1076.   void commitdelete(Signal* signal, bool systemRestart);
  1077.   void deleteElement(Signal* signal);
  1078.   void getLastAndRemove(Signal* signal);
  1079.   void releaseLeftlist(Signal* signal);
  1080.   void releaseRightlist(Signal* signal);
  1081.   void checkoverfreelist(Signal* signal);
  1082.   void deleteLongKey(Signal* signal);
  1083.   void removeFromPageArrayList(Signal* signal);
  1084.   void insertPageArrayList(Signal* signal);
  1085.   void checkPageArrayList(Signal* signal, const char *);
  1086.   void checkPageB4Insert(Uint32, const char *); 
  1087.   void checkPageB4Remove(Uint32, const char *); 
  1088.   void checkIndexInLongKeyPage(Uint32, const char *);
  1089.   void printoutInfoAndShutdown(LongKeyPage *);
  1090.   void releaseLongPage(Signal* signal);
  1091.   void abortOperation(Signal* signal);
  1092.   void accAbortReqLab(Signal* signal, bool sendConf);
  1093.   void commitOperation(Signal* signal);
  1094.   void copyOpInfo(Signal* signal);
  1095.   Uint32 executeNextOperation(Signal* signal);
  1096.   void releaselock(Signal* signal);
  1097.   void takeOutFragWaitQue(Signal* signal);
  1098.   void check_lock_upgrade(Signal* signal, OperationrecPtr lock_owner,
  1099.   OperationrecPtr release_op);
  1100.   void allocOverflowPage(Signal* signal);
  1101.   bool getrootfragmentrec(Signal* signal, RootfragmentrecPtr&, Uint32 fragId);
  1102.   void insertLockOwnersList(Signal* signal, const OperationrecPtr&);
  1103.   void takeOutLockOwnersList(Signal* signal, const OperationrecPtr&);
  1104.   void initFsOpRec(Signal* signal);
  1105.   void initLcpConnRec(Signal* signal);
  1106.   void initOverpage(Signal* signal);
  1107.   void initPage(Signal* signal);
  1108.   void initPageZero(Signal* signal);
  1109.   void initRootfragrec(Signal* signal);
  1110.   void putOpInFragWaitQue(Signal* signal);
  1111.   void putOverflowRecInFrag(Signal* signal);
  1112.   void putRecInFreeOverdir(Signal* signal);
  1113.   void releaseDirectory(Signal* signal);
  1114.   void releaseDirrange(Signal* signal);
  1115.   void releaseFsConnRec(Signal* signal);
  1116.   void releaseFsOpRec(Signal* signal);
  1117.   void releaseLcpConnectRec(Signal* signal);
  1118.   void releaseOpRec(Signal* signal);
  1119.   void releaseOverflowRec(Signal* signal);
  1120.   void releaseOverpage(Signal* signal);
  1121.   void releasePage(Signal* signal);
  1122.   void releaseLcpPage(Signal* signal);
  1123.   void releaseSrRec(Signal* signal);
  1124.   void releaseLogicalPage(Fragmentrec * fragP, Uint32 logicalPageId);
  1125.   void seizeDirectory(Signal* signal);
  1126.   void seizeDirrange(Signal* signal);
  1127.   void seizeFragrec(Signal* signal);
  1128.   void seizeFsConnectRec(Signal* signal);
  1129.   void seizeFsOpRec(Signal* signal);
  1130.   void seizeLcpConnectRec(Signal* signal);
  1131.   void seizeOpRec(Signal* signal);
  1132.   void seizeOverRec(Signal* signal);
  1133.   void seizePage(Signal* signal);
  1134.   void seizeLcpPage(Page8Ptr&);
  1135.   void seizeRootfragrec(Signal* signal);
  1136.   void seizeScanRec(Signal* signal);
  1137.   void seizeSrVerRec(Signal* signal);
  1138.   void sendSystemerror(Signal* signal);
  1139.   void takeRecOutOfFreeOverdir(Signal* signal);
  1140.   void takeRecOutOfFreeOverpage(Signal* signal);
  1141.   void sendScanHbRep(Signal* signal, Uint32);
  1143.   void addFragRefuse(Signal* signal, Uint32 errorCode);
  1144.   void ndbsttorryLab(Signal* signal);
  1145.   void srCloseDataFileLab(Signal* signal);
  1146.   void acckeyref1Lab(Signal* signal, Uint32 result_code);
  1147.   void insertelementLab(Signal* signal);
  1148.   void startUndoLab(Signal* signal);
  1149.   void checkNextFragmentLab(Signal* signal);
  1150.   void endofexpLab(Signal* signal);
  1151.   void endofshrinkbucketLab(Signal* signal);
  1152.   void srStartUndoLab(Signal* signal);
  1153.   void senddatapagesLab(Signal* signal);
  1154.   void undoNext2Lab(Signal* signal);
  1155.   void sttorrysignalLab(Signal* signal);
  1156.   void sendholdconfsignalLab(Signal* signal);
  1157.   void accIsLockedLab(Signal* signal);
  1158.   void insertExistElemLab(Signal* signal);
  1159.   void refaccConnectLab(Signal* signal);
  1160.   void srReadOverPagesLab(Signal* signal);
  1161.   void releaseScanLab(Signal* signal);
  1162.   void exeoperationLab(Signal* signal);
  1163.   void saveKeyDataLab(Signal* signal);
  1164.   void lcpOpenUndofileConfLab(Signal* signal);
  1165.   void srFsOpenConfLab(Signal* signal);
  1166.   void checkSyncUndoPagesLab(Signal* signal);
  1167.   void sendaccSrconfLab(Signal* signal);
  1168.   void checkSendLcpConfLab(Signal* signal);
  1169.   void endsaveoverpageLab(Signal* signal);
  1170.   void lcpCloseDataFileLab(Signal* signal);
  1171.   void srOpenDataFileLoopLab(Signal* signal);
  1172.   void srReadPagesLab(Signal* signal);
  1173.   void srDoUndoLab(Signal* signal);
  1174.   void ndbrestart1Lab(Signal* signal);
  1175.   void initialiseRecordsLab(Signal* signal, Uint32 returnRef, Uint32 retData);
  1176.   void srReadPagesAllocLab(Signal* signal);
  1177.   void checkNextBucketLab(Signal* signal);
  1178.   void endsavepageLab(Signal* signal);
  1179.   void saveZeroPageLab(Signal* signal);
  1180.   void srAllocPage0011Lab(Signal* signal);
  1181.   void allocscanrecLab(Signal* signal);
  1182.   void sendLcpFragidconfLab(Signal* signal);
  1183.   void savepagesLab(Signal* signal);
  1184.   void saveOverPagesLab(Signal* signal);
  1185.   void srReadPageZeroLab(Signal* signal);
  1186.   void storeDataPageInDirectoryLab(Signal* signal);
  1187.   void lcpFsOpenConfLab(Signal* signal);
  1189.   void zpagesize_error(const char* where);
  1191.   void reportMemoryUsage(Signal* signal, int gth);
  1192.   void lcp_write_op_to_undolog(Signal* signal);
  1193.   void reenable_expand_after_redo_log_exection_complete(Signal*);
  1196.   // Initialisation
  1197.   void initData();
  1198.   void initRecords();
  1200.   // Variables
  1201. /* --------------------------------------------------------------------------------- */
  1202. /* DIRECTORY RANGE                                                                   */
  1203. /* --------------------------------------------------------------------------------- */
  1204.   DirRange *dirRange;
  1205.   DirRangePtr expDirRangePtr;
  1206.   DirRangePtr gnsDirRangePtr;
  1207.   DirRangePtr newDirRangePtr;
  1208.   DirRangePtr rdDirRangePtr;
  1209.   DirRangePtr nciOverflowrangeptr;
  1210.   Uint32 cdirrangesize;
  1211.   Uint32 cfirstfreeDirrange;
  1212. /* --------------------------------------------------------------------------------- */
  1213. /* DIRECTORYARRAY                                                                    */
  1214. /* --------------------------------------------------------------------------------- */
  1215.   Directoryarray *directoryarray;
  1216.   DirectoryarrayPtr expDirptr;
  1217.   DirectoryarrayPtr rdDirptr;
  1218.   DirectoryarrayPtr sdDirptr;
  1219.   DirectoryarrayPtr nciOverflowDirptr;
  1220.   Uint32 cdirarraysize;
  1221.   Uint32 cdirmemory;
  1222.   Uint32 cfirstfreedir;
  1223. /* --------------------------------------------------------------------------------- */
  1224. /* FRAGMENTREC. ALL INFORMATION ABOUT FRAMENT AND HASH TABLE IS SAVED IN FRAGMENT    */
  1225. /*         REC  A POINTER TO FRAGMENT RECORD IS SAVED IN ROOTFRAGMENTREC FRAGMENT    */
  1226. /* --------------------------------------------------------------------------------- */
  1227.   Fragmentrec *fragmentrec;
  1228.   FragmentrecPtr fragrecptr;
  1229.   Uint32 cfirstfreefrag;
  1230.   Uint32 cfragmentsize;
  1231. /* --------------------------------------------------------------------------------- */
  1232. /* FS_CONNECTREC                                                                     */
  1233. /* --------------------------------------------------------------------------------- */
  1234.   FsConnectrec *fsConnectrec;
  1235.   FsConnectrecPtr fsConnectptr;
  1236.   Uint32 cfsConnectsize;
  1237.   Uint32 cfsFirstfreeconnect;
  1238. /* --------------------------------------------------------------------------------- */
  1239. /* FS_OPREC                                                                          */
  1240. /* --------------------------------------------------------------------------------- */
  1241.   FsOprec *fsOprec;
  1242.   FsOprecPtr fsOpptr;
  1243.   Uint32 cfsOpsize;
  1244.   Uint32 cfsFirstfreeop;
  1245. /* --------------------------------------------------------------------------------- */
  1246. /* LCP_CONNECTREC                                                                    */
  1247. /* --------------------------------------------------------------------------------- */
  1248.   LcpConnectrec *lcpConnectrec;
  1249.   LcpConnectrecPtr lcpConnectptr;
  1250.   Uint32 clcpConnectsize;
  1251.   Uint32 cfirstfreelcpConnect;
  1252. /* --------------------------------------------------------------------------------- */
  1253. /* OPERATIONREC                                                                      */
  1254. /* --------------------------------------------------------------------------------- */
  1255.   Operationrec *operationrec;
  1256.   OperationrecPtr operationRecPtr;
  1257.   OperationrecPtr idrOperationRecPtr;
  1258.   OperationrecPtr copyInOperPtr;
  1259.   OperationrecPtr copyOperPtr;
  1260.   OperationrecPtr mlpqOperPtr;
  1261.   OperationrecPtr queOperPtr;
  1262.   OperationrecPtr readWriteOpPtr;
  1263.   Uint32 cfreeopRec;
  1264.   Uint32 coprecsize;
  1265. /* --------------------------------------------------------------------------------- */
  1266. /* OVERFLOW_RECORD                                                                   */
  1267. /* --------------------------------------------------------------------------------- */
  1268.   OverflowRecord *overflowRecord;
  1269.   OverflowRecordPtr iopOverflowRecPtr;
  1270.   OverflowRecordPtr tfoOverflowRecPtr;
  1271.   OverflowRecordPtr porOverflowRecPtr;
  1272.   OverflowRecordPtr priOverflowRecPtr;
  1273.   OverflowRecordPtr rorOverflowRecPtr;
  1274.   OverflowRecordPtr sorOverflowRecPtr;
  1275.   OverflowRecordPtr troOverflowRecPtr;
  1276.   Uint32 cfirstfreeoverrec;
  1277.   Uint32 coverflowrecsize;
  1279. /* --------------------------------------------------------------------------------- */
  1280. /* PAGE8                                                                             */
  1281. /* --------------------------------------------------------------------------------- */
  1282.   Page8 *page8;
  1283.   /* 8 KB PAGE                       */
  1284.   Page8Ptr aslpPageptr;
  1285.   Page8Ptr alpPageptr;
  1286.   Page8Ptr ancPageptr;
  1287.   Page8Ptr colPageptr;
  1288.   Page8Ptr ccoPageptr;
  1289.   Page8Ptr datapageptr;
  1290.   Page8Ptr delPageptr;
  1291.   Page8Ptr excPageptr;
  1292.   Page8Ptr expPageptr;
  1293.   Page8Ptr gdiPageptr;
  1294.   Page8Ptr gePageptr;
  1295.   Page8Ptr gflPageptr;
  1296.   Page8Ptr glkPageptr;
  1297.   Page8Ptr idrPageptr;
  1298.   Page8Ptr ilcPageptr;
  1299.   Page8Ptr iloPageptr;
  1300.   Page8Ptr inpPageptr;
  1301.   Page8Ptr iopPageptr;
  1302.   Page8Ptr ipzPageptr;
  1303.   Page8Ptr lastPageptr;
  1304.   Page8Ptr lastPrevpageptr;
  1305.   Page8Ptr lcnPageptr;
  1306.   Page8Ptr lcnCopyPageptr;
  1307.   Page8Ptr lupPageptr;
  1308.   Page8Ptr dlkPageptr;
  1309.   Page8Ptr ipaPagePtr;
  1310.   Page8Ptr priPageptr;
  1311.   Page8Ptr pwiPageptr;
  1312.   Page8Ptr rfpPageptr;
  1313.   Page8Ptr relpPageptr;
  1314.   Page8Ptr rlopPageptr;
  1315.   Page8Ptr slkPageptr;
  1316.   Page8Ptr slkCopyPageptr;
  1317.   Page8Ptr slkapPageptr;
  1318.   Page8Ptr slkapCopyPageptr;
  1319.   Page8Ptr ciPageidptr;
  1320.   Page8Ptr gsePageidptr;
  1321.   Page8Ptr isoPageptr;
  1322.   Page8Ptr nciPageidptr;
  1323.   Page8Ptr rsbPageidptr;
  1324.   Page8Ptr rscPageidptr;
  1325.   Page8Ptr slPageidptr;
  1326.   Page8Ptr sscPageidptr;
  1327.   Page8Ptr rlPageptr;
  1328.   Page8Ptr rlpPageptr;
  1329.   Page8Ptr ropPageptr;
  1330.   Page8Ptr rpPageptr;
  1331.   Page8Ptr slPageptr;
  1332.   Page8Ptr slpPageptr;
  1333.   Page8Ptr spPageptr;
  1334.   Uint32 cfirstfreepage;
  1335.   Uint32 cfreepage;
  1336.   Uint32 cpagesize;
  1337.   Uint32 cfirstfreeLcpPage;
  1338.   Uint32 cnoOfAllocatedPages;
  1339.   Uint32 cnoLcpPages;
  1340. /* --------------------------------------------------------------------------------- */
  1341. /* ROOTFRAGMENTREC                                                                   */
  1342. /*          DURING EXPAND FRAGMENT PROCESS, EACH FRAGMEND WILL BE EXPAND INTO TWO    */
  1343. /*          NEW FRAGMENTS.TO MAKE THIS PROCESS EASIER, DURING ADD FRAGMENT PROCESS   */
  1344. /*          NEXT FRAGMENT IDENTIIES WILL BE CALCULATED, AND TWO FRAGMENTS WILL BE    */
  1345. /*          ADDED IN (NDBACC). THEREBY EXPAND OF FRAGMENT CAN BE PERFORMED QUICK AND */
  1346. /*          EASY.THE NEW FRAGMENT ID SENDS TO TUP MANAGER FOR ALL OPERATION PROCESS. */
  1347. /* --------------------------------------------------------------------------------- */
  1348.   Rootfragmentrec *rootfragmentrec;
  1349.   RootfragmentrecPtr rootfragrecptr;
  1350.   RootfragmentrecPtr tmprootfrgptr;
  1351.   Uint32 crootfragmentsize;
  1352.   Uint32 cfirstfreerootfrag;
  1353. /* --------------------------------------------------------------------------------- */
  1354. /* SCAN_REC                                                                          */
  1355. /* --------------------------------------------------------------------------------- */
  1356.   ScanRec *scanRec;
  1357.   ScanRecPtr scanPtr;
  1358.   Uint32 cscanRecSize;
  1359.   Uint32 cfirstFreeScanRec;
  1360. /* --------------------------------------------------------------------------------- */
  1361. /* SR_VERSION_REC                                                                    */
  1362. /* --------------------------------------------------------------------------------- */
  1363.   SrVersionRec *srVersionRec;
  1364.   SrVersionRecPtr srVersionPtr;
  1365.   Uint32 csrVersionRecSize;
  1366.   Uint32 cfirstFreeSrVersionRec;
  1367. /* --------------------------------------------------------------------------------- */
  1368. /* TABREC                                                                            */
  1369. /* --------------------------------------------------------------------------------- */
  1370.   Tabrec *tabrec;
  1371.   TabrecPtr tabptr;
  1372.   Uint32 ctablesize;
  1373. /* --------------------------------------------------------------------------------- */
  1374. /* UNDOPAGE                                                                          */
  1375. /* --------------------------------------------------------------------------------- */
  1376.   Undopage *undopage;
  1377.                                                    /* 32 KB PAGE                      */
  1378.   UndopagePtr undopageptr;
  1379.   Uint32 tpwiElementptr;
  1380.   Uint32 tpriElementptr;
  1381.   Uint32 tgseElementptr;
  1382.   Uint32 tgseContainerptr;
  1383.   Uint32 tiloIndex;
  1384.   Uint32 trlHead;
  1385.   Uint32 trlRelCon;
  1386.   Uint32 trlNextused;
  1387.   Uint32 trlPrevused;
  1388.   Uint32 tlcnChecksum;
  1389.   Uint32 tlupElemIndex;
  1390.   Uint32 tlupIndex;
  1391.   Uint32 tlupForward;
  1392.   Uint32 tslkPageIndex;
  1393.   Uint32 tslkKeyLen;
  1394.   Uint32 tslkapKeyLen;
  1395.   Uint32 tslkapPageIndex;
  1396.   Uint32 tipaArrayPos;
  1397.   Uint32 trfpArrayPos;
  1398.   Uint32 tdlkLogicalPageIndex;
  1399.   Uint32 tancNext;
  1400.   Uint32 tancBufType;
  1401.   Uint32 tancContainerptr;
  1402.   Uint32 tancPageindex;
  1403.   Uint32 tancPageid;
  1404.   Uint32 tidrResult;
  1405.   Uint32 tidrKeyLen;
  1406.   Uint32 tidrElemhead;
  1407.   Uint32 tidrForward;
  1408.   Uint32 tidrPageindex;
  1409.   Uint32 tidrContainerptr;
  1410.   Uint32 tidrContainerhead;
  1411.   Uint32 tlastForward;
  1412.   Uint32 tlastPageindex;
  1413.   Uint32 tlastContainerlen;
  1414.   Uint32 tlastElementptr;
  1415.   Uint32 tlastContainerptr;
  1416.   Uint32 tlastContainerhead;
  1417.   Uint32 trlPageindex;
  1418.   Uint32 tdelContainerptr;
  1419.   Uint32 tdelElementptr;
  1420.   Uint32 tdelForward;
  1421.   Uint32 tiopPageId;
  1422.   Uint32 tipPageId;
  1423.   Uint32 ttupKeyLength;
  1424.   Uint32 tgeLocked;
  1425.   Uint32 tgeResult;
  1426.   Uint32 tgeContainerptr;
  1427.   Uint32 tgeElementptr;
  1428.   Uint32 tgeForward;
  1429.   Uint32 tslcResult;
  1430.   Uint32 tslcPagedir;
  1431.   Uint32 tslcPageIndex;
  1432.   Uint32 tundoElemIndex;
  1433.   Uint32 texpReceivedBucket;
  1434.   Uint32 texpDirInd;
  1435.   Uint32 texpDirRangeIndex;
  1436.   Uint32 texpDirPageIndex;
  1437.   Uint32 tdata0;
  1438.   Uint32 tcheckpointid;
  1439.   Uint32 tciContainerptr;
  1440.   Uint32 tnciContainerptr;
  1441.   Uint32 tisoContainerptr;
  1442.   Uint32 trscContainerptr;
  1443.   Uint32 tsscContainerptr;
  1444.   Uint32 tciContainerlen;
  1445.   Uint32 trscContainerlen;
  1446.   Uint32 tsscContainerlen;
  1447.   Uint32 tciContainerhead;
  1448.   Uint32 tnciContainerhead;
  1449.   Uint32 tslElementptr;
  1450.   Uint32 tisoElementptr;
  1451.   Uint32 tsscElementptr;
  1452.   Uint32 tfid;
  1453.   Uint32 tscanFlag;
  1454.   Uint32 theadundoindex;
  1455.   Uint32 tgflBufType;
  1456.   Uint32 thashvalue;
  1457.   Uint32 tgseIsforward;
  1458.   Uint32 tsscIsforward;
  1459.   Uint32 trscIsforward;
  1460.   Uint32 tciIsforward;
  1461.   Uint32 tnciIsforward;
  1462.   Uint32 tisoIsforward;
  1463.   Uint32 tgseIsLocked;
  1464.   Uint32 tsscIsLocked;
  1465.   Uint32 tkey1;
  1466.   Uint32 tkey2;
  1467.   Uint32 tkey3;
  1468.   Uint32 tkey4;
  1469.   Uint32 tkeylen;
  1470.   Uint32 tkSize;
  1471.   Uint32 tlhfragbits;
  1472.   Uint32 tlhdirbits;
  1473.   Uint32 tlocalkeylen;
  1474.   Uint32 tmaxloadfactor;
  1475.   Uint32 tminloadfactor;
  1476.   Uint32 tmp;
  1477.   Uint32 tmpP;
  1478.   Uint32 tmpP2;
  1479.   Uint32 taslpDirIndex;
  1480.   Uint32 tmp1;
  1481.   Uint32 tmp2;
  1482.   Uint32 tgflPageindex;
  1483.   Uint32 tmpindex;
  1484.   Uint32 tslNextfree;
  1485.   Uint32 tslPageindex;
  1486.   Uint32 tgsePageindex;
  1487.   Uint32 tnciNextSamePage;
  1488.   Uint32 tslPrevfree;
  1489.   Uint32 tciPageindex;
  1490.   Uint32 trsbPageindex;
  1491.   Uint32 tnciPageindex;
  1492.   Uint32 tlastPrevconptr;
  1493.   Uint32 treqinfo;
  1494.   Uint32 transactionid1;
  1495.   Uint32 transactionid2;
  1496.   Uint32 tresult;
  1497.   Uint32 tslUpdateHeader;
  1498.   Uint32 tuserptr;
  1499.   BlockReference tuserblockref;
  1500.   Uint32 tundoindex;
  1501.   Uint32 tlqhPointer;
  1502.   Uint32 tholdSentOp;
  1503.   Uint32 tholdMore;
  1504.   Uint32 tlcpLqhCheckV;
  1505.   Uint32 tgdiPageindex;
  1506.   Uint32 tiopIndex;
  1507.   Uint32 tnciTmp;
  1508.   Uint32 tlenKeyinfo;
  1509.   Uint32 tullIndex;
  1510.   Uint32 turlIndex;
  1511.   Uint32 tlfrTmp1;
  1512.   Uint32 tlfrTmp2;
  1513.   Uint32 tudqeIndex;
  1514.   Uint32 tscanTrid1;
  1515.   Uint32 tscanTrid2;
  1516.   Uint32 taccscanTmp;
  1518.   Uint16 clastUndoPageIdWritten;
  1519.   Uint32 cactiveCheckpId;
  1520.   Uint32 cactiveRootfrag;
  1521.   Uint32 cactiveSrFsPtr;
  1522.   Uint32 cactiveUndoFilePage;
  1523.   Uint32 cactiveOpenUndoFsPtr;
  1524.   Uint32 cactiveSrUndoPage;
  1525.   Uint32 cprevUndoaddress;
  1526.   Uint32 creadyUndoaddress;
  1527.   Uint32 ctest;
  1528.   Uint32 cundoLogActive;
  1529.   Uint32 clqhPtr;
  1530.   BlockReference clqhBlockRef;
  1531.   Uint32 cminusOne;
  1532.   NodeId cmynodeid;
  1533.   Uint32 cactiveUndoFileVersion;
  1534.   BlockReference cownBlockref;
  1535.   BlockReference cndbcntrRef;
  1536.   Uint16 csignalkey;
  1537.   Uint32 cundopagesize;
  1538.   Uint32 cundoposition;
  1539.   Uint32 cundoElemIndex;
  1540.   Uint32 cundoinfolength;
  1541.   Uint32 czero;
  1542.   Uint32 csrVersList[16];
  1543.   Uint32 clblPageCounter;
  1544.   Uint32 clblPageOver;
  1545.   Uint32 clblPagesPerTick;
  1546.   Uint32 clblPagesPerTickAfterSr;
  1547.   Uint32 csystemRestart;
  1548.   Uint32 cexcForward;
  1549.   Uint32 cexcPageindex;
  1550.   Uint32 cexcContainerptr;
  1551.   Uint32 cexcContainerhead;
  1552.   Uint32 cexcContainerlen;
  1553.   Uint32 cexcElementptr;
  1554.   Uint32 cexcPrevconptr;
  1555.   Uint32 cexcMovedLen;
  1556.   Uint32 cexcPrevpageptr;
  1557.   Uint32 cexcPrevpageindex;
  1558.   Uint32 cexcPrevforward;
  1559.   Uint32 clocalkey[32];
  1560.   Uint32 ckeys[2048];
  1561.   
  1562.   Uint32 c_errorInsert3000_TableId;
  1563.   Uint32 cSrUndoRecords[5];
  1564. };
  1566. #endif