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

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

MySQL数据库

开发平台：

Visual C++

Dbtup.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 DBTUP_H
  18. #define DBTUP_H
  20. #include <pc.hpp>
  21. #include <SimulatedBlock.hpp>
  22. #include <ndb_limits.h>
  23. #include <trigger_definitions.h>
  24. #include <ArrayList.hpp>
  25. #include <AttributeHeader.hpp>
  26. #include <Bitmask.hpp>
  27. #include <signaldata/TupKey.hpp>
  28. #include <signaldata/CreateTrig.hpp>
  29. #include <signaldata/DropTrig.hpp>
  30. #include <signaldata/TrigAttrInfo.hpp>
  31. #include <signaldata/BuildIndx.hpp>
  33. #define ZWORDS_ON_PAGE 8192          /* NUMBER OF WORDS ON A PAGE.      */
  34. #define ZATTRBUF_SIZE 32             /* SIZE OF ATTRIBUTE RECORD BUFFER */
  35. #define ZMIN_PAGE_LIMIT_TUPKEYREQ 5
  36. #define ZTUP_VERSION_BITS 15
  38. #ifdef DBTUP_C
  39. //------------------------------------------------------------------
  40. // Jam Handling:
  41. //
  42. // When DBTUP reports lines through jam in the trace files it has to
  43. // be interpreted. 4024 means as an example line 24 in DbtupCommit.cpp
  44. // Thus 4000 is added to the line number beacuse it is located in the
  45. // file DbtupCommit.cpp. The following is the exhaustive list of the
  46. // added value in the various files. ndbrequire, ptrCheckGuard still
  47. // only reports the line number in the file it currently is located in.
  48. // 
  49. // DbtupExecQuery.cpp         0
  50. // DbtupBuffer.cpp         2000
  51. // DbtupRoutines.cpp       3000
  52. // DbtupCommit.cpp         5000
  53. // DbtupFixAlloc.cpp       6000
  54. // DbtupTrigger.cpp        7000
  55. // DbtupAbort.cpp          9000
  56. // DbtupLCP.cpp           10000
  57. // DbtupUndoLog.cpp       12000
  58. // DbtupPageMap.cpp       14000
  59. // DbtupPagMan.cpp        16000
  60. // DbtupStoredProcDef.cpp 18000
  61. // DbtupMeta.cpp          20000
  62. // DbtupTabDesMan.cpp     22000
  63. // DbtupGen.cpp           24000
  64. // DbtupSystemRestart.cpp 26000
  65. // DbtupIndex.cpp         28000
  66. // DbtupDebug.cpp         30000
  67. //------------------------------------------------------------------
  69. /*
  70. 2.2 LOCAL SYMBOLS
  71. -----------------
  72. */
  73. /* ---------------------------------------------------------------- */
  74. /*       S I Z E              O F               R E C O R D S       */
  75. /* ---------------------------------------------------------------- */
  76. #define ZNO_OF_ATTRBUFREC 10000             /* SIZE   OF ATTRIBUTE INFO FILE   */
  77. #define ZNO_OF_CONCURRENT_OPEN_OP 40        /* NUMBER OF CONCURRENT OPENS      */
  78. #define ZNO_OF_CONCURRENT_WRITE_OP 80       /* NUMBER OF CONCURRENT DISK WRITES*/
  79. #define ZNO_OF_FRAGOPREC 20                 /* NUMBER OF CONCURRENT ADD FRAG.  */
  80. #define ZNO_OF_LCP_REC 10                   /* NUMBER OF CONCURRENT CHECKPOINTS*/
  81. #define TOT_PAGE_RECORD_SPACE 262144        /* SIZE OF PAGE RECORD FILE.       */
  82. #define ZNO_OF_PAGE TOT_PAGE_RECORD_SPACE/ZWORDS_ON_PAGE   
  83. #define ZNO_OF_PAGE_RANGE_REC 128           /* SIZE OF PAGE RANGE FILE         */
  84. #define ZNO_OF_PARALLELL_UNDO_FILES 16      /* NUMBER OF PARALLEL UNDO FILES   */
  85. #define ZNO_OF_RESTART_INFO_REC 10          /* MAXIMUM PARALLELL RESTART INFOS */
  86.     /* 24 SEGMENTS WITH 8 PAGES IN EACH*/
  87.                     /* PLUS ONE UNDO BUFFER CACHE      */
  88. // Undo record identifiers are 32-bits with page index 13-bits
  89. #define ZUNDO_RECORD_ID_PAGE_INDEX 13    /* 13 BITS = 8192 WORDS/PAGE       */
  90. #define ZUNDO_RECORD_ID_PAGE_INDEX_MASK (ZWORDS_ON_PAGE - 1) /* 1111111111111 */
  92. // Trigger constants
  93. #define ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE 16
  95. /* ---------------------------------------------------------------- */
  96. // VARIABLE NUMBERS OF PAGE_WORD, UNDO_WORD AND LOGIC_WORD FOR
  97. // COMMUNICATION WITH FILE SYSTEM
  98. /* ---------------------------------------------------------------- */
  99. #define ZBASE_ADDR_PAGE_WORD 1              /* BASE ADDRESS OF PAGE_WORD VAR   */
  100. #define ZBASE_ADDR_UNDO_WORD 2              /* BASE ADDRESS OF UNDO_WORD VAR   */
  101. #define ZBASE_ADDR_LOGIC_WORD 3             /* BASE ADDRESS OF LOGIC_WORD VAR  */
  103. /* ---------------------------------------------------------------- */
  104. // NUMBER OF PAGES SENT TO DISK IN DATA BUFFER AND UNDO BUFFER WHEN
  105. // OPTIMUM PERFORMANCE IS ACHIEVED.
  106. /* ---------------------------------------------------------------- */
  107. #define ZUB_SEGMENT_SIZE 8                  /* SEGMENT SIZE OF UNDO BUFFER     */
  108. #define ZDB_SEGMENT_SIZE 8                  /* SEGMENT SIZE OF DATA BUFFER     */
  110. /* ---------------------------------------------------------------- */
  111. /* A ATTRIBUTE MAY BE NULL, DYNAMIC OR NORMAL. A NORMAL ATTRIBUTE   */
  112. /* IS A ATTRIBUTE THAT IS NOT NULL OR DYNAMIC. A NULL ATTRIBUTE     */
  113. /* MAY HAVE NO VALUE. A DYNAMIC ATTRIBUTE IS A NULL ATTRIBUTE THAT  */
  114. /* DOES NOT HAVE TO BE A MEMBER OF EVERY TUPLE I A CERTAIN TABLE.   */
  115. /* ---------------------------------------------------------------- */
  116. /**
  117.  * #defines moved into include/kernel/Interpreter.hpp
  118.  */
  119. #define ZMAX_REGISTER 21
  120. #define ZINSERT_DELETE 0
  121. /* ---------------------------------------------------------------- */
  122. /* THE MINIMUM SIZE OF AN 'EMPTY' TUPLE HEADER IN R-WORDS           */
  123. /* ---------------------------------------------------------------- */
  124. #define ZTUP_HEAD_MINIMUM_SIZE 2
  125.           /* THE TUPLE HEADER FIELD 'SIZE OF NULL ATTR. FIELD' SPECIFYES    */
  126.           /* THE SIZE OF THE TUPLE HEADER FIELD 'NULL ATTR. FIELD'.         */
  127.           /* THE TUPLE HEADER FIELD 'TYPE' SPECIFYES THE TYPE OF THE TUPLE  */
  128.           /* HEADER.                                                        */
  129.                                /* TUPLE ATTRIBUTE INDEX CLUSTERS, ATTRIBUTE */
  130.                                /* CLUSTERS AND A DYNAMIC ATTRIBUTE HEADER.  */
  131.                                /* IT MAY ALSO CONTAIN SHORT ATTRIBUTES AND  */
  132.                                /* POINTERS TO LONG ATTRIBUTE HEADERS.       */
  133.                                /* TUPLE ATTRIBUTE INDEX CLUSTERS, ATTRIBUTE */
  134.                                /* CLUSTERS AND A DYNAMIC ATTRIBUTE HEADER.  */
  136. #define ZTH_TYPE3 2            /* TUPLE HEADER THAT MAY HAVE A POINTER TO   */
  137.                                /* A DYNAMIC ATTRIBUTE HEADER. IT MAY ALSO   */
  138.                                /* CONTAIN SHORT ATTRIBUTES AND POINTERS     */
  139.                                /* TO LONG ATTRIBUTE HEADERS.                */
  141.           /* DATA STRUCTURE TYPES */
  142.           /* WHEN ATTRIBUTE INFO IS SENT WITH A ATTRINFO-SIGNAL THE         */
  143.           /* VARIABLE TYPE IS SPECIFYED. THIS MUST BE DONE TO BE ABLE TO    */
  144.           /* NOW HOW MUCH DATA OF A ATTRIBUTE TO READ FROM ATTRINFO.        */
  145. #define ZFIXED_ARRAY 2                             /* ZFIXED  ARRAY FIELD.                  */
  146. #define ZNON_ARRAY 1                               /* NORMAL FIELD.                         */
  147. #define ZVAR_ARRAY 0                               /* VARIABLE ARRAY FIELD                  */
  148. #define ZNOT_STORE 3                               /* THE ATTR IS STORED IN THE INDEX BLOCK */
  149. #define ZMAX_SMALL_VAR_ARRAY 256
  151.           /* PLEASE OBSERVE THAT THEESE CONSTANTS CORRESPONDS TO THE NUMBER */
  152.           /* OF BITS NEEDED TO REPRESENT THEM    D O    N O T   C H A N G E */
  153. #define Z1BIT_VAR 0                                /* 1 BIT VARIABLE.                        */
  154. #define Z2BIT_VAR 1                                /* 2 BIT VARIABLE.                        */
  155. #define Z4BIT_VAR 2                                /* 4 BIT VARIABLE.                        */
  156. #define Z8BIT_VAR 3                                /* 8 BIT VARIABLE.                        */
  157. #define Z16BIT_VAR 4                               /* 16 BIT VARIABLE.                       */
  158. #define Z32BIT_VAR 5                               /* 32 BIT VARIABLE.                       */
  159. #define Z64BIT_VAR 6                               /* 64 BIT VARIABLE.                       */
  160. #define Z128BIT_VAR 7                              /* 128 BIT VARIABLE.                      */
  162.           /* WHEN A REQUEST CAN NOT BE EXECUTED BECAUSE OF A ERROR THE      */
  163.           /* ERROR MUST BE IDENTIFYED BY MEANS OF A ERROR CODE AND SENT TO  */
  164.           /* THE REQUESTER.                                                 */
  165. #define ZGET_OPREC_ERROR 804            // TUP_SEIZEREF
  167. #define ZEXIST_FRAG_ERROR 816           // Add fragment
  168. #define ZFULL_FRAGRECORD_ERROR 817      // Add fragment
  169. #define ZNO_FREE_PAGE_RANGE_ERROR 818   // Add fragment
  170. #define ZNOFREE_FRAGOP_ERROR 830        // Add fragment
  171. #define ZTOO_LARGE_TUPLE_ERROR 851      // Add fragment
  172. #define ZNO_FREE_TAB_ENTRY_ERROR 852    // Add fragment
  173. #define ZNO_PAGES_ALLOCATED_ERROR 881   // Add fragment
  175. #define ZGET_REALPID_ERROR 809
  176. #define ZNOT_IMPLEMENTED_ERROR 812
  177. #define ZSEIZE_ATTRINBUFREC_ERROR 805
  178. #define ZTOO_MUCH_ATTRINFO_ERROR 823
  179. #define ZMEM_NOTABDESCR_ERROR 826
  180. #define ZMEM_NOMEM_ERROR 827
  181. #define ZAI_INCONSISTENCY_ERROR 829
  182. #define ZNO_ILLEGAL_NULL_ATTR 839
  183. #define ZNOT_NULL_ATTR 840
  184. #define ZNO_INSTRUCTION_ERROR 871
  185. #define ZOUTSIDE_OF_PROGRAM_ERROR 876
  186. #define ZSTORED_PROC_ID_ERROR 877
  187. #define ZREGISTER_INIT_ERROR 878
  188. #define ZATTRIBUTE_ID_ERROR 879
  189. #define ZTRY_TO_READ_TOO_MUCH_ERROR 880
  190. #define ZTOTAL_LEN_ERROR 882
  191. #define ZATTR_INTERPRETER_ERROR 883
  192. #define ZSTACK_OVERFLOW_ERROR 884
  193. #define ZSTACK_UNDERFLOW_ERROR 885
  194. #define ZTOO_MANY_INSTRUCTIONS_ERROR 886
  195. #define ZTRY_TO_UPDATE_ERROR 888
  196. #define ZCALL_ERROR 890
  197. #define ZTEMPORARY_RESOURCE_FAILURE 891
  199. #define ZSTORED_SEIZE_ATTRINBUFREC_ERROR 873 // Part of Scan
  201. #define ZREAD_ONLY_CONSTRAINT_VIOLATION 893
  202. #define ZVAR_SIZED_NOT_SUPPORTED 894
  203. #define ZINCONSISTENT_NULL_ATTRIBUTE_COUNT 895
  204. #define ZTUPLE_CORRUPTED_ERROR 896
  205. #define ZTRY_UPDATE_PRIMARY_KEY 897
  206. #define ZMUST_BE_ABORTED_ERROR 898
  207. #define ZTUPLE_DELETED_ERROR 626
  208. #define ZINSERT_ERROR 630
  211.           /* SOME WORD POSITIONS OF FIELDS IN SOME HEADERS */
  212. #define ZPAGE_STATE_POS 0                 /* POSITION OF PAGE STATE            */
  213. #define ZPAGE_NEXT_POS 1                  /* POSITION OF THE NEXT POINTER WHEN IN FREELIST     */
  214. #define ZPAGE_PREV_POS 2                  /* POSITION OF THE PREVIOUS POINTER WHEN IN FREELIST */
  215. #define ZFREELIST_HEADER_POS 3            /* POSITION OF THE FIRST FREELIST        */
  216. #define ZPAGE_FRAG_PAGE_ID_POS 4          /* POSITION OF FRAG PAGE ID WHEN USED*/
  217. #define ZPAGE_NEXT_CLUST_POS 5            /* POSITION OF NEXT FREE SET OF PAGES    */
  218. #define ZPAGE_FIRST_CLUST_POS 2           /* POSITION OF THE POINTER TO THE FIRST PAGE IN A CLUSTER */
  219. #define ZPAGE_LAST_CLUST_POS 6            /* POSITION OF THE POINTER TO THE LAST PAGE IN A CLUSTER */
  220. #define ZPAGE_PREV_CLUST_POS 7            /* POSITION OF THE PREVIOUS POINTER  */
  221. #define ZPAGE_HEADER_SIZE 32              /* NUMBER OF WORDS IN MEM  PAGEHEADER        */
  222. #define ZDISK_PAGE_HEADER_SIZE 32         /* NUMBER OF WORDS IN DISK PAGEHEADER        */
  223. #define ZNO_OF_FREE_BLOCKS 3              /* NO OF FREE BLOCK IN THE DISK PAGE         */
  224. #define ZDISK_PAGE_ID 8                   /*  ID OF THE PAGE ON THE DISK               */
  225. #define ZBLOCK_LIST 9
  226. #define ZCOPY_OF_PAGE 10
  227. #define ZPAGE_PHYSICAL_INDEX 11
  228. #define ZNEXT_IN_PAGE_USED_LIST 12
  229. #define ZPREV_IN_PAGE_USED_LIST 13
  230. #define ZDISK_USED_TYPE 14
  231. #define ZFREE_COMMON 1                    /* PAGE STATE, PAGE IN COMMON AREA                   */
  232. #define ZEMPTY_MM 2                       /* PAGE STATE, PAGE IN EMPTY LIST                    */
  233. #define ZTH_MM_FREE 3                     /* PAGE STATE, TUPLE HEADER PAGE WITH FREE AREA      */
  234. #define ZTH_MM_FULL 4                     /* PAGE STATE, TUPLE HEADER PAGE WHICH IS FULL       */
  235. #define ZAC_MM_FREE 5                     /* PAGE STATE, ATTRIBUTE CLUSTER PAGE WITH FREE AREA */
  236. #define ZTH_MM_FREE_COPY 7                /* PAGE STATE, TH COPY PAGE WITH FREE AREA           */
  237. #define ZTH_MM_FULL_COPY 8                /* PAGE STATE, TH COPY PAGE WHICH IS FULL            */
  238. #define ZAC_MM_FREE_COPY 9                /* PAGE STATE, AC COPY PAGE WITH FREE AREA           */
  239. #define ZMAX_NO_COPY_PAGES 4              /* THE MAXIMUM NUMBER OF COPY PAGES ALLOWED PER FRAGMENT */
  241.           /* CONSTANTS USED TO HANDLE TABLE DESCRIPTOR RECORDS                   */
  242.           /* ALL POSITIONS AND SIZES IS BASED ON R-WORDS (32-BIT ON APZ 212)     */
  243. #define ZTD_HEADER 0                      /* HEADER POSITION                   */
  244. #define ZTD_DATASIZE 1                    /* SIZE OF THE DATA IN THIS CHUNK    */
  245. #define ZTD_SIZE 2                        /* TOTAL SIZE OF TABLE DESCRIPTOR    */
  247.           /* TRAILER POSITIONS FROM END OF TABLE DESCRIPTOR RECORD               */
  248. #define ZTD_TR_SIZE 1                     /* SIZE DESCRIPTOR POS FROM END+1    */
  249. #define ZTD_TR_TYPE 2
  250. #define ZTD_TRAILER_SIZE 2                /* TOTAL SIZE OF TABLE TRAILER       */
  251. #define ZAD_SIZE 2                        /* TOTAL SIZE OF ATTR DESCRIPTOR     */
  252. #define ZAD_LOG_SIZE 1                    /* TWO LOG OF TOTAL SIZE OF ATTR DESCRIPTOR     */
  254.           /* CONSTANTS USED TO HANDLE TABLE DESCRIPTOR AS A FREELIST             */
  255. #define ZTD_FL_HEADER 0                   /* HEADER POSITION                   */
  256. #define ZTD_FL_SIZE 1                     /* TOTAL SIZE OF THIS FREELIST ENTRY */
  257. #define ZTD_FL_PREV 2                     /* PREVIOUS RECORD IN FREELIST       */
  258. #define ZTD_FL_NEXT 3                     /* NEXT RECORD IN FREELIST           */
  259. #define ZTD_FREE_SIZE 16                  /* SIZE NEEDED TO HOLD ONE FL ENTRY  */
  261.           /* CONSTANTS USED IN LSB OF TABLE DESCRIPTOR HEADER DESCRIBING USAGE   */
  262. #define ZTD_TYPE_FREE 0                   /* RECORD LINKED INTO FREELIST       */
  263. #define ZTD_TYPE_NORMAL 1                 /* RECORD USED AS TABLE DESCRIPTOR   */
  264.           /* ATTRIBUTE OPERATION CONSTANTS */
  265. #define ZLEAF 1
  266. #define ZNON_LEAF 2
  268.           /* ATTRINBUFREC VARIABLE POSITIONS. */
  269. #define ZBUF_PREV 29                      /* POSITION OF 'PREV'-VARIABLE (USED BY INTERPRETED EXEC) */
  270. #define ZBUF_DATA_LEN 30                  /* POSITION OF 'DATA LENGTH'-VARIABLE. */
  271. #define ZBUF_NEXT 31                      /* POSITION OF 'NEXT'-VARIABLE.        */
  272. #define ZSAVE_BUF_NEXT 28
  273. #define ZSAVE_BUF_DATA_LEN 27
  275.           /* RETURN POINTS. */
  276.           /* RESTART PHASES */
  277. #define ZSTARTPHASE1 1
  278. #define ZSTARTPHASE2 2
  279. #define ZSTARTPHASE3 3
  280. #define ZSTARTPHASE4 4
  281. #define ZSTARTPHASE6 6
  283. #define ZADDFRAG 0
  285.           /* CHECKPOINT RECORD TYPES */
  286. #define ZLCPR_TYPE_INSERT_TH 0             /* INSERT TUPLE HEADER                             */
  287. #define ZLCPR_TYPE_DELETE_TH 1             /* DELETE TUPLE HEADER                             */
  288. #define ZLCPR_TYPE_UPDATE_TH 2             /* DON'T CREATE IT, JUST UPDETE                    */
  289. #define ZLCPR_TYPE_INSERT_TH_NO_DATA 3     /* INSERT TUPLE HEADER                             */
  290. #define ZLCPR_ABORT_UPDATE 4               /* UNDO AN UPDATE OPERATION THAT WAS ACTIVE IN LCP */
  291. #define ZLCPR_ABORT_INSERT 5               /* UNDO AN INSERT OPERATION THAT WAS ACTIVE IN LCP */
  292. #define ZTABLE_DESCRIPTOR 6                /* TABLE DESCRIPTOR                                */
  293. #define ZINDICATE_NO_OP_ACTIVE 7           /* ENSURE THAT NO OPERATION ACTIVE AFTER RESTART   */
  294. #define ZLCPR_UNDO_LOG_PAGE_HEADER 8       /* CHANGE IN PAGE HEADER IS UNDO LOGGED            */
  295. #define ZLCPR_TYPE_UPDATE_GCI 9            /* Update GCI at commit time                       */
  296. #define ZNO_CHECKPOINT_RECORDS 10          /* NUMBER OF CHECKPOINTRECORD TYPES                */
  298.           /* RESULT CODES            */
  299.           /* ELEMENT POSITIONS IN SYSTEM RESTART INFO PAGE OF THE DATA FILE */
  300. #define ZSRI_NO_OF_FRAG_PAGES_POS 10       /* NUMBER OF FRAGMENT PAGES WHEN CHECKPOINT STARTED   */
  301. #define ZSRI_TUP_RESERVED_SIZE_POS 11      /* RESERVED SIZE OF THE TUPLE WHEN CP STARTED         */
  302. #define ZSRI_TUP_FIXED_AREA_POS 12         /* SIZE OF THE TUPLE FIXED AREA WHEN CP STARTED       */
  303. #define ZSRI_TAB_DESCR_SIZE 13             /* SIZE OF THE TABLE DESCRIPTOR WHEN CP STARTED       */
  304. #define ZSRI_NO_OF_ATTRIBUTES_POS 14       /* NUMBER OF ATTRIBUTES                               */
  305. #define ZSRI_UNDO_LOG_END_REC_ID 15        /* LAST UNDO LOG RECORD ID FOR THIS CHECKPOINT        */
  306. #define ZSRI_UNDO_LOG_END_PAGE_ID 16       /* LAST USED LOG PAGE ID FOR THIS CHECKPOINT          */
  307. #define ZSRI_TH_FREE_FIRST 17              /* FIRST FREE PAGE OF TUPLE HEADERS                   */
  308. #define ZSRI_TH_FREE_COPY_FIRST 18         /* FIRST FREE PAGE OF TUPLE HEADER COPIES             */
  309. #define ZSRI_EMPTY_PRIM_PAGE 27            /* FIRST EMPTY PAGE                                   */
  310. #define ZSRI_NO_COPY_PAGES_ALLOC 28        /* NO COPY PAGES IN FRAGMENT AT LOCAL CHECKPOINT      */
  311. #define ZSRI_UNDO_FILE_VER 29              /* CHECK POINT ID OF THE UNDO FILE                    */
  312. #define ZSRI_NO_OF_INDEX_ATTR 30           /* No of index attributes                             */
  313. #define ZNO_OF_PAGES_CLUSTER_REC 0
  315. //------------------------------------------------------------
  316. // TUP_CONTINUEB codes
  317. //------------------------------------------------------------
  318. #define ZSTART_EXEC_UNDO_LOG 0
  319. #define ZCONT_START_SAVE_CL 1
  320. #define ZCONT_SAVE_DP 2
  321. #define ZCONT_EXECUTE_LC 3
  322. #define ZCONT_LOAD_DP 4
  323. #define ZLOAD_BAL_LCP_TIMER 5
  324. #define ZINITIALISE_RECORDS 6
  325. #define ZREL_FRAG 7
  326. #define ZREPORT_MEMORY_USAGE 8
  327. #define ZBUILD_INDEX 9
  329. #define ZINDEX_STORAGE 0
  330. #define ZDATA_WORD_AT_DISK_PAGE 2030
  331. #define ZALLOC_DISK_PAGE_LAST_INDEX 2047
  332. #define ZWORD_IN_BLOCK 127                 /* NO OF WORD IN A BLOCK */
  333. #define ZNO_DISK_PAGES_FILE_REC 100
  334. #define ZMASK_PAGE_INDEX 0x7ff
  335. #define ZBIT_PAGE_INDEX 11                 /* 8 KBYT PAGE = 2048 WORDS */
  336. #define ZSCAN_PROCEDURE 0
  337. #define ZCOPY_PROCEDURE 2
  338. #define ZSTORED_PROCEDURE_DELETE 3
  339. #define ZSTORED_PROCEDURE_FREE 0xffff
  340. #define ZMIN_PAGE_LIMIT_TUP_COMMITREQ 2
  341. #define ZUNDO_PAGE_HEADER_SIZE 2           /* SIZE OF UNDO PAGE HEADER     */
  342. #endif
  344. class Dbtup: public SimulatedBlock {
  345. public:
  347.   typedef bool (Dbtup::* ReadFunction)(Uint32*,
  348.                                        AttributeHeader*,
  349.                                        Uint32,
  350.                                        Uint32);
  351.   typedef bool (Dbtup::* UpdateFunction)(Uint32*,
  352.                                          Uint32,
  353.                                          Uint32);
  354. // State values
  355. enum State {
  356.   NOT_INITIALIZED = 0,
  357.   COMMON_AREA_PAGES = 1,
  358.   UNDO_RESTART_PAGES = 2,
  359.   UNDO_PAGES = 3,
  360.   READ_ONE_PAGE = 4,
  361.   CHECKPOINT_DATA_READ = 7,
  362.   CHECKPOINT_DATA_READ_PAGE_ZERO = 8,
  363.   CHECKPOINT_DATA_WRITE = 9,
  364.   CHECKPOINT_DATA_WRITE_LAST = 10,
  365.   CHECKPOINT_DATA_WRITE_FLUSH = 11,
  366.   CHECKPOINT_UNDO_READ = 12,
  367.   CHECKPOINT_UNDO_READ_FIRST = 13,
  368.   CHECKPOINT_UNDO_WRITE = 14,
  369.   CHECKPOINT_UNDO_WRITE_FLUSH = 15,
  370.   CHECKPOINT_TD_READ = 16,
  371.   IDLE = 17,
  372.   ACTIVE = 18,
  373.   SYSTEM_RESTART = 19,
  374.   NO_OTHER_OP = 20,
  375.   COMMIT_DELETE = 21,
  376.   TO_BE_COMMITTED = 22,
  377.   ABORTED = 23,
  378.   ALREADY_ABORTED_INSERT = 24,
  379.   ALREADY_ABORTED = 25,
  380.   ABORT_INSERT = 26,
  381.   ABORT_UPDATE = 27,
  382.   INIT = 28,
  383.   INITIAL_READ = 29,
  384.   INTERPRETED_EXECUTION = 30,
  385.   FINAL_READ = 31,
  386.   FINAL_UPDATE = 32,
  387.   DISCONNECTED = 33,
  388.   DEFINED = 34,
  389.   ERROR_WAIT_TUPKEYREQ = 35,
  390.   STARTED = 36,
  391.   NOT_DEFINED = 37,
  392.   COMPLETED = 38,
  393.   WAIT_ABORT = 39,
  394.   NORMAL_PAGE = 40,
  395.   COPY_PAGE = 41,
  396.   DELETE_BLOCK = 42,
  397.   WAIT_STORED_PROCEDURE_ATTR_INFO = 43,
  398.   DATA_FILE_READ = 45,
  399.   DATA_FILE_WRITE = 46,
  400.   LCP_DATA_FILE_READ = 47,
  401.   LCP_DATA_FILE_WRITE = 48,
  402.   LCP_DATA_FILE_WRITE_WITH_UNDO = 49,
  403.   LCP_DATA_FILE_CLOSE = 50,
  404.   LCP_UNDO_FILE_READ = 51,
  405.   LCP_UNDO_FILE_CLOSE = 52,
  406.   LCP_UNDO_FILE_WRITE = 53,
  407.   OPENING_DATA_FILE = 54,
  408.   INITIATING_RESTART_INFO = 55,
  409.   INITIATING_FRAGMENT = 56,
  410.   OPENING_UNDO_FILE = 57,
  411.   READING_RESTART_INFO = 58,
  412.   INIT_UNDO_SEGMENTS = 59,
  413.   READING_TAB_DESCR = 60,
  414.   READING_DATA_PAGES = 61,
  415.   WAIT_COPY_PROCEDURE = 62,
  416.   TOO_MUCH_AI = 63,
  417.   SAME_PAGE = 64,
  418.   DEFINING = 65,
  419.   TUPLE_BLOCKED = 66,
  420.   ERROR_WAIT_STORED_PROCREQ = 67
  421. };
  423. // Records
  424. /* ************** ATTRIBUTE INFO BUFFER RECORD ****************** */
  425. /* THIS RECORD IS USED AS A BUFFER FOR INCOMING AND OUTGOING DATA */
  426. /* ************************************************************** */
  427. struct Attrbufrec {
  428.   Uint32 attrbuf[ZATTRBUF_SIZE];
  429. }; /* p2c: size = 128 bytes */
  431. typedef Ptr<Attrbufrec> AttrbufrecPtr;
  433. /* ********** CHECKPOINT INFORMATION ************ */
  434. /* THIS RECORD HOLDS INFORMATION NEEDED TO        */
  435. /* PERFORM A CHECKPOINT. IT'S POSSIBLE TO RUN     */
  436. /* MULTIPLE CHECKPOINTS AT A TIME. THIS RECORD    */
  437. /* MAKES IT POSSIBLE TO DISTINGER BETWEEN THE     */
  438. /* DIFFERENT CHECKPOINTS.                         */
  439. /* ********************************************** */
  440. struct CheckpointInfo {
  441.   Uint32 lcpNextRec;                           /* NEXT RECORD IN FREELIST                          */
  442.   Uint32 lcpCheckpointVersion;                 /* VERSION OF THE CHECKPOINT                        */
  443.   Uint32 lcpLocalLogInfoP;                     /* POINTER TO A LOCAL LOG INFO RECORD               */
  444.   Uint32 lcpUserptr;                           /* USERPOINTER TO THE BLOCK REQUESTING THE CP       */
  445.   Uint32 lcpFragmentP;                         /* FRAGMENT POINTER TO WHICH THE CHECKPOINT APPLIES */
  446.   Uint32 lcpFragmentId;                        /* FRAGMENT ID                                      */
  447.   Uint32 lcpTabPtr;                            /* TABLE POINTER                                    */
  448.   Uint32 lcpDataBufferSegmentP;                /* POINTER TO A DISK BUFFER SEGMENT POINTER (DATA)  */
  449.   Uint32 lcpDataFileHandle;   /* FILE HANDLES FOR DATA FILE. LOG FILE HANDLE IN LOCAL_LOG_INFO_RECORD */
  450.                                               /* FILE HANDLE TO THE OPEN DATA FILE                */
  451.   Uint32 lcpNoOfPages;
  452.   Uint32 lcpThFreeFirst;
  453.   Uint32 lcpThFreeCopyFirst;
  454.   Uint32 lcpEmptyPrimPage;
  455.   Uint32 lcpNoCopyPagesAlloc;
  456.   Uint32 lcpTmpOperPtr;                        /* TEMPORARY STORAGE OF OPER_PTR DURING SAVE        */
  457.   BlockReference lcpBlockref;                       /* BLOCKREFERENCE TO THE BLOCK REQUESTING THE CP    */
  458. };
  459. typedef Ptr<CheckpointInfo> CheckpointInfoPtr;
  461. /* *********** DISK BUFFER SEGMENT INFO ********* */
  462. /* THIS RECORD HOLDS INFORMATION NEEDED DURING    */
  463. /* A WRITE OF THE DATA BUFFER TO DISK. WHEN THE   */
  464. /* WRITE SIGNAL IS SENT A POINTER TO THIS RECORD  */
  465. /* IS INCLUDED. WHEN THE WRITE IS COMPLETED AND   */
  466. /* CONFIRMED THE PTR TO THIS RECORD IS RETURNED   */
  467. /* AND THE BUFFER PAGES COULD EASILY BE LOCATED   */
  468. /* AND DEALLOCATED. THE CHECKPOINT_INFO_VERSION   */
  469. /* KEEPS TRACK OF THE CHECPOINT_INFO_RECORD THAT  */
  470. /* INITIATED THE WRITE AND THE CP_PAGE_TO_DISK    */
  471. /* ELEMENT COULD BE INCREASED BY THE NUMBER OF    */
  472. /* PAGES WRITTEN.                                 */
  473. /* ********************************************** */
  474. struct DiskBufferSegmentInfo {
  475.   Uint32 pdxDataPage[16];                     /* ARRAY OF DATA BUFFER PAGES */
  476.   Uint32 pdxUndoBufferSet[2];
  477.   Uint32 pdxNextRec;
  478.   State pdxBuffertype;
  479.   State pdxOperation;
  480.              /*---------------------------------------------------------------------------*/
  481.              /* PDX_FLAGS BITS AND THEIR USAGE:                                           */
  482.              /* BIT    0                    1                      COMMENT                */
  483.              /*---------------------------------------------------------------------------*/
  484.              /* 0      SEGMENT INVALID      SEGMENT VALID          USED DURING READS      */
  485.              /* 1-15                                               NOT USED               */
  486.              /*---------------------------------------------------------------------------*/
  487.   Uint32 pdxCheckpointInfoP;                  /* USED DURING LOCAL CHKP     */
  488.   Uint32 pdxRestartInfoP;                     /* USED DURING RESTART        */
  489.   Uint32 pdxLocalLogInfoP;                    /* POINTS TO A LOCAL LOG INFO */
  490.   Uint32 pdxFilePage;                         /* START PAGE IN FILE         */
  491.   Uint32 pdxNumDataPages;                     /* NUMBER OF DATA PAGES       */
  492. };
  493. typedef Ptr<DiskBufferSegmentInfo> DiskBufferSegmentInfoPtr;
  495. struct Fragoperrec {
  496.   bool   definingFragment;
  497.   Uint32 nextFragoprec;
  498.   Uint32 lqhPtrFrag;
  499.   Uint32 fragidFrag;
  500.   Uint32 tableidFrag;
  501.   Uint32 fragPointer;
  502.   Uint32 attributeCount;
  503.   Uint32 freeNullBit;
  504.   Uint32 noOfNewAttrCount;
  505.   Uint32 charsetIndex;
  506.   BlockReference lqhBlockrefFrag;
  507.   bool inUse;
  508. };
  509. typedef Ptr<Fragoperrec> FragoperrecPtr;
  511. struct Fragrecord {
  512.   Uint32 nextStartRange;
  513.   Uint32 currentPageRange;
  514.   Uint32 rootPageRange;
  515.   Uint32 noOfPages;
  516.   Uint32 emptyPrimPage;
  518.   Uint32 firstusedOprec;
  519.   Uint32 lastusedOprec;
  521.   Uint32 thFreeFirst;
  522.   Uint32 thFreeCopyFirst;
  523.   Uint32 noCopyPagesAlloc;
  525.   Uint32 checkpointVersion;
  526.   Uint32 minPageNotWrittenInCheckpoint;
  527.   Uint32 maxPageWrittenInCheckpoint;
  528.   State fragStatus;
  529.   Uint32 fragTableId;
  530.   Uint32 fragmentId;
  531.   Uint32 nextfreefrag;
  532. };
  533. typedef Ptr<Fragrecord> FragrecordPtr;
  535.           /* ************ LOCAL LOG FILE INFO ************* */
  536.           /* THIS RECORD HOLDS INFORMATION NEEDED DURING    */
  537.           /* CHECKPOINT AND RESTART. THERE ARE FOUR         */
  538.           /* PARALLELL UNDO LOG FILES, EACH ONE REPRESENTED */
  539.           /* BY AN ENTITY OF THIS RECORD.                   */
  540.           /* BECAUSE EACH FILE IS SHARED BETWEEN FOUR       */
  541.           /* TABLES AND HAS ITS OWN PAGEPOINTERS AND        */
  542.           /* WORDPOINTERS.                                  */
  543.           /* ********************************************** */
  544. struct LocalLogInfo {
  545.   Uint32 lliActiveLcp;                                   /* NUMBER OF ACTIVE LOCAL CHECKPOINTS ON THIS FILE */
  546.   Uint32 lliEndPageId;                                   /* PAGE IDENTIFIER OF LAST PAGE WITH LOG DATA      */
  547.   Uint32 lliPrevRecordId;                                /* PREVIOUS RECORD IN THIS LOGFILE                 */
  548.   Uint32 lliLogFilePage;                                 /* PAGE IN LOGFILE                                 */
  549.   Uint32 lliNumFragments;                                /* NO OF FRAGMENTS RESTARTING FROM THIS LOCAL LOG  */
  550.   Uint32 lliUndoBufferSegmentP;                          /* POINTER TO A DISK BUFFER SEGMENT POINTER (UNDO) */
  551.   Uint32 lliUndoFileHandle;                              /* FILE HANDLE OF UNDO LOG FILE                    */
  552.   Uint32 lliUndoPage;                                    /* UNDO PAGE IN BUFFER                             */
  553.   Uint32 lliUndoWord;
  554.   Uint32 lliUndoPagesToDiskWithoutSynch;
  555. };
  556. typedef Ptr<LocalLogInfo> LocalLogInfoPtr;
  558. struct Operationrec {
  559. // Easy to remove (2 words)
  560.   Uint32 attroutbufLen;
  561.   Uint32 logSize;
  563. // Needed (20 words)
  564.   State tupleState;
  565.   Uint32 prevActiveOp;
  566.   Uint32 nextActiveOp;
  567.   Uint32 nextOprecInList;
  568.   Uint32 prevOprecInList;
  569.   Uint32 tableRef;
  570.   Uint32 fragId;
  571.   Uint32 fragmentPtr;
  572.   Uint32 fragPageId;
  573.   Uint32 realPageId;
  574.   bool undoLogged;
  575.   Uint32 realPageIdC;
  576.   Uint32 fragPageIdC;
  577.   Uint32 firstAttrinbufrec;
  578.   Uint32 lastAttrinbufrec;
  579.   Uint32 attrinbufLen;
  580.   Uint32 currentAttrinbufLen;
  581.   Uint32 userpointer;
  582.   State transstate;
  583.   Uint32 savePointId;
  585. // Easy to remove (3 words)
  586.   Uint32 tcOperationPtr;
  587.   Uint32 transid1;
  588.   Uint32 transid2;
  590. // Needed (2 words)
  591.   Uint16 pageIndex;
  592.   Uint16 pageOffset;
  593.   Uint16 pageOffsetC;
  594.   Uint16 pageIndexC;
  595. // Hard to remove
  596.   Uint16 tupVersion;
  598. // Easy to remove (1.5 word)
  599.   BlockReference recBlockref;
  600.   BlockReference userblockref;
  601.   Uint16 storedProcedureId;
  603.   Uint8 inFragList;
  604.   Uint8 inActiveOpList;
  605.   Uint8 deleteInsertFlag;
  607. // Needed (1 word)
  608.   Uint8 dirtyOp;
  609.   Uint8 interpretedExec;
  610.   Uint8 optype;
  611.   Uint8 opSimple;
  613. // Used by triggers
  614.   Uint32 primaryReplica;
  615.   BlockReference coordinatorTC;
  616.   Uint32 tcOpIndex;
  617.   Uint32 gci;
  618.   Uint32 noFiredTriggers;
  619.   union {
  620.     Uint32 hashValue; // only used in TUP_COMMITREQ
  621.     Uint32 lastRow;
  622.   };
  623.   Bitmask<MAXNROFATTRIBUTESINWORDS> changeMask;
  624. };
  625. typedef Ptr<Operationrec> OperationrecPtr;
  627. struct Page {
  628.   Uint32 pageWord[ZWORDS_ON_PAGE];
  629. };
  630. typedef Ptr<Page> PagePtr;
  632.           /* ****************************** PAGE RANGE RECORD ************************** */
  633.           /* PAGE RANGES AND BASE PAGE ID. EACH RANGE HAS A  CORRESPONDING BASE PAGE ID  */
  634.           /* THAT IS USED TO  CALCULATE REAL PAGE ID FROM A FRAGMENT PAGE ID AND A TABLE */
  635.           /* REFERENCE.                                                                  */
  636.           /* THE PAGE RANGES ARE ORGANISED IN A B-TREE FASHION WHERE THE VARIABLE TYPE   */
  637.           /* SPECIFIES IF A LEAF NODE HAS BEEN REACHED. IF A LEAF NODE HAS BEEN REACHED  */
  638.           /* THEN BASE_PAGE_ID IS THE BASE_PAGE_ID OF THE SET OF PAGES THAT WAS          */
  639.           /* ALLOCATED IN THAT RANGE. OTHERWISE BASE_PAGE_ID IS THE POINTER TO THE NEXT  */
  640.           /* PAGE_RANGE RECORD.                                                          */
  641.           /* *************************************************************************** */
  642. struct PageRange {
  643.   Uint32 startRange[4];                                  /* START OF RANGE                                   */
  644.   Uint32 endRange[4];                                    /* END OF THIS RANGE                                */
  645.   Uint32 basePageId[4];                                  /* BASE PAGE ID.                                    */
  646. /*----               VARIABLE BASE_PAGE_ID2 (4) 8 DS NEEDED WHEN SUPPORTING 40 BIT PAGE ID           -------*/
  647.   Uint8 type[4];                                        /* TYPE OF BASE PAGE ID                             */
  648.   Uint32 nextFree;                                       /* NEXT FREE PAGE RANGE RECORD                      */
  649.   Uint32 parentPtr;                                      /* THE PARENT TO THE PAGE RANGE REC IN THE B-TREE   */
  650.   Uint8 currentIndexPos;
  651. };
  652. typedef Ptr<PageRange> PageRangePtr;
  654.           /* *********** PENDING UNDO WRITE INFO ********** */
  655.           /* THIS RECORD HOLDS INFORMATION NEEDED DURING    */
  656.           /* A FILE OPEN OPERATION                          */
  657.           /* IF THE FILE OPEN IS A PART OF A CHECKPOINT THE */
  658.           /* CHECKPOINT_INFO_P WILL HOLD A POINTER TO THE   */
  659.           /* CHECKPOINT_INFOR_PTR RECORD                    */
  660.           /* IF IT IS A PART OF RESTART THE PFO_RESTART_INFO*/
  661.           /* ELEMENT WILL POINT TO A RESTART INFO RECORD    */
  662.           /* ********************************************** */
  663. struct PendingFileOpenInfo {
  664.   Uint32 pfoNextRec;
  665.   State pfoOpenType;
  666.   Uint32 pfoCheckpointInfoP;
  667.   Uint32 pfoRestartInfoP;
  668. };
  669. typedef Ptr<PendingFileOpenInfo> PendingFileOpenInfoPtr;
  671. struct RestartInfoRecord {
  672.   Uint32 sriNextRec;
  673.   State sriState;                                       /* BLOCKREFERENCE TO THE REQUESTING BLOCK           */
  674.   Uint32 sriUserptr;                                     /* USERPOINTER TO THE REQUESTING BLOCK              */
  675.   Uint32 sriDataBufferSegmentP;                          /* POINTER TO A DISK BUFFER SEGMENT POINTER (DATA)  */
  676.   Uint32 sriDataFileHandle;                              /* FILE HANDLE TO THE OPEN DATA FILE                */
  677.   Uint32 sriCheckpointVersion;                           /* CHECKPOINT VERSION TO RESTART FROM               */
  678.   Uint32 sriFragid;                                      /* FRAGMENT ID                                      */
  679.   Uint32 sriFragP;                                       /* FRAGMENT POINTER                                 */
  680.   Uint32 sriTableId;                                     /* TABLE ID                                         */
  681.   Uint32 sriLocalLogInfoP;                               /* POINTER TO A LOCAL LOG INFO RECORD               */
  682.   Uint32 sriNumDataPages;                                /* NUMBER OF DATA PAGES TO READ                     */
  683.   Uint32 sriCurDataPageFromBuffer;                       /* THE CHECKPOINT IS COMPLETED                      */
  684.   BlockReference sriBlockref;
  685. };
  686. typedef Ptr<RestartInfoRecord> RestartInfoRecordPtr;
  688.   /* ************* TRIGGER DATA ************* */
  689.   /* THIS RECORD FORMS LISTS OF ACTIVE       */
  690.   /* TRIGGERS FOR EACH TABLE.                 */
  691.   /* THE RECORDS ARE MANAGED BY A TRIGGER     */
  692.   /* POOL wHERE A TRIGGER RECORD IS SEIZED    */
  693.   /* WHEN A TRIGGER IS ACTIVATED AND RELEASED */
  694.   /* WHEN THE TRIGGER IS DEACTIVATED.         */
  695.   /* **************************************** */
  696. struct TupTriggerData {
  697.   
  698.   /**
  699.    * Trigger id, used by DICT/TRIX to identify the trigger
  700.    */
  701.   Uint32 triggerId;
  703.   /**
  704.    * Index id is needed for ordered index.
  705.    */
  706.   Uint32 indexId;
  708.   /**
  709.    * Trigger type etc, defines what the trigger is used for
  710.    */
  711.   TriggerType::Value triggerType;
  712.   TriggerActionTime::Value triggerActionTime;
  713.   TriggerEvent::Value triggerEvent;
  714.   /**
  715.    * Receiver block
  716.    */
  717.   Uint32 m_receiverBlock;
  718.   
  719.   /**
  720.    * Monitor all replicas, i.e. trigger will fire on all nodes where tuples
  721.    * are stored
  722.    */
  723.   bool monitorReplicas;
  725.   /**
  726.    * Monitor all attributes, the trigger monitors all changes to attributes 
  727.    * in the table
  728.    */
  729.   bool monitorAllAttributes;
  731.   /**
  732.    * Send only changed attributes at trigger firing time.
  733.    */
  734.   bool sendOnlyChangedAttributes;
  736.   /**
  737.    * Send also before values at trigger firing time.
  738.    */
  739.   bool sendBeforeValues;
  741.   /**
  742.    * Attribute mask, defines what attributes are to be monitored
  743.    * Can be seen as a compact representation of SQL column name list
  744.    */
  745.   Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;
  746.   
  747.   /**
  748.    * Next ptr (used in pool/list)
  749.    */
  750.   union {
  751.     Uint32 nextPool;
  752.     Uint32 nextList;
  753.   };
  754.   
  755.   /**
  756.    * Prev pointer (used in list)
  757.    */
  758.   Uint32 prevList;
  760.   inline void print(NdbOut & s) const { s << "[TriggerData = " << triggerId << "]"; };
  761. };
  763. typedef Ptr<TupTriggerData> TriggerPtr;
  764.   
  765. /**
  766.  * Pool of trigger data record
  767.  */
  768. ArrayPool<TupTriggerData> c_triggerPool;
  770.           /* ************ TABLE RECORD ************ */
  771.           /* THIS RECORD FORMS A LIST OF TABLE      */
  772.           /* REFERENCE INFORMATION. ONE RECORD      */
  773.           /* PER TABLE REFERENCE.                   */
  774.           /* ************************************** */
  775. struct Tablerec {
  776.   Tablerec(ArrayPool<TupTriggerData> & triggerPool) : 
  777.     afterInsertTriggers(triggerPool),
  778.     afterDeleteTriggers(triggerPool),
  779.     afterUpdateTriggers(triggerPool),
  780.     subscriptionInsertTriggers(triggerPool),
  781.     subscriptionDeleteTriggers(triggerPool),
  782.     subscriptionUpdateTriggers(triggerPool),
  783.     constraintUpdateTriggers(triggerPool),
  784.     tuxCustomTriggers(triggerPool)
  785.   {}
  787.   Bitmask<MAXNROFATTRIBUTESINWORDS> notNullAttributeMask;
  789.   ReadFunction* readFunctionArray;
  790.   UpdateFunction* updateFunctionArray;
  791.   CHARSET_INFO** charsetArray;
  793.   Uint32 readKeyArray;
  794.   Uint32 tabDescriptor;
  795.   Uint32 attributeGroupDescriptor;
  797.   bool   GCPIndicator;
  798.   bool   checksumIndicator;
  800.   Uint16 tupheadsize;
  801.   Uint16 noOfAttr;
  802.   Uint16 noOfKeyAttr;
  803.   Uint16 noOfCharsets;
  804.   Uint16 noOfNewAttr;
  805.   Uint16 noOfNullAttr;
  806.   Uint16 noOfAttributeGroups;
  808.   Uint8  tupChecksumIndex;
  809.   Uint8  tupNullIndex;
  810.   Uint8  tupNullWords;
  811.   Uint8  tupGCPIndex;
  813.   // Lists of trigger data for active triggers
  814.   ArrayList<TupTriggerData> afterInsertTriggers;
  815.   ArrayList<TupTriggerData> afterDeleteTriggers;
  816.   ArrayList<TupTriggerData> afterUpdateTriggers;
  817.   ArrayList<TupTriggerData> subscriptionInsertTriggers;
  818.   ArrayList<TupTriggerData> subscriptionDeleteTriggers;
  819.   ArrayList<TupTriggerData> subscriptionUpdateTriggers;
  820.   ArrayList<TupTriggerData> constraintUpdateTriggers;
  822.   // List of ordered indexes
  823.   ArrayList<TupTriggerData> tuxCustomTriggers;
  825.   Uint32 fragid[2 * MAX_FRAG_PER_NODE];
  826.   Uint32 fragrec[2 * MAX_FRAG_PER_NODE];
  828.   struct {
  829.     Uint32 tabUserPtr;
  830.     Uint32 tabUserRef;
  831.   } m_dropTable;
  832.   State tableStatus;
  833. };
  835. typedef Ptr<Tablerec> TablerecPtr;
  837. struct storedProc {
  838.   Uint32 storedLinkFirst;
  839.   Uint32 storedLinkLast;
  840.   Uint32 storedCounter;
  841.   Uint32 nextPool;
  842.   Uint16 storedCode;
  843.   Uint16 storedProcLength;
  844. };
  846. typedef Ptr<storedProc> StoredProcPtr;
  848. ArrayPool<storedProc> c_storedProcPool;
  850. /* **************************** TABLE_DESCRIPTOR RECORD ******************************** */
  851. /* THIS VARIABLE IS USED TO STORE TABLE DESCRIPTIONS. A TABLE DESCRIPTION IS STORED AS A */
  852. /* CONTIGUOS ARRAY IN THIS VARIABLE. WHEN A NEW TABLE IS ADDED A CHUNK IS ALLOCATED IN   */
  853. /* THIS RECORD. WHEN ATTRIBUTES ARE ADDED TO THE TABLE, A NEW CHUNK OF PROPER SIZE IS    */
  854. /* ALLOCATED AND ALL DATA IS COPIED TO THIS NEW CHUNK AND THEN THE OLD CHUNK IS PUT IN   */
  855. /* THE FREE LIST. EACH TABLE IS DESCRIBED BY A NUMBER OF TABLE DESCRIPTIVE ATTRIBUTES    */
  856. /* AND A NUMBER OF ATTRIBUTE DESCRIPTORS AS SHOWN IN FIGURE BELOW                        */
  857. /*                                                                                       */
  858. /* WHEN ALLOCATING A TABLE DESCRIPTOR THE SIZE IS ALWAYS A MULTIPLE OF 16 WORDS.         */
  859. /*                                                                                       */
  860. /*               ----------------------------------------------                          */
  861. /*               |    TRAILER USED FOR ALLOC/DEALLOC          |                          */
  862. /*               ----------------------------------------------                          */
  863. /*               |    TABLE DESCRIPTIVE ATTRIBUTES            |                          */
  864. /*               ----------------------------------------------                          */
  865. /*               |    ATTRIBUTE DESCRIPTION 1                 |                          */
  866. /*               ----------------------------------------------                          */
  867. /*               |    ATTRIBUTE DESCRIPTION 2                 |                          */
  868. /*               ----------------------------------------------                          */
  869. /*               |                                            |                          */
  870. /*               |                                            |                          */
  871. /*               |                                            |                          */
  872. /*               ----------------------------------------------                          */
  873. /*               |    ATTRIBUTE DESCRIPTION N                 |                          */
  874. /*               ----------------------------------------------                          */
  875. /*                                                                                       */
  876. /* THE TABLE DESCRIPTIVE ATTRIBUTES CONTAINS THE FOLLOWING ATTRIBUTES:                   */
  877. /*                                                                                       */
  878. /*               ----------------------------------------------                          */
  879. /*               |    HEADER (TYPE OF INFO)                   |                          */
  880. /*               ----------------------------------------------                          */
  881. /*               |    SIZE OF WHOLE CHUNK (INCL. TRAILER)     |                          */
  882. /*               ----------------------------------------------                          */
  883. /*               |    TABLE IDENTITY                          |                          */
  884. /*               ----------------------------------------------                          */
  885. /*               |    FRAGMENT IDENTITY                       |                          */
  886. /*               ----------------------------------------------                          */
  887. /*               |    NUMBER OF ATTRIBUTES                    |                          */
  888. /*               ----------------------------------------------                          */
  889. /*               |    SIZE OF FIXED ATTRIBUTES                |                          */
  890. /*               ----------------------------------------------                          */
  891. /*               |    NUMBER OF NULL FIELDS                   |                          */
  892. /*               ----------------------------------------------                          */
  893. /*               |    NOT USED                                |                          */
  894. /*               ----------------------------------------------                          */
  895. /*                                                                                       */
  896. /* THESE ATTRIBUTES ARE ALL ONE R-VARIABLE IN THE RECORD.                                */
  897. /* NORMALLY ONLY ONE TABLE DESCRIPTOR IS USED. DURING SCHEMA CHANGES THERE COULD         */
  898. /* HOWEVER EXIST MORE THAN ONE TABLE DESCRIPTION SINCE THE SCHEMA CHANGE OF VARIOUS      */
  899. /* FRAGMENTS ARE NOT SYNCHRONISED. THIS MEANS THAT ALTHOUGH THE SCHEMA HAS CHANGED       */
  900. /* IN ALL FRAGMENTS, BUT THE FRAGMENTS HAVE NOT REMOVED THE ATTRIBUTES IN THE SAME       */
  901. /* TIME-FRAME. THEREBY SOME ATTRIBUTE INFORMATION MIGHT DIFFER BETWEEN FRAGMENTS.        */
  902. /* EXAMPLES OF ATTRIBUTES THAT MIGHT DIFFER ARE SIZE OF FIXED ATTRIBUTES, NUMBER OF      */
  903. /* ATTRIBUTES, FIELD START WORD, START BIT.                                              */
  904. /*                                                                                       */
  905. /* AN ATTRIBUTE DESCRIPTION CONTAINS THE FOLLOWING ATTRIBUTES:                           */
  906. /*                                                                                       */
  907. /*               ----------------------------------------------                          */
  908. /*               |    Field Type, 4 bits (LSB Bits)           |                          */
  909. /*               ----------------------------------------------                          */
  910. /*               |    Attribute Size, 4 bits                  |                          */
  911. /*               ----------------------------------------------                          */
  912. /*               |    NULL indicator 1 bit                    |                          */
  913. /*               ----------------------------------------------                          */
  914. /*               |    Indicator if TUP stores attr. 1 bit     |                          */
  915. /*               ----------------------------------------------                          */
  916. /*               |    Not used 6 bits                         |                          */
  917. /*               ----------------------------------------------                          */
  918. /*               |    No. of elements in fixed array 16 bits  |                          */
  919. /*               ----------------------------------------------                          */
  920. /*               ----------------------------------------------                          */
  921. /*               |    Field Start Word, 21 bits (LSB Bits)    |                          */
  922. /*               ----------------------------------------------                          */
  923. /*               |    NULL Bit, 11 bits                       |                          */
  924. /*               ----------------------------------------------                          */
  925. /*                                                                                       */
  926. /* THE ATTRIBUTE SIZE CAN BE 1,2,4,8,16,32,64 AND 128 BITS.                              */
  927. /*                                                                                       */
  928. /* THE UNUSED PARTS OF THE RECORDS ARE PUT IN A LINKED LIST OF FREE PARTS. EACH OF       */
  929. /* THOSE FREE PARTS HAVE THREE RECORDS ASSIGNED AS SHOWN IN THIS STRUCTURE               */
  930. /* ALL FREE PARTS ARE SET INTO A CHUNK LIST WHERE EACH CHUNK IS AT LEAST 16 WORDS        */
  931. /*                                                                                       */
  932. /*               ----------------------------------------------                          */
  933. /*               |    HEADER = RNIL                           |                          */
  934. /*               ----------------------------------------------                          */
  935. /*               |    SIZE OF FREE AREA                       |                          */
  936. /*               ----------------------------------------------                          */
  937. /*               |    POINTER TO PREVIOUS FREE AREA           |                          */
  938. /*               ----------------------------------------------                          */
  939. /*               |    POINTER TO NEXT FREE AREA               |                          */
  940. /*               ----------------------------------------------                          */
  941. /*                                                                                       */
  942. /* IF THE POINTER TO THE NEXT AREA IS RNIL THEN THIS IS THE LAST FREE AREA.              */
  943. /*                                                                                       */
  944. /*****************************************************************************************/
  945. struct TableDescriptor {
  946.   Uint32 tabDescr;
  947. };
  948. typedef Ptr<TableDescriptor> TableDescriptorPtr;
  950. struct HostBuffer {
  951.   bool  inPackedList;
  952.   Uint32 packetLenTA;
  953.   Uint32 noOfPacketsTA;
  954.   Uint32 packetBufferTA[30];
  955. };
  956. typedef Ptr<HostBuffer> HostBufferPtr;
  958.           /* **************** UNDO PAGE RECORD ******************* */
  959.           /* THIS RECORD FORMS AN UNDO PAGE CONTAINING A NUMBER OF */
  960.           /* DATA WORDS. CURRENTLY THERE ARE 2048 WORDS ON A PAGE  */
  961.           /* EACH OF 32 BITS (4 BYTES) WHICH FORMS AN UNDO PAGE    */
  962.           /* WITH A TOTAL OF 8192 BYTES                            */
  963.           /* ***************************************************** */
  964. struct UndoPage {
  965.   Uint32 undoPageWord[ZWORDS_ON_PAGE]; /* 32 KB */
  966. };
  967. typedef Ptr<UndoPage> UndoPagePtr;
  969.   /*
  970.    * Build index operation record.
  971.    */
  972.   struct BuildIndexRec {
  973.     // request cannot use signal class due to extra members
  974.     Uint32 m_request[BuildIndxReq::SignalLength];
  975.     Uint32 m_triggerPtrI;       // the index trigger
  976.     Uint32 m_fragNo;            // fragment number under Tablerec
  977.     Uint32 m_pageId;            // logical fragment page id
  978.     Uint32 m_tupleNo;           // tuple number on page (pageIndex >> 1)
  979.     BuildIndxRef::ErrorCode m_errorCode;
  980.     union {
  981.       Uint32 nextPool;
  982.       Uint32 nextList;
  983.     };
  984.     Uint32 prevList;
  985.   };
  986.   typedef Ptr<BuildIndexRec> BuildIndexPtr;
  987.   ArrayPool<BuildIndexRec> c_buildIndexPool;
  988.   ArrayList<BuildIndexRec> c_buildIndexList;
  989.   Uint32 c_noOfBuildIndexRec;
  991. public:
  992.   Dbtup(const class Configuration &);
  993.   virtual ~Dbtup();
  995.   /*
  996.    * TUX uses logical tuple address when talking to ACC and LQH.
  997.    */
  998.   void tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32& tupAddr);
  1000.   /*
  1001.    * TUX index in TUP has single Uint32 array attribute which stores an
  1002.    * index node.  TUX reads and writes the node directly via pointer.
  1003.    */
  1004.   int tuxAllocNode(Signal* signal, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node);
  1005.   void tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node);
  1006.   void tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node);
  1008.   /*
  1009.    * TUX reads primary table attributes for index keys.  Tuple is
  1010.    * specified by location of original tuple and version number.  Input
  1011.    * is attribute ids in AttributeHeader format.  Output is attribute
  1012.    * data with headers.  Uses readAttributes with xfrm option set.
  1013.    * Returns number of words or negative (-terrorCode) on error.
  1014.    */
  1015.   int tuxReadAttrs(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32 tupVersion, const Uint32* attrIds, Uint32 numAttrs, Uint32* dataOut);
  1017.   /*
  1018.    * TUX reads primary key without headers into an array of words.  Used
  1019.    * for md5 summing and when returning keyinfo.  Returns number of
  1020.    * words or negative (-terrorCode) on error.
  1021.    */
  1022.   int tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* dataOut);
  1024.   /*
  1025.    * TUX checks if tuple is visible to scan.
  1026.    */
  1027.   bool tuxQueryTh(Uint32 fragPtrI, Uint32 tupAddr, Uint32 tupVersion, Uint32 transId1, Uint32 transId2, Uint32 savePointId);
  1029. private:
  1030.   BLOCK_DEFINES(Dbtup);
  1032.   // Transit signals
  1033.   void execDEBUG_SIG(Signal* signal);
  1034.   void execCONTINUEB(Signal* signal);
  1036.   // Received signals
  1037.   void execDUMP_STATE_ORD(Signal* signal);
  1038.   void execSEND_PACKED(Signal* signal);
  1039.   void execSTTOR(Signal* signal);
  1040.   void execTUP_LCPREQ(Signal* signal);
  1041.   void execEND_LCPREQ(Signal* signal);
  1042.   void execSTART_RECREQ(Signal* signal);
  1043.   void execMEMCHECKREQ(Signal* signal);
  1044.   void execTUPSEIZEREQ(Signal* signal);
  1045.   void execTUPRELEASEREQ(Signal* signal);
  1046.   void execSTORED_PROCREQ(Signal* signal);
  1047.   void execTUPFRAGREQ(Signal* signal);
  1048.   void execTUP_ADD_ATTRREQ(Signal* signal);
  1049.   void execTUP_COMMITREQ(Signal* signal);
  1050.   void execTUP_ABORTREQ(Signal* signal);
  1051.   void execTUP_SRREQ(Signal* signal);
  1052.   void execTUP_PREPLCPREQ(Signal* signal);
  1053.   void execFSOPENCONF(Signal* signal);
  1054.   void execFSCLOSECONF(Signal* signal);
  1055.   void execFSWRITECONF(Signal* signal);
  1056.   void execFSREADCONF(Signal* signal);
  1057.   void execNDB_STTOR(Signal* signal);
  1058.   void execREAD_CONFIG_REQ(Signal* signal);
  1059.   void execSET_VAR_REQ(Signal* signal);
  1060.   void execDROP_TAB_REQ(Signal* signal);
  1061.   void execALTER_TAB_REQ(Signal* signal);
  1062.   void execFSREMOVECONF(Signal* signal);
  1063.   void execTUP_ALLOCREQ(Signal* signal);
  1064.   void execTUP_DEALLOCREQ(Signal* signal);
  1065.   void execTUP_WRITELOG_REQ(Signal* signal);
  1067.   // Ordered index related
  1068.   void execBUILDINDXREQ(Signal* signal);
  1069.   void buildIndex(Signal* signal, Uint32 buildPtrI);
  1070.   void buildIndexReply(Signal* signal, const BuildIndexRec* buildRec);
  1072. //------------------------------------------------------------------
  1073. //------------------------------------------------------------------
  1074. // Methods to handle execution of TUPKEYREQ + ATTRINFO.
  1075. //
  1076. // Module Execution Manager
  1077. //
  1078. // The TUPKEYREQ signal is central to this block. This signal is used
  1079. // by everybody that needs to read data residing in DBTUP. The data is
  1080. // read using an interpreter approach.
  1081. //
  1082. // Operations only needing to read execute a simplified version of the
  1083. // interpreter where the only instruction is read Attribute to send.
  1084. // Operations only needing to update the record (insert or update)
  1085. // execute a simplified version of the interpreter where the only
  1086. // instruction is write Attribute.
  1087. //
  1088. // Currently TUPKEYREQ is used in the following situations.
  1089. // 1) Normal transaction execution. Can be any of the types described
  1090. //    below.
  1091. // 2) Execution of fragment redo log during system restart.
  1092. //    In this situation there will only be normal updates, inserts
  1093. //    and deletes performed.
  1094. // 3) A special type of normal transaction execution is to write the
  1095. //    records arriving from the primary replica in the node restart
  1096. //    processing. This will always be normal write operations which
  1097. //    are translated to inserts or updates before arriving to TUP.
  1098. // 4) Scan processing. The scan processing will use normal reads or
  1099. //    interpreted reads in their execution. There will be one TUPKEYREQ
  1100. //    signal for each record processed.
  1101. // 5) Copy fragment processing. This is a special type of scan used in the
  1102. //    primary replica at system restart. It reads the entire reads and
  1103. //    converts those to writes to the starting node. In this special case
  1104. //    LQH acts as an API node and receives also the ATTRINFO sent in the
  1105. //    TRANSID_AI signals.
  1106. //
  1107. // Signal Diagram:
  1108. //
  1109. // In Signals:
  1110. // -----------
  1111. //
  1112. // Logically there is one request TUPKEYREQ which requests to read/write data
  1113. // of one tuple in the database. Since the definition of what to read and write
  1114. // can be bigger than the maximum signal size we segment the signal. The definition
  1115. // of what to read/write/interpreted program is sent before the TUPKEYREQ signal.
  1116. //
  1117. // ---> ATTRINFO
  1118. // ...
  1119. // ---> ATTRINFO
  1120. // ---> TUPKEYREQ
  1121. // The number of ATTRINFO signals can be anything between 0 and upwards.
  1122. // The total size of the ATTRINFO is not allowed to be more than 16384 words.
  1123. // There is always one and only one TUPKEYREQ.
  1124. //
  1125. // Response Signals (successful case):
  1126. //
  1127. // Simple/Dirty Read Operation
  1128. // ---------------------------
  1129. //
  1130. // <---- TRANSID_AI (to API)
  1131. // ...
  1132. // <---- TRANSID_AI (to API)
  1133. // <---- READCONF   (to API)
  1134. // <---- TUPKEYCONF (to LQH)
  1135. // There is always exactly one READCONF25 sent last. The number of
  1136. // TRANSID_AI is dependent on how much that was read. The maximum size
  1137. // of the ATTRINFO sent back is 16384 words. The signals are sent
  1138. // directly to the application with an address provided by the
  1139. // TUPKEYREQ signal.
  1140. // A positive response signal is also sent to LQH.
  1141. //
  1142. // Normal Read Operation
  1143. // ---------------------
  1144. //
  1145. // <---- TRANSID_AI (to API)
  1146. // ...
  1147. // <---- TRANSID_AI (to API)
  1148. // <---- TUPKEYCONF (to LQH)
  1149. // The number of TRANSID_AI is dependent on how much that was read.
  1150. // The maximum size of the ATTRINFO sent back is 16384 words. The
  1151. // signals are sent directly to the application with an address
  1152. // provided by the TUPKEYREQ signal.
  1153. // A positive response signal is also sent to LQH.
  1154. //
  1155. // Normal update/insert/delete operation
  1156. // -------------------------------------
  1157. //
  1158. // <---- TUPKEYCONF
  1159. // After successful updating of the tuple LQH is informed of this.
  1160. //
  1161. // Delete with read
  1162. // ----------------
  1163. //
  1164. // Will behave as a normal read although it also prepares the
  1165. // deletion of the tuple.
  1166. //
  1167. // Interpreted Update
  1168. // ------------------
  1169. //
  1170. // <---- TRANSID_AI (to API)
  1171. // ...
  1172. // <---- TRANSID_AI (to API)
  1173. // <---- TUP_ATTRINFO (to LQH)
  1174. // ...
  1175. // <---- TUP_ATTRINFO (to LQH)
  1176. // <---- TUPKEYCONF (to LQH)
  1177. //
  1178. // The interpreted Update contains five sections:
  1179. // The first section performs read Attribute operations
  1180. // that send results back to the API.
  1181. //
  1182. // The second section executes the interpreted program
  1183. // where data from attributes can be updated and it
  1184. // can also read attribute values into the registers.
  1185. //
  1186. // The third section performs unconditional updates of
  1187. // attributes.
  1188. //
  1189. // The fourth section can read the attributes to be sent to the
  1190. // API after updating the record.
  1191. //
  1192. // The fifth section contains subroutines used by the interpreter
  1193. // in the second section.
  1194. //
  1195. // All types of interpreted programs contains the same five sections.
  1196. // The only difference is that only interpreted updates can update
  1197. // attributes. Interpreted inserts are not allowed.
  1198. //
  1199. // Interpreted Updates have to send back the information about the
  1200. // attributes they have updated. This information will be shipped to
  1201. // the log and also to any other replicas. Thus interpreted updates
  1202. // are only performed in the primary replica. The fragment redo log
  1203. // in LQH will contain information so that normal update/inserts/deletes
  1204. // can be performed using TUPKEYREQ.
  1205. //
  1206. // Interpreted Read
  1207. // ----------------
  1208. //
  1209. // From a signalling point of view the Interpreted Read behaves as
  1210. // as a Normal Read. The interpreted Read is often used by Scan's.
  1211. //
  1212. // Interpreted Delete
  1213. // ------------------
  1214. //
  1215. // <---- TUPKEYCONF
  1216. // After successful prepartion to delete the tuple LQH is informed
  1217. // of this.
  1218. //
  1219. // Interpreted Delete with Read
  1220. // ----------------------------
  1221. //
  1222. // From a signalling point of view an interpreted delete with read
  1223. // behaves as a normal read.
  1224. //
  1225. // Continuation after successful case:
  1226. //
  1227. // After a read of any kind the operation record is ready to be used
  1228. // again by a new operation.
  1229. //
  1230. // Any updates, inserts or deletes waits for either of two messages.
  1231. // A commit specifying that the operation is to be performed for real
  1232. // or an abort specifying that the operation is to be rolled back and
  1233. // the record to be restored in its original format.
  1234. // 
  1235. // This is handled by the module Transaction Manager.
  1236. //
  1237. // Response Signals (unsuccessful case):
  1238. //
  1239. // <---- TUPKEYREF (to LQH)
  1240. // A signal is sent back to LQH informing about the unsuccessful
  1241. // operation. In this case TUP waits for an abort signal to arrive
  1242. // before the operation record is ready for the next operation.
  1243. // This is handled by the Transaction Manager.
  1244. //------------------------------------------------------------------
  1245. //------------------------------------------------------------------
  1247. // *****************************************************************
  1248. // Signal Reception methods.
  1249. // *****************************************************************
  1250. //------------------------------------------------------------------
  1251. //------------------------------------------------------------------
  1252.   void execTUPKEYREQ(Signal* signal);
  1254. //------------------------------------------------------------------
  1255. //------------------------------------------------------------------
  1256.   void execATTRINFO(Signal* signal);
  1258. // Trigger signals
  1259. //------------------------------------------------------------------
  1260. //------------------------------------------------------------------
  1261.   void execCREATE_TRIG_REQ(Signal* signal);
  1263. //------------------------------------------------------------------
  1264. //------------------------------------------------------------------
  1265.   void execDROP_TRIG_REQ(Signal* signal);
  1267. // *****************************************************************
  1268. // Support methods for ATTRINFO.
  1269. // *****************************************************************
  1270. //------------------------------------------------------------------
  1271. //------------------------------------------------------------------
  1272.   void handleATTRINFOforTUPKEYREQ(Signal* signal,
  1273.                                   Uint32 length,
  1274.                                   Operationrec * const regOperPtr);
  1276. // *****************************************************************
  1277. // Setting up the environment for reads, inserts, updates and deletes.
  1278. // *****************************************************************
  1279. //------------------------------------------------------------------
  1280. //------------------------------------------------------------------
  1281.   int handleReadReq(Signal* signal,
  1282.                     Operationrec* const regOperPtr,
  1283.                     Tablerec* const regTabPtr,
  1284.                     Page* pagePtr);
  1286. //------------------------------------------------------------------
  1287. //------------------------------------------------------------------
  1288.   int handleUpdateReq(Signal* signal,
  1289.                       Operationrec* const regOperPtr,
  1290.                       Fragrecord* const regFragPtr,
  1291.                       Tablerec* const regTabPtr,
  1292.                       Page* const pagePtr);
  1294. //------------------------------------------------------------------
  1295. //------------------------------------------------------------------
  1296.   int handleInsertReq(Signal* signal,
  1297.                       Operationrec* const regOperPtr,
  1298.                       Fragrecord* const regFragPtr,
  1299.                       Tablerec* const regTabPtr,
  1300.                       Page* const pagePtr);
  1302. //------------------------------------------------------------------
  1303. //------------------------------------------------------------------
  1304.   int handleDeleteReq(Signal* signal,
  1305.                       Operationrec* const regOperPtr,
  1306.                       Fragrecord* const regFragPtr,
  1307.                       Tablerec* const regTabPtr,
  1308.                       Page* const pagePtr);
  1310. //------------------------------------------------------------------
  1311. //------------------------------------------------------------------
  1312.   int  updateStartLab(Signal* signal,
  1313.                       Operationrec* const regOperPtr,
  1314.                       Tablerec* const regTabPtr,
  1315.                       Page* const pagePtr);
  1317. // *****************************************************************
  1318. // Interpreter Handling methods.
  1319. // *****************************************************************
  1321. //------------------------------------------------------------------
  1322. //------------------------------------------------------------------
  1323.   int interpreterStartLab(Signal* signal,
  1324.                           Page* const pagePtr,
  1325.                           Uint32 TupHeadOffset);
  1327. //------------------------------------------------------------------
  1328. //------------------------------------------------------------------
  1329.   int interpreterNextLab(Signal* signal,
  1330.                          Page* const pagePtr,
  1331.                          Uint32 TupHeadOffset,
  1332.                          Uint32* logMemory,
  1333.                          Uint32* mainProgram,
  1334.                          Uint32 TmainProgLen,
  1335.                          Uint32* subroutineProg,
  1336.                          Uint32 TsubroutineLen,
  1337.  Uint32 * tmpArea,
  1338.  Uint32 tmpAreaSz);
  1340. // *****************************************************************
  1341. // Signal Sending methods.
  1342. // *****************************************************************
  1343. //------------------------------------------------------------------
  1344. //------------------------------------------------------------------
  1345.   void sendReadAttrinfo(Signal* signal,
  1346.                         Uint32 TnoOfData,
  1347.                         const Operationrec * const regOperPtr);
  1349. //------------------------------------------------------------------
  1350. //------------------------------------------------------------------
  1351.   void sendLogAttrinfo(Signal* signal,
  1352.                        Uint32 TlogSize,
  1353.                        Operationrec * const regOperPtr);
  1355. //------------------------------------------------------------------
  1356. //------------------------------------------------------------------
  1357.   void sendTUPKEYCONF(Signal* signal, Operationrec * 
  1358.                       const regOperPtr, 
  1359.                       Uint32 TlogSize);
  1361. //------------------------------------------------------------------
  1362. //------------------------------------------------------------------
  1363. // *****************************************************************
  1364. // The methods that perform the actual read and update of attributes
  1365. // in the tuple.
  1366. // *****************************************************************
  1367. //------------------------------------------------------------------
  1368. //------------------------------------------------------------------
  1369.   int readAttributes(Page* const pagePtr,
  1370.                      Uint32   TupHeadOffset,
  1371.                      const Uint32*  inBuffer,
  1372.                      Uint32   inBufLen,
  1373.                      Uint32*  outBuffer,
  1374.                      Uint32   TmaxRead,
  1375.                      bool     xfrmFlag);
  1377. //------------------------------------------------------------------
  1378. //------------------------------------------------------------------
  1379.   int readAttributesWithoutHeader(Page* const pagePtr,
  1380.                                   Uint32   TupHeadOffset,
  1381.                                   Uint32*  inBuffer,
  1382.                                   Uint32   inBufLen,
  1383.                                   Uint32*  outBuffer,
  1384.                                   Uint32*  attrBuffer,
  1385.                                   Uint32   TmaxRead);
  1387. //------------------------------------------------------------------
  1388. //------------------------------------------------------------------
  1389.   int updateAttributes(Page* const pagePtr,
  1390.                        Uint32      TupHeadOffset,
  1391.                        Uint32*     inBuffer,
  1392.                        Uint32      inBufLen);
  1394. //------------------------------------------------------------------
  1395. //------------------------------------------------------------------
  1396.   bool readFixedSizeTHOneWordNotNULL(Uint32* outBuffer,
  1397.                                      AttributeHeader* ahOut,
  1398.                                      Uint32  attrDescriptor,
  1399.                                      Uint32  attrDes2);
  1401. //------------------------------------------------------------------
  1402. //------------------------------------------------------------------
  1403.   bool updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer,
  1404.                                        Uint32  attrDescriptor,
  1405.                                        Uint32  attrDes2);
  1407. //------------------------------------------------------------------
  1408. //------------------------------------------------------------------
  1409.   bool readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer,
  1410.                                      AttributeHeader* ahOut,
  1411.                                      Uint32  attrDescriptor,
  1412.                                      Uint32  attrDes2);
  1414. //------------------------------------------------------------------
  1415. //------------------------------------------------------------------
  1416.   bool updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer,
  1417.                                        Uint32  attrDescriptor,
  1418.                                        Uint32  attrDes2);
  1420. //------------------------------------------------------------------
  1421. //------------------------------------------------------------------
  1422.   bool readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
  1423.                                       AttributeHeader* ahOut,
  1424.                                       Uint32  attrDescriptor,
  1425.                                       Uint32  attrDes2);
  1427. //------------------------------------------------------------------
  1428. //------------------------------------------------------------------
  1429.   bool updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
  1430.                                         Uint32  attrDescriptor,
  1431.                                         Uint32  attrDes2);
  1433. //------------------------------------------------------------------
  1434. //------------------------------------------------------------------
  1435.   bool readFixedSizeTHOneWordNULLable(Uint32* outBuffer,
  1436.                                       AttributeHeader* ahOut,
  1437.                                       Uint32  attrDescriptor,
  1438.                                       Uint32  attrDes2);
  1440. //------------------------------------------------------------------
  1441. //------------------------------------------------------------------
  1442.   bool updateFixedSizeTHOneWordNULLable(Uint32* inBuffer,
  1443.                                         Uint32  attrDescriptor,
  1444.                                         Uint32  attrDes2);
  1446. //------------------------------------------------------------------
  1447. //------------------------------------------------------------------
  1448.   bool readFixedSizeTHTwoWordNULLable(Uint32* outBuffer,
  1449.                                       AttributeHeader* ahOut,
  1450.                                       Uint32  attrDescriptor,
  1451.                                       Uint32  attrDes2);
  1453. //------------------------------------------------------------------
  1454. //------------------------------------------------------------------
  1455.   bool updateFixedSizeTHTwoWordNULLable(Uint32* inBuffer,
  1456.                                         Uint32  attrDescriptor,
  1457.                                         Uint32  attrDes2);
  1459. //------------------------------------------------------------------
  1460. //------------------------------------------------------------------
  1461.   bool readFixedSizeTHManyWordNULLable(Uint32* outBuffer,
  1462.                                        AttributeHeader* ahOut,
  1463.                                        Uint32  attrDescriptor,
  1464.                                        Uint32  attrDes2);
  1466. //------------------------------------------------------------------
  1467. //------------------------------------------------------------------
  1468.   bool readFixedSizeTHZeroWordNULLable(Uint32* outBuffer,
  1469.                                        AttributeHeader* ahOut,
  1470.                                        Uint32  attrDescriptor,
  1471.                                        Uint32  attrDes2);
  1472. //------------------------------------------------------------------
  1473. //------------------------------------------------------------------
  1474.   bool updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
  1475.                                          Uint32  attrDescriptor,
  1476.                                          Uint32  attrDes2);
  1478. //------------------------------------------------------------------
  1479. //------------------------------------------------------------------
  1480.   bool readVariableSizedAttr(Uint32* outBuffer,
  1481.                              AttributeHeader* ahOut,
  1482.                              Uint32  attrDescriptor,
  1483.                              Uint32  attrDes2);
  1485. //------------------------------------------------------------------
  1486. //------------------------------------------------------------------
  1487.   bool updateVariableSizedAttr(Uint32* inBuffer,
  1488.                                Uint32  attrDescriptor,
  1489.                                Uint32  attrDes2);
  1491. //------------------------------------------------------------------
  1492. //------------------------------------------------------------------
  1493.   bool readVarSizeUnlimitedNotNULL(Uint32* outBuffer,
  1494.                                    AttributeHeader* ahOut,
  1495.                                    Uint32  attrDescriptor,
  1496.                                    Uint32  attrDes2);
  1498. //------------------------------------------------------------------
  1499. //------------------------------------------------------------------
  1500.   bool updateVarSizeUnlimitedNotNULL(Uint32* inBuffer,
  1501.                                      Uint32  attrDescriptor,
  1502.                                      Uint32  attrDes2);
  1504. //------------------------------------------------------------------
  1505. //------------------------------------------------------------------
  1506.   bool readVarSizeUnlimitedNULLable(Uint32* outBuffer,
  1507.                                     AttributeHeader* ahOut,
  1508.                                     Uint32  attrDescriptor,
  1509.                                     Uint32  attrDes2);
  1511. //------------------------------------------------------------------
  1512. //------------------------------------------------------------------
  1513.   bool updateVarSizeUnlimitedNULLable(Uint32* inBuffer,
  1514.                                       Uint32  attrDescriptor,
  1515.                                       Uint32  attrDes2);
  1517. //------------------------------------------------------------------
  1518. //------------------------------------------------------------------
  1519.   bool readBigVarSizeNotNULL(Uint32* outBuffer,
  1520.                              AttributeHeader* ahOut,
  1521.                              Uint32  attrDescriptor,
  1522.                              Uint32  attrDes2);
  1524. //------------------------------------------------------------------
  1525. //------------------------------------------------------------------
  1526.   bool updateBigVarSizeNotNULL(Uint32* inBuffer,
  1527.                                Uint32  attrDescriptor,
  1528.                                Uint32  attrDes2);
  1530. //------------------------------------------------------------------
  1531. //------------------------------------------------------------------
  1532.   bool readBigVarSizeNULLable(Uint32* outBuffer,
  1533.                               AttributeHeader* ahOut,
  1534.                               Uint32  attrDescriptor,
  1535.                               Uint32  attrDes2);
  1537. //------------------------------------------------------------------
  1538. //------------------------------------------------------------------
  1539.   bool updateBigVarSizeNULLable(Uint32* inBuffer,
  1540.                                 Uint32  attrDescriptor,
  1541.                                 Uint32  attrDes2);
  1543. //------------------------------------------------------------------
  1544. //------------------------------------------------------------------
  1545.   bool readSmallVarSizeNotNULL(Uint32* outBuffer,
  1546.                                AttributeHeader* ahOut,
  1547.                                Uint32  attrDescriptor,
  1548.                                Uint32  attrDes2);
  1550. //------------------------------------------------------------------
  1551. //------------------------------------------------------------------
  1552.   bool updateSmallVarSizeNotNULL(Uint32* inBuffer,
  1553.                                  Uint32  attrDescriptor,
  1554.                                  Uint32  attrDes2);
  1556. //------------------------------------------------------------------
  1557. //------------------------------------------------------------------
  1558.   bool readSmallVarSizeNULLable(Uint32* outBuffer,
  1559.                                 AttributeHeader* ahOut,
  1560.                                 Uint32  attrDescriptor,
  1561.                                 Uint32  attrDes2);
  1563. //------------------------------------------------------------------
  1564. //------------------------------------------------------------------
  1565.   bool updateSmallVarSizeNULLable(Uint32* inBuffer,
  1566.                                   Uint32  attrDescriptor,
  1567.                                   Uint32  attrDes2);
  1569. //------------------------------------------------------------------
  1570. //------------------------------------------------------------------
  1571.   bool readDynFixedSize(Uint32* outBuffer,
  1572.                         AttributeHeader* ahOut,
  1573.                         Uint32  attrDescriptor,
  1574.                         Uint32  attrDes2);
  1576. //------------------------------------------------------------------
  1577. //------------------------------------------------------------------
  1578.   bool updateDynFixedSize(Uint32* inBuffer,
  1579.                           Uint32  attrDescriptor,
  1580.                           Uint32  attrDes2);
  1582. //------------------------------------------------------------------
  1583. //------------------------------------------------------------------
  1584.   bool readDynVarSizeUnlimited(Uint32* outBuffer,
  1585.                                AttributeHeader* ahOut,
  1586.                                Uint32  attrDescriptor,
  1587.                                Uint32  attrDes2);
  1589. //------------------------------------------------------------------
  1590. //------------------------------------------------------------------
  1591.   bool updateDynVarSizeUnlimited(Uint32* inBuffer,
  1592.                                  Uint32  attrDescriptor,
  1593.                                  Uint32  attrDes2);
  1595. //------------------------------------------------------------------
  1596. //------------------------------------------------------------------
  1597.   bool readDynBigVarSize(Uint32* outBuffer,
  1598.                          AttributeHeader* ahOut,
  1599.                          Uint32  attrDescriptor,
  1600.                          Uint32  attrDes2);
  1602. //------------------------------------------------------------------
  1603. //------------------------------------------------------------------
  1604.   bool updateDynBigVarSize(Uint32* inBuffer,
  1605.                            Uint32  attrDescriptor,
  1606.                            Uint32  attrDes2);
  1608. //------------------------------------------------------------------
  1609. //------------------------------------------------------------------
  1610.   bool readDynSmallVarSize(Uint32* outBuffer,
  1611.                            AttributeHeader* ahOut,
  1612.                            Uint32  attrDescriptor,
  1613.                            Uint32  attrDes2);
  1615. //------------------------------------------------------------------
  1616. //------------------------------------------------------------------
  1617.   bool updateDynSmallVarSize(Uint32* inBuffer,
  1618.                              Uint32  attrDescriptor,
  1619.                              Uint32  attrDes2);
  1621. // *****************************************************************
  1622. // Read char routines optionally (tXfrmFlag) apply strxfrm
  1623. // *****************************************************************
  1625.   bool readCharNotNULL(Uint32* outBuffer,
  1626.                        AttributeHeader* ahOut,
  1627.                        Uint32  attrDescriptor,
  1628.                        Uint32  attrDes2);
  1630.   bool readCharNULLable(Uint32* outBuffer,
  1631.                         AttributeHeader* ahOut,
  1632.                         Uint32  attrDescriptor,
  1633.                         Uint32  attrDes2);
  1635. //------------------------------------------------------------------
  1636. //------------------------------------------------------------------
  1637.   bool nullFlagCheck(Uint32  attrDes2);
  1638.   Uint32 read_psuedo(Uint32 attrId, Uint32* outBuffer);
  1640. //------------------------------------------------------------------
  1641. //------------------------------------------------------------------
  1642.   void setUpQueryRoutines(Tablerec* const regTabPtr);
  1644. // *****************************************************************
  1645. // Service methods.
  1646. // *****************************************************************
  1647. //------------------------------------------------------------------
  1648. //------------------------------------------------------------------
  1649.   void copyAttrinfo(Signal* signal, Operationrec * const regOperPtr, Uint32*  inBuffer);
  1651. //------------------------------------------------------------------
  1652. //------------------------------------------------------------------
  1653.   void initOpConnection(Operationrec* regOperPtr, Fragrecord*);
  1655. //------------------------------------------------------------------
  1656. //------------------------------------------------------------------
  1657.   void initOperationrec(Signal* signal);
  1659. //------------------------------------------------------------------
  1660. //------------------------------------------------------------------
  1661.   int initStoredOperationrec(Operationrec* const regOperPtr,
  1662.                              Uint32 storedId);
  1664. //------------------------------------------------------------------
  1665. //------------------------------------------------------------------
  1666.   void insertActiveOpList(Signal* signal, 
  1667.                           OperationrecPtr regOperPtr,
  1668.                           Page * const pagePtr,
  1669.                           Uint32 pageOffset);
  1671. //------------------------------------------------------------------
  1672. //------------------------------------------------------------------
  1673.   void linkOpIntoFragList(OperationrecPtr regOperPtr,
  1674.                           Fragrecord* const regFragPtr);
  1676. //------------------------------------------------------------------
  1677. //------------------------------------------------------------------
  1678.   void bufferTRANSID_AI(Signal* signal, BlockReference aRef, Uint32 Tlen);
  1680. //------------------------------------------------------------------
  1681. // Trigger handling routines
  1682. //------------------------------------------------------------------
  1683.   ArrayList<TupTriggerData>* findTriggerList(Tablerec* table,
  1684.                                              TriggerType::Value ttype,
  1685.                                              TriggerActionTime::Value ttime,
  1686.                                              TriggerEvent::Value tevent);
  1688.   bool createTrigger(Tablerec* table, const CreateTrigReq* req);
  1690.   Uint32 dropTrigger(Tablerec* table, const DropTrigReq* req);
  1692.   void checkImmediateTriggersAfterInsert(Signal* signal, 
  1693.                                          Operationrec* const regOperPtr, 
  1694.                                          Tablerec* const tablePtr);
  1696.   void checkImmediateTriggersAfterUpdate(Signal* signal, 
  1697.                                          Operationrec* const regOperPtr, 
  1698.                                          Tablerec* const tablePtr);
  1700.   void checkImmediateTriggersAfterDelete(Signal* signal, 
  1701.                                          Operationrec* const regOperPtr, 
  1702.                                          Tablerec* const tablePtr);
  1704. #if 0
  1705.   void checkDeferredTriggers(Signal* signal, 
  1706.                              Operationrec* const regOperPtr,
  1707.                              Tablerec* const regTablePtr);
  1708. #endif
  1709.   void checkDetachedTriggers(Signal* signal, 
  1710.                              Operationrec* const regOperPtr,
  1711.                              Tablerec* const regTablePtr);
  1713.   void fireImmediateTriggers(Signal* signal, 
  1714.                              ArrayList<TupTriggerData>& triggerList, 
  1715.                              Operationrec* const regOperPtr);
  1717.   void fireDeferredTriggers(Signal* signal, 
  1718.                             ArrayList<TupTriggerData>& triggerList,
  1719.                             Operationrec* const regOperPtr);
  1721.   void fireDetachedTriggers(Signal* signal,
  1722.                             ArrayList<TupTriggerData>& triggerList,
  1723.                             Operationrec* const regOperPtr);
  1725.   void executeTriggers(Signal* signal,
  1726.                        ArrayList<TupTriggerData>& triggerList,
  1727.                        Operationrec* const regOperPtr);
  1729.   void executeTrigger(Signal* signal, 
  1730.                       TupTriggerData* const trigPtr, 
  1731.                       Operationrec* const regOperPtr);
  1733.   bool readTriggerInfo(TupTriggerData* const trigPtr,
  1734.                        Operationrec* const regOperPtr, 
  1735.                        Uint32* const keyBuffer,
  1736.                        Uint32& noPrimKey,
  1737.                        Uint32* const mainBuffer,
  1738.                        Uint32& noMainWords,
  1739.                        Uint32* const copyBuffer,
  1740.                        Uint32& noCopyWords,
  1741.        bool xfrm);
  1743.   void sendTrigAttrInfo(Signal*        signal, 
  1744.                         Uint32*        data, 
  1745.                         Uint32         dataLen,
  1746.                         bool           executeDirect,
  1747.                         BlockReference receiverReference);
  1749.   Uint32 setAttrIds(Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask, 
  1750.                     Uint32 noOfAttributes, 
  1751.                     Uint32* inBuffer);
  1753.   void sendFireTrigOrd(Signal* signal, 
  1754.                        Operationrec * const regOperPtr, 
  1755.                        TupTriggerData* const trigPtr,
  1756.                        Uint32 noPrimKeySignals, 
  1757.                        Uint32 noBeforeSignals, 
  1758.                        Uint32 noAfterSignals);
  1760.   bool primaryKey(Tablerec* const, Uint32);
  1762.   // these set terrorCode and return non-zero on error
  1764.   int executeTuxInsertTriggers(Signal* signal, 
  1765.                                 Operationrec* const regOperPtr,
  1766.                                 Tablerec* const regTabPtr);
  1768.   int executeTuxUpdateTriggers(Signal* signal, 
  1769.                                 Operationrec* const regOperPtr,
  1770.                                 Tablerec* const regTabPtr);
  1772.   int executeTuxDeleteTriggers(Signal* signal, 
  1773.                                 Operationrec* const regOperPtr,
  1774.                                 Tablerec* const regTabPtr);
  1776.   int addTuxEntries(Signal* signal,
  1777.                     Operationrec* regOperPtr,
  1778.                     Tablerec* regTabPtr);
  1780.   // these crash the node on error
  1782.   void executeTuxCommitTriggers(Signal* signal, 
  1783.                                 Operationrec* regOperPtr,
  1784.                                 Tablerec* const regTabPtr);
  1786.   void executeTuxAbortTriggers(Signal* signal, 
  1787.                                Operationrec* regOperPtr,
  1788.                                Tablerec* const regTabPtr);
  1790.   void removeTuxEntries(Signal* signal,
  1791.                         Operationrec* regOperPtr,
  1792.                         Tablerec* regTabPtr);
  1794. // *****************************************************************
  1795. // Error Handling routines.
  1796. // *****************************************************************
  1797. //------------------------------------------------------------------
  1798. //------------------------------------------------------------------
  1799.   int TUPKEY_abort(Signal* signal, int error_type);
  1801. //------------------------------------------------------------------
  1802. //------------------------------------------------------------------
  1803.   void tupkeyErrorLab(Signal* signal);
  1805. //------------------------------------------------------------------
  1806. //------------------------------------------------------------------
  1807. // Methods to handle execution of TUP_COMMITREQ + TUP_ABORTREQ.
  1808. //
  1809. // Module Transaction Manager
  1810. //
  1811. // The Transaction Manager module is responsible for the commit
  1812. // and abort of operations started by the Execution Manager.
  1813. //
  1814. // Commit Operation:
  1815. // ----------------
  1816. //
  1817. // Failures in commit processing is not allowed since that would
  1818. // leave the database in an unreliable state. Thus the only way
  1819. // to handle failures in commit processing is to crash the node.
  1820. //
  1821. // TUP_COMMITREQ can only be received in the wait state after a
  1822. // successful TUPKEYREQ which was not a read operation.
  1823. // 
  1824. // Commit of Delete:
  1825. // -----------------
  1826. //
  1827. // This will actually perform the deletion of the record unless
  1828. // other operations also are connected to the record. In this case
  1829. // we will set the delete state on the record that becomes the owner
  1830. // of the record.
  1831. //
  1832. // Commit of Update:
  1833. // ----------------
  1834. //
  1835. // We will release the copy record where the original record was kept.
  1836. // Also here we will take special care if more operations are updating
  1837. // the record simultaneously.
  1838. //
  1839. // Commit of Insert:
  1840. // -----------------
  1841. //
  1842. // Will simply reset the state of the operation record.
  1843. //
  1844. // Signal Diagram:
  1845. // --->  TUP_COMMITREQ (from LQH)
  1846. // <---- TUP_COMMITCONF (to LQH)
  1847. //
  1848. //
  1849. // Abort Operation:
  1850. // ----------------
  1851. //
  1852. // Signal Diagram:
  1853. // --->  TUP_ABORTREQ (from LQH)
  1854. // <---- TUP_ABORTCONF (to LQH)
  1855. //
  1856. // Failures in abort processing is not allowed since that would
  1857. // leave the database in an unreliable state. Thus the only way
  1858. // to handle failures in abort processing is to crash the node.
  1859. //
  1860. // Abort messages can arrive at any time. It can arrive even before
  1861. // anything at all have arrived of the operation. It can arrive after
  1862. // receiving a number of ATTRINFO but before TUPKEYREQ has been received.
  1863. // It must arrive after that we sent TUPKEYREF in response to TUPKEYREQ
  1864. // and finally it can arrive after successfully performing the TUPKEYREQ
  1865. // in all cases including the read case.
  1866. //------------------------------------------------------------------
  1867. //------------------------------------------------------------------
  1869. #if 0
  1870.   void checkPages(Fragrecord* const regFragPtr);
  1871. #endif
  1872.   void printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit);
  1874.   bool checkUpdateOfPrimaryKey(Uint32* updateBuffer, Tablerec* const regTabPtr);
  1876.   void setNullBits(Page* const regPage, Tablerec* const regTabPtr, Uint32 pageOffset);
  1877.   bool checkNullAttributes(Operationrec* const, Tablerec* const);
  1878.   bool getPage(PagePtr& pagePtr,
  1879.                Operationrec* const regOperPtr,
  1880.                Fragrecord* const regFragPtr,
  1881.                Tablerec* const regTabPtr);
  1883.   bool getPageLastCommitted(Operationrec* const regOperPtr,
  1884.                             Operationrec* const leaderOpPtr);
  1886.   bool getPageThroughSavePoint(Operationrec* const regOperPtr,
  1887.                                Operationrec* const leaderOpPtr);
  1889.   Uint32 calculateChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize);
  1890.   void setChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize);
  1892.   void commitSimple(Signal* signal,
  1893.                     Operationrec* const regOperPtr,
  1894.                     Fragrecord* const regFragPtr,
  1895.                     Tablerec* const regTabPtr);
  1897.   void commitRecord(Signal* signal,
  1898.                     Operationrec* const regOperPtr,
  1899.                     Fragrecord* const regFragPtr,
  1900.                     Tablerec* const regTabPtr);
  1902.   void setTupleStatesSetOpType(Operationrec* const regOperPtr,
  1903.                                Page* const pagePtr,
  1904.                                Uint32& opType,
  1905.                                OperationrecPtr& firstOpPtr);
  1907.   void findBeforeValueOperation(OperationrecPtr& befOpPtr,
  1908.                                 OperationrecPtr firstOpPtr);
  1910.   void calculateChangeMask(Page* const PagePtr,
  1911.                            Tablerec* const regTabPtr,
  1912.                            Uint32 pageOffset,
  1913.                            Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask);
  1915.   void updateGcpId(Signal* signal,
  1916.                    Operationrec* const regOperPtr,
  1917.                    Fragrecord* const regFragPtr,
  1918.                    Tablerec* const regTabPtr);
  1920.   void abortUpdate(Signal* signal,
  1921.                    Operationrec*  const regOperPtr,
  1922.                    Fragrecord* const regFragPtr,
  1923.                    Tablerec* const regTabPtr);
  1924.   void commitUpdate(Signal* signal,
  1925.                     Operationrec*  const regOperPtr,
  1926.                     Fragrecord* const regFragPtr,
  1927.                     Tablerec* const regTabPtr);
  1929.   void setTupleStateOnPreviousOps(Uint32 prevOpIndex);
  1930.   void copyMem(Signal* signal, Uint32 sourceIndex, Uint32 destIndex);
  1932.   void freeAllAttrBuffers(Operationrec*  const regOperPtr);
  1933.   void freeAttrinbufrec(Uint32 anAttrBufRec);
  1934.   void removeActiveOpList(Operationrec*  const regOperPtr);
  1936.   void updatePackedList(Signal* signal, Uint16 ahostIndex);
  1938.   void setUpDescriptorReferences(Uint32 descriptorReference,
  1939.                                  Tablerec* const regTabPtr,
  1940.                                  const Uint32* offset);
  1941.   void setUpKeyArray(Tablerec* const regTabPtr);
  1942.   bool addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex);
  1943.   void deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId);
  1944.   void abortAddFragOp(Signal* signal);
  1945.   void releaseTabDescr(Tablerec* const regTabPtr);
  1946.   void getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr);
  1948.   void initialiseRecordsLab(Signal* signal, Uint32 switchData, Uint32, Uint32);
  1949.   void initializeAttrbufrec();
  1950.   void initializeCheckpointInfoRec();
  1951.   void initializeDiskBufferSegmentRecord();
  1952.   void initializeFragoperrec();
  1953.   void initializeFragrecord();
  1954.   void initializeHostBuffer();
  1955.   void initializeLocalLogInfo();
  1956.   void initializeOperationrec();
  1957.   void initializePendingFileOpenInfoRecord();
  1958.   void initializeRestartInfoRec();
  1959.   void initializeTablerec();
  1960.   void initializeTabDescr();
  1961.   void initializeUndoPage();
  1963.   void initTab(Tablerec* const regTabPtr);
  1965.   void startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2);
  1967.   void fragrefuseLab(Signal* signal, FragoperrecPtr fragOperPtr);
  1968.   void fragrefuse1Lab(Signal* signal, FragoperrecPtr fragOperPtr);
  1969.   void fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr);
  1970.   void fragrefuse3Lab(Signal* signal,
  1971.                       FragoperrecPtr fragOperPtr,
  1972.                       FragrecordPtr regFragPtr,
  1973.                       Tablerec* const regTabPtr,
  1974.                       Uint32 fragId);
  1975.   void fragrefuse4Lab(Signal* signal,
  1976.                       FragoperrecPtr fragOperPtr,
  1977.                       FragrecordPtr regFragPtr,
  1978.                       Tablerec* const regTabPtr,
  1979.                       Uint32 fragId);
  1980.   void addattrrefuseLab(Signal* signal,
  1981.                         FragrecordPtr regFragPtr,
  1982.                         FragoperrecPtr fragOperPtr,
  1983.                         Tablerec* const regTabPtr,
  1984.                         Uint32 fragId);
  1987.   void checkLcpActiveBufferPage(Uint32 minPageNotWrittenInCheckpoint, DiskBufferSegmentInfoPtr dbsiPtr);
  1988.   void lcpWriteListDataPageSegment(Signal* signal,
  1989.                                    DiskBufferSegmentInfoPtr dbsiPtr,
  1990.                                    CheckpointInfoPtr ciPtr,
  1991.                                    bool flushFlag);
  1992.   void lcpFlushLogLab(Signal* signal, CheckpointInfoPtr ciPtr);
  1993.   void lcpClosedDataFileLab(Signal* signal, CheckpointInfoPtr ciPtr);
  1994.   void lcpEndconfLab(Signal* signal);
  1995.   void lcpSaveDataPageLab(Signal* signal, Uint32 ciIndex);
  1996.   void lcpCompletedLab(Signal* signal, Uint32 ciIndex);
  1997.   void lcpFlushRestartInfoLab(Signal* signal, Uint32 ciIndex);
  1998.   void lcpSaveCopyListLab(Signal* signal, CheckpointInfoPtr ciPtr);
  2000.   void sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr);
  2001.   void releaseFragment(Signal* signal, Uint32 tableId);
  2003.   void allocDataBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr);
  2004.   void allocRestartUndoBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr, LocalLogInfoPtr lliPtr);
  2005.   void freeDiskBufferSegmentRecord(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr);
  2006.   void freeUndoBufferPages(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr);
  2008.   void releaseCheckpointInfoRecord(CheckpointInfoPtr ciPtr);
  2009.   void releaseDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr dbsiPtr);
  2010.   void releaseFragoperrec(FragoperrecPtr fragOperPtr);
  2011.   void releaseFragrec(FragrecordPtr regFragPtr);
  2012.   void releasePendingFileOpenInfoRecord(PendingFileOpenInfoPtr pfoPtr);
  2013.   void releaseRestartInfoRecord(RestartInfoRecordPtr riPtr);
  2015.   void seizeDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr& dbsiPtr);
  2016.   void seizeCheckpointInfoRecord(CheckpointInfoPtr& ciPtr);
  2017.   void seizeFragoperrec(FragoperrecPtr& fragOperPtr);
  2018.   void seizeFragrecord(FragrecordPtr& regFragPtr);
  2019.   void seizeOpRec(OperationrecPtr& regOperPtr);
  2020.   void seizePendingFileOpenInfoRecord(PendingFileOpenInfoPtr& pfoiPtr);
  2021.   void seizeRestartInfoRecord(RestartInfoRecordPtr& riPtr);
  2023.   // Initialisation
  2024.   void initData();
  2025.   void initRecords();
  2027.   void rfrClosedDataFileLab(Signal* signal, Uint32 restartIndex);
  2028.   void rfrCompletedLab(Signal* signal, RestartInfoRecordPtr riPtr);
  2029.   void rfrInitRestartInfoLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr);
  2030.   void rfrLoadDataPagesLab(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr);
  2031.   void rfrReadFirstUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr);
  2032.   void rfrReadNextDataSegment(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr);
  2033.   void rfrReadNextUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr);
  2034.   void rfrReadRestartInfoLab(Signal* signal, RestartInfoRecordPtr riPtr);
  2035.   void rfrReadSecondUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr);
  2037.   void startExecUndoLogLab(Signal* signal, Uint32 lliIndex);
  2038.   void readExecUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr);
  2039.   void closeExecUndoLogLab(Signal* signal, LocalLogInfoPtr lliPtr);
  2040.   void endExecUndoLogLab(Signal* signal, Uint32 lliIndex);
  2042.   struct XlcStruct {
  2043.     Uint32 PageId;
  2044.     Uint32 PageIndex;
  2045.     Uint32 LogRecordType;
  2046.     Uint32 FragId;
  2047.     FragrecordPtr FragPtr;
  2048.     LocalLogInfoPtr LliPtr;
  2049.     DiskBufferSegmentInfoPtr DbsiPtr;
  2050.     UndoPagePtr UPPtr;
  2051.     TablerecPtr TabPtr;
  2052.   };
  2054.   void xlcGetNextRecordLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr);
  2055.   void xlcRestartCompletedLab(Signal* signal);
  2057.   void xlcCopyData(XlcStruct& xlcStruct, Uint32 pageOffset, Uint32 noOfWords, PagePtr pagePtr);
  2058.   void xlcGetLogHeader(XlcStruct& xlcStruct);
  2059.   Uint32 xlcGetLogWord(XlcStruct& xlcStruct);
  2061.   void xlcAbortInsert(Signal* signal, XlcStruct& xlcStruct);
  2062.   void xlcAbortUpdate(Signal* signal, XlcStruct& xlcStruct);
  2063.   void xlcDeleteTh(XlcStruct& xlcStruct);
  2064.   void xlcIndicateNoOpActive(XlcStruct& xlcStruct);
  2065.   void xlcInsertTh(XlcStruct& xlcStruct);
  2066.   void xlcTableDescriptor(XlcStruct& xlcStruct);
  2067.   void xlcUndoLogPageHeader(XlcStruct& xlcStruct);
  2068.   void xlcUpdateTh(XlcStruct& xlcStruct);
  2069.   void xlcUpdateGCI(XlcStruct& xlcStruct);
  2072.   void cprAddData(Signal* signal,
  2073.                   Fragrecord* const regFragPtr,
  2074.                   Uint32 pageIndex,
  2075.                   Uint32 noOfWords,
  2076.                   Uint32 startOffset);
  2077.   void cprAddGCIUpdate(Signal* signal,
  2078.                        Uint32 prevGCI,
  2079.                        Fragrecord* const regFragPtr);
  2080.   void cprAddLogHeader(Signal* signal,
  2081.                        LocalLogInfo* const lliPtr,
  2082.                        Uint32 recordType,
  2083.                        Uint32 tableId,
  2084.                        Uint32 fragId);
  2085.   void cprAddUndoLogPageHeader(Signal* signal,
  2086.                                Page* const regPagePtr,
  2087.                                Fragrecord* const regFragPtr);
  2088.   void cprAddUndoLogRecord(Signal* signal,
  2089.                            Uint32 recordType,
  2090.                            Uint32 pageId,
  2091.                            Uint32 pageIndex,
  2092.                            Uint32 tableId,
  2093.                            Uint32 fragId,
  2094.                            Uint32 localLogIndex);
  2095.   void cprAddAbortUpdate(Signal* signal,
  2096.                          LocalLogInfo* const lliPtr,
  2097.                          Operationrec* const regOperPtr);
  2098.   void cprAddUndoLogWord(Signal* signal,
  2099.                          LocalLogInfo* const lliPtr,
  2100.                          Uint32 undoWord);
  2101.   bool isUndoLoggingNeeded(Fragrecord* const regFragPtr, Uint32 pageId);
  2102.   bool isUndoLoggingActive(Fragrecord* const regFragPtr);
  2103.   bool isUndoLoggingBlocked(Fragrecord* const regFragPtr);
  2104.   bool isPageUndoLogged(Fragrecord* const regFragPtr, Uint32 pageId);
  2106.   void seizeUndoBufferSegment(Signal* signal, UndoPagePtr& regUndoPagePtr);
  2107.   void lcpWriteUndoSegment(Signal* signal, LocalLogInfo* const lliPtr, bool flushFlag);
  2110.   void deleteScanProcedure(Signal* signal, Operationrec* regOperPtr);
  2111.   void copyProcedure(Signal* signal,
  2112.                      TablerecPtr regTabPtr,
  2113.                      Operationrec* regOperPtr);
  2114.   void scanProcedure(Signal* signal,
  2115.                      Operationrec* regOperPtr,
  2116.                      Uint32 lenAttrInfo);
  2117.   void storedSeizeAttrinbufrecErrorLab(Signal* signal,
  2118.                                        Operationrec* regOperPtr);
  2119.   bool storedProcedureAttrInfo(Signal* signal,
  2120.                                Operationrec* regOperPtr,
  2121.                                Uint32 length,
  2122.                                Uint32 firstWord,
  2123.                                bool copyProc);
  2125. //-----------------------------------------------------------------------------
  2126. // Table Descriptor Memory Manager
  2127. //-----------------------------------------------------------------------------
  2129. // Public methods
  2130.   Uint32 getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset);
  2131.   Uint32 allocTabDescr(const Tablerec* regTabPtr, Uint32* offset);
  2132.   void freeTabDescr(Uint32 retRef, Uint32 retNo);
  2133.   Uint32 getTabDescrWord(Uint32 index);
  2134.   void setTabDescrWord(Uint32 index, Uint32 word);
  2136. // Private methods
  2137.   Uint32 sizeOfReadFunction();
  2138.   void   removeTdArea(Uint32 tabDesRef, Uint32 list);
  2139.   void   insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list);
  2140.   Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo);
  2142. //------------------------------------------------------------------------------------------------------
  2143. // Page Memory Manager
  2144. //------------------------------------------------------------------------------------------------------
  2146. // Public methods
  2147.   void allocConsPages(Uint32 noOfPagesToAllocate,
  2148.                       Uint32& noOfPagesAllocated,
  2149.                       Uint32& allocPageRef);
  2150.   void returnCommonArea(Uint32 retPageRef, Uint32 retNo);
  2151.   void initializePage();
  2153. // Private methods
  2154.   void removeCommonArea(Uint32 remPageRef, Uint32 list);
  2155.   void insertCommonArea(Uint32 insPageRef, Uint32 list);
  2156.   void findFreeLeftNeighbours(Uint32& allocPageRef, Uint32& noPagesAllocated, Uint32 noPagesToAllocate);
  2157.   void findFreeRightNeighbours(Uint32& allocPageRef, Uint32& noPagesAllocated, Uint32 noPagesToAllocate);
  2158.   Uint32 nextHigherTwoLog(Uint32 input);
  2160. // Private data
  2161.   Uint32 cfreepageList[16];
  2163. //------------------------------------------------------------------------------------------------------
  2164. // Page Mapper, convert logical page id's to physical page id's
  2165. // The page mapper also handles the pages allocated to the fragment.
  2166. //------------------------------------------------------------------------------------------------------
  2167. //
  2168. // Public methods
  2169.   Uint32 getRealpid(Fragrecord* const regFragPtr, Uint32 logicalPageId);
  2170.   Uint32 getNoOfPages(Fragrecord* const regFragPtr);
  2171.   void initPageRangeSize(Uint32 size);
  2172.   bool insertPageRangeTab(Fragrecord* const regFragPtr,
  2173.                           Uint32 startPageId,
  2174.                           Uint32 noPages);
  2175.   void releaseFragPages(Fragrecord* const regFragPtr);
  2176.   void initFragRange(Fragrecord* const regFragPtr);
  2177.   void initializePageRange();
  2178.   Uint32 getEmptyPage(Fragrecord* const regFragPtr);
  2179.   Uint32 allocFragPages(Fragrecord* const regFragPtr, Uint32 noOfPagesAllocated);
  2181. // Private methods
  2182.   Uint32 leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr currPageRangePtr);
  2183.   void releasePagerange(PageRangePtr regPRPtr);
  2184.   void seizePagerange(PageRangePtr& regPageRangePtr);
  2185.   void errorHandler(Uint32 errorCode);
  2186.   void allocMoreFragPages(Fragrecord* const regFragPtr);
  2188. // Private data
  2189.   Uint32 cfirstfreerange;
  2190.   PageRange *pageRange;
  2191.   Uint32 c_noOfFreePageRanges;
  2192.   Uint32 cnoOfPageRangeRec;
  2194. //------------------------------------------------------------------------------------------------------
  2195. // Fixed Allocator
  2196. // Allocates and deallocates tuples of fixed size on a fragment.
  2197. //------------------------------------------------------------------------------------------------------
  2198. //
  2199. // Public methods
  2200.   bool allocTh(Fragrecord* const regFragPtr,
  2201.                Tablerec* const regTabPtr,
  2202.                Uint32 pageType,
  2203.                Signal* signal,
  2204.                Uint32& pageOffset,
  2205.                PagePtr& pagePtr);
  2207.   void freeThSr(Tablerec*  const regTabPtr,
  2208.                 Page*  const regPagePtr,
  2209.                 Uint32 freePageOffset);
  2211.   void freeTh(Fragrecord*  const regFragPtr,
  2212.               Tablerec* const regTabPtr,
  2213.               Signal* signal,
  2214.               Page*  const regPagePtr,
  2215.               Uint32 freePageOffset);
  2217.   void getThAtPageSr(Page* const regPagePtr,
  2218.                      Uint32& pageOffset);
  2220. // Private methods
  2221.   void convertThPage(Uint32 Tupheadsize,
  2222.                      Page*  const regPagePtr);
  2224.   void getThAtPage(Fragrecord* const regFragPtr,
  2225.                    Page* const regPagePtr,
  2226.                    Signal* signal,
  2227.                    Uint32& pageOffset);
  2229.   void getEmptyPageThCopy(Fragrecord* const regFragPtr,
  2230.                           Signal* signal,
  2231.                           Page* const regPagePtr);
  2233.   void getEmptyPageTh(Fragrecord* const regFragPtr,
  2234.                       Signal* signal,
  2235.                       Page* const regPagePtr);
  2237. //------------------------------------------------------------------------------------------------------
  2238. // Temporary variables used for storing commonly used variables in certain modules
  2239. //------------------------------------------------------------------------------------------------------
  2241.   FragrecordPtr   fragptr;
  2242.   OperationrecPtr operPtr;
  2243.   TablerecPtr     tabptr;
  2245. // readAttributes and updateAttributes module
  2246.   Uint32          tCheckOffset;
  2247.   Uint32          tMaxRead;
  2248.   Uint32          tOutBufIndex;
  2249.   Uint32*         tTupleHeader;
  2250.   bool            tXfrmFlag;
  2252. // updateAttributes module
  2253.   Uint32          tInBufIndex;
  2254.   Uint32          tInBufLen;
  2256.   Uint32          terrorCode;
  2258. //------------------------------------------------------------------------------------------------------
  2259. // Common stored variables. Variables that have a valid value always.
  2260. //------------------------------------------------------------------------------------------------------
  2261.   Uint32 cnoOfLcpRec;
  2262.   Uint32 cnoOfParallellUndoFiles;
  2263.   Uint32 cnoOfUndoPage;
  2265.   Attrbufrec *attrbufrec;
  2266.   Uint32 cfirstfreeAttrbufrec;
  2267.   Uint32 cnoOfAttrbufrec;
  2268.   Uint32 cnoFreeAttrbufrec;
  2270.   CheckpointInfo *checkpointInfo;
  2271.   Uint32 cfirstfreeLcp;
  2273.   DiskBufferSegmentInfo *diskBufferSegmentInfo;
  2274.   Uint32 cfirstfreePdx;
  2275.   Uint32 cnoOfConcurrentWriteOp;
  2277.   Fragoperrec *fragoperrec;
  2278.   Uint32 cfirstfreeFragopr;
  2279.   Uint32 cnoOfFragoprec;
  2281.   Fragrecord *fragrecord;
  2282.   Uint32 cfirstfreefrag;
  2283.   Uint32 cnoOfFragrec;
  2285.   HostBuffer *hostBuffer;
  2287.   LocalLogInfo *localLogInfo;
  2288.   Uint32 cnoOfLocalLogInfo;
  2290.   Uint32 cfirstfreeOprec;
  2291.   Operationrec *operationrec;
  2292.   Uint32 cnoOfOprec;
  2294.   Page *page;
  2295.   Uint32 cnoOfPage;
  2296.   Uint32 cnoOfAllocatedPages;
  2297.   
  2298.   PendingFileOpenInfo *pendingFileOpenInfo;
  2299.   Uint32 cfirstfreePfo;
  2300.   Uint32 cnoOfConcurrentOpenOp;
  2302.   RestartInfoRecord *restartInfoRecord;
  2303.   Uint32 cfirstfreeSri;
  2304.   Uint32 cnoOfRestartInfoRec;
  2306.   Tablerec *tablerec;
  2307.   Uint32 cnoOfTablerec;
  2309.   TableDescriptor *tableDescriptor;
  2310.   Uint32 cnoOfTabDescrRec;
  2312.   UndoPage *undoPage;
  2313.   Uint32 cfirstfreeUndoSeg;
  2314.   Int32 cnoFreeUndoSeg;
  2318.   Uint32 cnoOfDataPagesToDiskWithoutSynch;
  2320.   Uint32 cdata[32];
  2321.   Uint32 cdataPages[16];
  2322.   Uint32 cpackedListIndex;
  2323.   Uint32 cpackedList[MAX_NODES];
  2324.   Uint32 cfreeTdList[16];
  2325.   Uint32 clastBitMask;
  2326.   Uint32 clblPageCounter;
  2327.   Uint32 clblPagesPerTick;
  2328.   Uint32 clblPagesPerTickAfterSr;
  2329.   BlockReference clqhBlockref;
  2330.   Uint32 clqhUserpointer;
  2331.   Uint32 cminusOne;
  2332.   BlockReference cndbcntrRef;
  2333.   Uint32 cundoFileVersion;
  2334.   BlockReference cownref;
  2335.   Uint32 cownNodeId;
  2336.   Uint32 czero;
  2338.  // A little bit bigger to cover overwrites in copy algorithms (16384 real size).
  2339. #define ZATTR_BUFFER_SIZE 16384
  2340.   Uint32 clogMemBuffer[ZATTR_BUFFER_SIZE + 16];
  2341.   Uint32 coutBuffer[ZATTR_BUFFER_SIZE + 16];
  2342.   Uint32 cinBuffer[ZATTR_BUFFER_SIZE + 16];
  2343.   Uint32 totNoOfPagesAllocated;
  2345.   // Trigger variables
  2346.   Uint32 c_maxTriggersPerTable;
  2348.   // Counters for num UNDO log records executed
  2349.   Uint32 cSrUndoRecords[9];
  2351.   STATIC_CONST(MAX_PARALLELL_TUP_SRREQ = 2); 
  2352.   Uint32 c_sr_free_page_0;
  2354.   Uint32 c_errorInsert4000TableId;
  2356.   void initGlobalTemporaryVars();
  2357.   void reportMemoryUsage(Signal* signal, int incDec);
  2359.   
  2360. #ifdef VM_TRACE
  2361.   struct Th {
  2362.     Uint32 data[1];
  2363.   };
  2364.   friend class NdbOut& operator<<(NdbOut&, const Operationrec&);
  2365.   friend class NdbOut& operator<<(NdbOut&, const Th&);
  2366. #endif
  2367. };
  2369. inline
  2370. bool Dbtup::isUndoLoggingNeeded(Fragrecord* const regFragPtr,
  2371.                                 Uint32 pageId)
  2372. {
  2373.   if ((regFragPtr->checkpointVersion != RNIL) &&
  2374.       (pageId >= regFragPtr->minPageNotWrittenInCheckpoint) &&
  2375.       (pageId < regFragPtr->maxPageWrittenInCheckpoint)) {
  2376.     return true;
  2377.   }//if
  2378.   return false;
  2379. }//Dbtup::isUndoLoggingNeeded()
  2381. inline
  2382. bool Dbtup::isUndoLoggingActive(Fragrecord* const regFragPtr)
  2383. {
  2384.   if (regFragPtr->checkpointVersion != RNIL) {
  2385.     return true;
  2386.   }//if
  2387.   return false;
  2388. }//Dbtup::isUndoLoggingNeeded()
  2390. inline
  2391. bool Dbtup::isUndoLoggingBlocked(Fragrecord* const regFragPtr)
  2392. {
  2393.   if ((regFragPtr->checkpointVersion != RNIL) &&
  2394.       (cnoFreeUndoSeg < ZMIN_PAGE_LIMIT_TUPKEYREQ)) {
  2395.     return true;
  2396.   }//if
  2397.   return false;
  2398. }//Dbtup::isUndoLoggingNeeded()
  2400. inline
  2401. bool Dbtup::isPageUndoLogged(Fragrecord* const regFragPtr,
  2402.                              Uint32 pageId)
  2403. {
  2404.   if ((pageId >= regFragPtr->minPageNotWrittenInCheckpoint) &&
  2405.       (pageId < regFragPtr->maxPageWrittenInCheckpoint)) {
  2406.     return true;
  2407.   }//if
  2408.   return false;
  2409. }//Dbtup::isUndoLoggingNeeded()
  2411. #endif