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

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef DBDICT_H
  14. #define DBDICT_H
  15. /**
  16.  * Dict : Dictionary Block
  17.  */
  18. #include <ndb_limits.h>
  19. #include <trigger_definitions.h>
  20. #include <pc.hpp>
  21. #include <ArrayList.hpp>
  22. #include <DLHashTable.hpp>
  23. #include <CArray.hpp>
  24. #include <KeyTable2.hpp>
  25. #include <SimulatedBlock.hpp>
  26. #include <SimpleProperties.hpp>
  27. #include <SignalCounter.hpp>
  28. #include <Bitmask.hpp>
  29. #include <AttributeList.hpp>
  30. #include <signaldata/GetTableId.hpp>
  31. #include <signaldata/GetTabInfo.hpp>
  32. #include <signaldata/DictTabInfo.hpp>
  33. #include <signaldata/CreateTable.hpp>
  34. #include <signaldata/CreateTab.hpp>
  35. #include <signaldata/DropTable.hpp>
  36. #include <signaldata/AlterTable.hpp>
  37. #include <signaldata/AlterTab.hpp>
  38. #include <signaldata/CreateIndx.hpp>
  39. #include <signaldata/DropIndx.hpp>
  40. #include <signaldata/AlterIndx.hpp>
  41. #include <signaldata/BuildIndx.hpp>
  42. #include <signaldata/UtilPrepare.hpp>
  43. #include <signaldata/CreateEvnt.hpp>
  44. #include <signaldata/CreateTrig.hpp>
  45. #include <signaldata/DropTrig.hpp>
  46. #include <signaldata/AlterTrig.hpp>
  47. #include "SchemaFile.hpp"
  48. #include <blocks/mutexes.hpp>
  49. #include <SafeCounter.hpp>
  50. #include <RequestTracker.hpp>
  51. #ifdef DBDICT_C
  52. // Debug Macros
  53. /*--------------------------------------------------------------*/
  54. // Constants for CONTINUEB
  55. /*--------------------------------------------------------------*/
  56. #define ZPACK_TABLE_INTO_PAGES 0
  57. #define ZSEND_GET_TAB_RESPONSE 3
  58. /*--------------------------------------------------------------*/
  59. // Other constants in alphabetical order
  60. /*--------------------------------------------------------------*/
  61. #define ZNOMOREPHASES 255
  62. /*--------------------------------------------------------------*/
  63. // Schema file defines
  64. /*--------------------------------------------------------------*/
  65. #define ZSCHEMA_WORDS 4
  66. /*--------------------------------------------------------------*/
  67. // Page constants
  68. /*--------------------------------------------------------------*/
  69. #define ZALLOCATE 1 //Variable number of page for NDBFS
  70. #define ZPAGE_HEADER_SIZE 32
  71. #define ZPOS_PAGE_SIZE 16
  72. #define ZPOS_CHECKSUM 17
  73. #define ZPOS_VERSION 18
  74. #define ZPOS_PAGE_HEADER_SIZE 19
  75. /*--------------------------------------------------------------*/
  76. // Size constants
  77. /*--------------------------------------------------------------*/
  78. #define ZFS_CONNECT_SIZE 4
  79. #define ZSIZE_OF_PAGES_IN_WORDS 8192
  80. #define ZLOG_SIZE_OF_PAGES_IN_WORDS 13
  81. #define ZMAX_PAGES_OF_TABLE_DEFINITION 8
  82. #define ZNUMBER_OF_PAGES (2 * ZMAX_PAGES_OF_TABLE_DEFINITION + 2)
  83. #define ZNO_OF_FRAGRECORD 5
  84. /*--------------------------------------------------------------*/
  85. // Error codes
  86. /*--------------------------------------------------------------*/
  87. #define ZNODE_FAILURE_ERROR 704
  88. #endif
  89. /**
  90.  * Systable NDB$EVENTS_0
  91.  */
  92. #define EVENT_SYSTEM_TABLE_NAME "sys/def/NDB$EVENTS_0"
  93. #define EVENT_SYSTEM_TABLE_LENGTH 6
  94. struct sysTab_NDBEVENTS_0 {
  95.   char   NAME[MAX_TAB_NAME_SIZE];
  96.   Uint32 EVENT_TYPE;
  97.   char   TABLE_NAME[MAX_TAB_NAME_SIZE];
  98.   Uint32 ATTRIBUTE_MASK[MAXNROFATTRIBUTESINWORDS];
  99.   Uint32 SUBID;
  100.   Uint32 SUBKEY;
  101. };
  102. /**
  103.  *  DICT - This blocks handles all metadata
  104.  */
  105. class Dbdict: public SimulatedBlock {
  106. public:
  107.   /*
  108.    *   2.3 RECORD AND FILESIZES
  109.    */
  110.   /**
  111.    * Shared table / index record.  Most of this is permanent data stored
  112.    * on disk.  Index trigger ids are volatile.
  113.    */
  114.   struct TableRecord : public MetaData::Table {
  115.     /****************************************************
  116.      *    Support variables for table handling
  117.      ****************************************************/
  118.     /*     Active page which is sent to disk */
  119.     Uint32 activePage;
  120.     /**    File pointer received from disk   */
  121.     Uint32 filePtr[2];
  122.     /**    Pointer to first attribute in table */
  123.     Uint32 firstAttribute;
  124.     /*    Pointer to first page of table description */
  125.     Uint32 firstPage;
  126.     /**    Pointer to last attribute in table */
  127.     Uint32 lastAttribute;
  128. #ifdef HAVE_TABLE_REORG    
  129.     /*    Second table used by this table (for table reorg) */
  130.     Uint32 secondTable;
  131. #endif
  132.     /*    Next record in Pool */
  133.     Uint32 nextPool;
  134.     /*    Next record in hash table */
  135.     Uint32 nextHash;
  136.     /*    Previous record in Pool */
  137.     Uint32 prevPool;
  138.     /*    Previous record in hash table */
  139.     Uint32 prevHash;
  140.     enum TabState {
  141.       NOT_DEFINED = 0,
  142.       REORG_TABLE_PREPARED = 1,
  143.       DEFINING = 2,
  144.       CHECKED = 3,
  145.       DEFINED = 4,
  146.       PREPARE_DROPPING = 5,
  147.       DROPPING = 6,
  148.       BACKUP_ONGOING = 7
  149.     };
  150.     TabState tabState;
  151.     /*    State when returning from TC_SCHVERREQ */
  152.     enum TabReturnState {
  153.       TRS_IDLE = 0,
  154.       ADD_TABLE = 1,
  155.       SLAVE_SYSTEM_RESTART = 2,
  156.       MASTER_SYSTEM_RESTART = 3
  157.     };
  158.     TabReturnState tabReturnState;
  159.     /**    Number of words */
  160.     Uint32 packedSize;
  161.     /**   Index state (volatile data) */
  162.     enum IndexState {
  163.       IS_UNDEFINED = 0,         // initial
  164.       IS_OFFLINE = 1,           // index table created
  165.       IS_BUILDING = 2,          // building (local state)
  166.       IS_DROPPING = 3,          // dropping (local state)
  167.       IS_ONLINE = 4,            // online
  168.       IS_BROKEN = 9             // build or drop aborted
  169.     };
  170.     IndexState indexState;
  171.     /**   Trigger ids of index (volatile data) */
  172.     Uint32 insertTriggerId;
  173.     Uint32 updateTriggerId;
  174.     Uint32 deleteTriggerId;
  175.     Uint32 customTriggerId;     // ordered index
  176.     Uint32 buildTriggerId;      // temp during build
  177.     /**  Index state in other blocks on this node */
  178.     enum IndexLocal {
  179.       IL_CREATED_TC = 1 << 0    // created in TC
  180.     };
  181.     Uint32 indexLocal;
  182.     inline bool equal(TableRecord & rec) const {
  183.       return strcmp(tableName, rec.tableName) == 0;
  184.     }
  185.     inline Uint32 hashValue() const {
  186.       Uint32 h = 0;
  187.       for (const char* p = tableName; *p != 0; p++)
  188.         h = (h << 5) + h + (*p);
  189.       return h;
  190.     }
  191.     /**  frm data for this table */
  192.     /** TODO Could preferrably be made dynamic size */
  193.     Uint32 frmLen;
  194.     char frmData[MAX_FRM_DATA_SIZE];
  195.     Uint32 fragmentCount;
  196.   };
  197.   typedef Ptr<TableRecord> TableRecordPtr;
  198.   ArrayPool<TableRecord> c_tableRecordPool;
  199.   DLHashTable<TableRecord> c_tableRecordHash;
  200.   /**
  201.    * Table attributes.  Permanent data.
  202.    *
  203.    * Indexes have an attribute list which duplicates primary table
  204.    * attributes.  This is wrong but convenient.
  205.    */
  206.   struct AttributeRecord : public MetaData::Attribute {
  207.     union {    
  208.     /** Pointer to the next attribute used by ArrayPool */
  209.     Uint32 nextPool;
  210.     /** Pointer to the next attribute used by DLHash */
  211.     Uint32 nextHash;
  212.     };
  213.     /** Pointer to the previous attribute used by DLHash */
  214.     Uint32 prevHash;
  215.     /** Pointer to the next attribute in table */
  216.     Uint32 nextAttrInTable;
  217.     inline bool equal(AttributeRecord & rec) const {
  218.       return strcmp(attributeName, rec.attributeName) == 0;
  219.     }
  220.     inline Uint32 hashValue() const {
  221.       Uint32 h = 0;
  222.       for (const char* p = attributeName; *p != 0; p++)
  223.         h = (h << 5) + h + (*p);
  224.       return h;
  225.     }
  226.   };
  227.   typedef Ptr<AttributeRecord> AttributeRecordPtr;
  228.   ArrayPool<AttributeRecord> c_attributeRecordPool;
  229.   DLHashTable<AttributeRecord> c_attributeRecordHash;
  230.   /**
  231.    * Triggers.  This is volatile data not saved on disk.  Setting a
  232.    * trigger online creates the trigger in TC (if index) and LQH-TUP.
  233.    */
  234.   struct TriggerRecord {
  235.     /** Trigger state */
  236.     enum TriggerState { 
  237.       TS_NOT_DEFINED = 0,
  238.       TS_DEFINING = 1,
  239.       TS_OFFLINE  = 2,   // created globally in DICT
  240.       TS_BUILDING = 3,
  241.       TS_DROPPING = 4,
  242.       TS_ONLINE = 5      // activated globally
  243.     };
  244.     TriggerState triggerState;
  245.     /** Trigger state in other blocks on this node */
  246.     enum IndexLocal {
  247.       TL_CREATED_TC = 1 << 0,   // created in TC
  248.       TL_CREATED_LQH = 1 << 1   // created in LQH-TUP
  249.     };
  250.     Uint32 triggerLocal;
  251.     /** Trigger name, used by DICT to identify the trigger */ 
  252.     char triggerName[MAX_TAB_NAME_SIZE];
  253.     /** Trigger id, used by TRIX, TC, LQH, and TUP to identify the trigger */
  254.     Uint32 triggerId;
  255.     /** Table id, the table the trigger is defined on */
  256.     Uint32 tableId;
  257.     /** Trigger type, defines what the trigger is used for */
  258.     TriggerType::Value triggerType;
  259.     
  260.     /** Trigger action time, defines when the trigger should fire */
  261.     TriggerActionTime::Value triggerActionTime;
  262.     
  263.     /** Trigger event, defines what events the trigger should monitor */
  264.     TriggerEvent::Value triggerEvent;
  265.     
  266.     /** Monitor all replicas */
  267.     bool monitorReplicas;
  268.     /** Monitor all, the trigger monitors changes of all attributes in table */
  269.     bool monitorAllAttributes;
  270.     
  271.     /**
  272.      * Attribute mask, defines what attributes are to be monitored.
  273.      * Can be seen as a compact representation of SQL column name list.
  274.      */
  275.     AttributeMask attributeMask;
  276.     /** Index id, only used by secondary_index triggers */
  277.     Uint32 indexId;
  278.     union {
  279.     /** Pointer to the next attribute used by ArrayPool */
  280.     Uint32 nextPool;
  281.     /** Next record in hash table */
  282.     Uint32 nextHash;
  283.     };
  284.     
  285.     /** Previous record in hash table */
  286.     Uint32 prevHash;
  287.     /** Equal function, used by DLHashTable */
  288.     inline bool equal(TriggerRecord & rec) const {
  289.        return strcmp(triggerName, rec.triggerName) == 0;
  290.     }
  291.     
  292.     /** Hash value function, used by DLHashTable */
  293.     inline Uint32 hashValue() const {
  294.       Uint32 h = 0;
  295.       for (const char* p = triggerName; *p != 0; p++)
  296.         h = (h << 5) + h + (*p);
  297.       return h;
  298.     }
  299.   };
  300.   
  301.   Uint32 c_maxNoOfTriggers;
  302.   typedef Ptr<TriggerRecord> TriggerRecordPtr;
  303.   ArrayPool<TriggerRecord> c_triggerRecordPool;
  304.   DLHashTable<TriggerRecord> c_triggerRecordHash;
  305.   /**
  306.    * Information for each FS connection.
  307.    ****************************************************************************/
  308.   struct FsConnectRecord {
  309.     enum FsState {
  310.       IDLE = 0,
  311.       OPEN_WRITE_SCHEMA = 1,
  312.       WRITE_SCHEMA = 2,
  313.       CLOSE_WRITE_SCHEMA = 3,
  314.       OPEN_READ_SCHEMA1 = 4,
  315.       OPEN_READ_SCHEMA2 = 5,
  316.       READ_SCHEMA1 = 6,
  317.       READ_SCHEMA2 = 7,
  318.       CLOSE_READ_SCHEMA = 8,
  319.       OPEN_READ_TAB_FILE1 = 9,
  320.       OPEN_READ_TAB_FILE2 = 10,
  321.       READ_TAB_FILE1 = 11,
  322.       READ_TAB_FILE2 = 12,
  323.       CLOSE_READ_TAB_FILE = 13,
  324.       OPEN_WRITE_TAB_FILE = 14,
  325.       WRITE_TAB_FILE = 15,
  326.       CLOSE_WRITE_TAB_FILE = 16
  327.     };
  328.     /** File Pointer for this file system connection */
  329.     Uint32 filePtr;
  330.     /** Reference of owner record */
  331.     Uint32 ownerPtr;
  332.     /** State of file system connection */
  333.     FsState fsState;
  334.     /** Used by Array Pool for free list handling */
  335.     Uint32 nextPool;
  336.   };
  337.   
  338.   typedef Ptr<FsConnectRecord> FsConnectRecordPtr;
  339.   ArrayPool<FsConnectRecord> c_fsConnectRecordPool;
  340.   /**
  341.    * This record stores all the information about a node and all its attributes
  342.    ****************************************************************************/
  343.   struct NodeRecord {
  344.     enum NodeState {
  345.       API_NODE = 0,
  346.       NDB_NODE_ALIVE = 1,
  347.       NDB_NODE_DEAD = 2
  348.     };
  349.     bool hotSpare;
  350.     NodeState nodeState;
  351.   };
  352.   typedef Ptr<NodeRecord> NodeRecordPtr;
  353.   CArray<NodeRecord> c_nodes;
  354.   NdbNodeBitmask c_aliveNodes;
  355.   
  356.   /**
  357.    * This record stores all the information about a table and all its attributes
  358.    ****************************************************************************/
  359.   struct PageRecord {
  360.     Uint32 word[8192];
  361.   };
  362.   
  363.   typedef Ptr<PageRecord> PageRecordPtr;
  364.   CArray<PageRecord> c_pageRecordArray;
  365.   /**
  366.    * A page for create index table signal.
  367.    */
  368.   PageRecord c_indexPage;
  369. public:
  370.   Dbdict(const class Configuration &);
  371.   virtual ~Dbdict();
  372. private:
  373.   BLOCK_DEFINES(Dbdict);
  374.   // Signal receivers
  375.   void execDICTSTARTREQ(Signal* signal);
  376.   
  377.   void execGET_TABINFOREQ(Signal* signal);
  378.   void execGET_TABLEDID_REQ(Signal* signal);
  379.   void execGET_TABINFO_REF(Signal* signal);
  380.   void execGET_TABINFO_CONF(Signal* signal);
  381.   void execCONTINUEB(Signal* signal);
  382.   void execDUMP_STATE_ORD(Signal* signal);
  383.   void execHOT_SPAREREP(Signal* signal);
  384.   void execDIADDTABCONF(Signal* signal);
  385.   void execDIADDTABREF(Signal* signal);
  386.   void execTAB_COMMITCONF(Signal* signal);
  387.   void execTAB_COMMITREF(Signal* signal);
  388.   void execGET_SCHEMA_INFOREQ(Signal* signal);
  389.   void execSCHEMA_INFO(Signal* signal);
  390.   void execSCHEMA_INFOCONF(Signal* signal);
  391.   void execREAD_NODESCONF(Signal* signal);
  392.   void execFSCLOSECONF(Signal* signal);
  393.   void execFSOPENCONF(Signal* signal);
  394.   void execFSOPENREF(Signal* signal);
  395.   void execFSREADCONF(Signal* signal);
  396.   void execFSREADREF(Signal* signal);
  397.   void execFSWRITECONF(Signal* signal);
  398.   void execNDB_STTOR(Signal* signal);
  399.   void execREAD_CONFIG_REQ(Signal* signal);
  400.   void execSTTOR(Signal* signal);
  401.   void execTC_SCHVERCONF(Signal* signal);
  402.   void execNODE_FAILREP(Signal* signal);
  403.   void execINCL_NODEREQ(Signal* signal);
  404.   void execAPI_FAILREQ(Signal* signal);
  405.   void execWAIT_GCP_REF(Signal* signal);
  406.   void execWAIT_GCP_CONF(Signal* signal);
  407.   void execLIST_TABLES_REQ(Signal* signal);
  408.   // Index signals
  409.   void execCREATE_INDX_REQ(Signal* signal);
  410.   void execCREATE_INDX_CONF(Signal* signal);
  411.   void execCREATE_INDX_REF(Signal* signal);
  412.   void execALTER_INDX_REQ(Signal* signal);
  413.   void execALTER_INDX_CONF(Signal* signal);
  414.   void execALTER_INDX_REF(Signal* signal);
  415.   void execCREATE_TABLE_CONF(Signal* signal);
  416.   void execCREATE_TABLE_REF(Signal* signal);
  417.   void execDROP_INDX_REQ(Signal* signal);
  418.   void execDROP_INDX_CONF(Signal* signal);
  419.   void execDROP_INDX_REF(Signal* signal);
  420.   void execDROP_TABLE_CONF(Signal* signal);
  421.   void execDROP_TABLE_REF(Signal* signal);
  422.   void execBUILDINDXREQ(Signal* signal);
  423.   void execBUILDINDXCONF(Signal* signal);
  424.   void execBUILDINDXREF(Signal* signal);
  425.   void execBACKUP_FRAGMENT_REQ(Signal*);
  426.   // Util signals used by Event code
  427.   void execUTIL_PREPARE_CONF(Signal* signal);
  428.   void execUTIL_PREPARE_REF (Signal* signal);
  429.   void execUTIL_EXECUTE_CONF(Signal* signal);
  430.   void execUTIL_EXECUTE_REF (Signal* signal);
  431.   void execUTIL_RELEASE_CONF(Signal* signal);
  432.   void execUTIL_RELEASE_REF (Signal* signal);
  433.   // Event signals from API
  434.   void execCREATE_EVNT_REQ (Signal* signal);
  435.   void execCREATE_EVNT_CONF(Signal* signal);
  436.   void execCREATE_EVNT_REF (Signal* signal);
  437.   void execDROP_EVNT_REQ (Signal* signal);
  438.   void execSUB_START_REQ (Signal* signal);
  439.   void execSUB_START_CONF (Signal* signal);
  440.   void execSUB_START_REF (Signal* signal);
  441.   void execSUB_STOP_REQ (Signal* signal);
  442.   void execSUB_STOP_CONF (Signal* signal);
  443.   void execSUB_STOP_REF (Signal* signal);
  444.   // Event signals from SUMA
  445.   void execCREATE_SUBID_CONF(Signal* signal);
  446.   void execCREATE_SUBID_REF (Signal* signal);
  447.   void execSUB_CREATE_CONF(Signal* signal);
  448.   void execSUB_CREATE_REF (Signal* signal);
  449.   void execSUB_SYNC_CONF(Signal* signal);
  450.   void execSUB_SYNC_REF (Signal* signal);
  451.   void execSUB_REMOVE_REQ(Signal* signal);
  452.   void execSUB_REMOVE_CONF(Signal* signal);
  453.   void execSUB_REMOVE_REF(Signal* signal);
  454.   // Trigger signals
  455.   void execCREATE_TRIG_REQ(Signal* signal);
  456.   void execCREATE_TRIG_CONF(Signal* signal);
  457.   void execCREATE_TRIG_REF(Signal* signal);
  458.   void execALTER_TRIG_REQ(Signal* signal);
  459.   void execALTER_TRIG_CONF(Signal* signal);
  460.   void execALTER_TRIG_REF(Signal* signal);
  461.   void execDROP_TRIG_REQ(Signal* signal);
  462.   void execDROP_TRIG_CONF(Signal* signal);
  463.   void execDROP_TRIG_REF(Signal* signal);
  464.   void execDROP_TABLE_REQ(Signal* signal);
  465.   
  466.   void execPREP_DROP_TAB_REQ(Signal* signal);
  467.   void execPREP_DROP_TAB_REF(Signal* signal);  
  468.   void execPREP_DROP_TAB_CONF(Signal* signal);
  469.   void execDROP_TAB_REQ(Signal* signal);  
  470.   void execDROP_TAB_REF(Signal* signal);  
  471.   void execDROP_TAB_CONF(Signal* signal);
  472.   void execCREATE_TABLE_REQ(Signal* signal);
  473.   void execALTER_TABLE_REQ(Signal* signal);
  474.   void execCREATE_FRAGMENTATION_REF(Signal*);
  475.   void execCREATE_FRAGMENTATION_CONF(Signal*);
  476.   void execCREATE_TAB_REQ(Signal* signal);
  477.   void execADD_FRAGREQ(Signal* signal);
  478.   void execLQHFRAGREF(Signal* signal);
  479.   void execLQHFRAGCONF(Signal* signal);
  480.   void execLQHADDATTREF(Signal* signal);
  481.   void execLQHADDATTCONF(Signal* signal);
  482.   void execCREATE_TAB_REF(Signal* signal);
  483.   void execCREATE_TAB_CONF(Signal* signal);  
  484.   void execALTER_TAB_REQ(Signal* signal);
  485.   void execALTER_TAB_REF(Signal* signal);
  486.   void execALTER_TAB_CONF(Signal* signal);
  487.   bool check_ndb_versions() const;
  488.   /*
  489.    *  2.4 COMMON STORED VARIABLES
  490.    */
  491.   /**
  492.    * This record stores all the state needed 
  493.    * when the schema page is being sent to other nodes
  494.    ***************************************************************************/
  495.   struct SendSchemaRecord {
  496.     /** Number of words of schema data */
  497.     Uint32 noOfWords;
  498.     /** Page Id of schema data */
  499.     Uint32 pageId;
  500.     Uint32 nodeId;
  501.     SignalCounter m_SCHEMAINFO_Counter;
  502.     
  503.     Uint32 noOfWordsCurrentlySent;
  504.     Uint32 noOfSignalsSentSinceDelay;
  505.     bool inUse;
  506.   };
  507.   SendSchemaRecord c_sendSchemaRecord;
  508.   /**
  509.    * This record stores all the state needed 
  510.    * when a table file is being read from disk
  511.    ****************************************************************************/
  512.   struct ReadTableRecord {
  513.     /** Number of Pages */
  514.     Uint32 noOfPages;
  515.     /** Page Id*/
  516.     Uint32 pageId;
  517.     /** Table Id of read table */
  518.     Uint32 tableId;
  519.     
  520.     bool inUse;
  521.     Callback m_callback;
  522.   };
  523.   ReadTableRecord c_readTableRecord;
  524.   /**
  525.    * This record stores all the state needed 
  526.    * when a table file is being written to disk
  527.    ****************************************************************************/
  528.   struct WriteTableRecord {
  529.     /** Number of Pages */
  530.     Uint32 noOfPages;
  531.     /** Page Id*/
  532.     Uint32 pageId;
  533.     /** Table Files Handled, local state variable */
  534.     Uint32 noOfTableFilesHandled;
  535.     /** Table Id of written table */
  536.     Uint32 tableId;
  537.     /** State, indicates from where it was called */
  538.     enum TableWriteState {
  539.       IDLE = 0,
  540.       WRITE_ADD_TABLE_MASTER = 1,
  541.       WRITE_ADD_TABLE_SLAVE = 2,
  542.       WRITE_RESTART_FROM_MASTER = 3,
  543.       WRITE_RESTART_FROM_OWN = 4,
  544.       TWR_CALLBACK = 5
  545.     };
  546.     TableWriteState tableWriteState;
  547.     Callback m_callback;
  548.   };
  549.   WriteTableRecord c_writeTableRecord;
  550.   /**
  551.    * This record stores all the state needed 
  552.    * when a schema file is being read from disk
  553.    ****************************************************************************/
  554.   struct ReadSchemaRecord {
  555.     /** Page Id of schema page */
  556.     Uint32 pageId;
  557.     /** State, indicates from where it was called */
  558.     enum SchemaReadState {
  559.       IDLE = 0,
  560.       INITIAL_READ = 1
  561.     };
  562.     SchemaReadState schemaReadState;
  563.   };
  564.   ReadSchemaRecord c_readSchemaRecord;
  565. private:
  566.   /**
  567.    * This record stores all the state needed 
  568.    * when a schema file is being written to disk
  569.    ****************************************************************************/
  570.   struct WriteSchemaRecord {
  571.     /** Page Id of schema page */
  572.     Uint32 pageId;
  573.     /** Schema Files Handled, local state variable */
  574.     Uint32 noOfSchemaFilesHandled;
  575.     bool inUse;
  576.     Callback m_callback;
  577.   };
  578.   WriteSchemaRecord c_writeSchemaRecord;
  579.   /**
  580.    * This record stores all the information needed 
  581.    * when a file is being read from disk
  582.    ****************************************************************************/
  583.   struct RestartRecord {
  584.     /**    Global check point identity       */
  585.     Uint32 gciToRestart;
  586.     /**    The active table at restart process */
  587.     Uint32 activeTable;
  588.     /**    The active table at restart process */
  589.     BlockReference returnBlockRef;
  590.   };
  591.   RestartRecord c_restartRecord;
  592.   /**
  593.    * This record stores all the information needed 
  594.    * when a file is being read from disk
  595.    ****************************************************************************/
  596.   struct RetrieveRecord {
  597.     RetrieveRecord(){ noOfWaiters = 0;}
  598.     
  599.     /**    Only one retrieve table definition at a time       */
  600.     bool busyState;
  601.     
  602.     /**
  603.      * No of waiting in time queue
  604.      */
  605.     Uint32 noOfWaiters;
  606.     
  607.     /**    Block Reference of retriever       */
  608.     BlockReference blockRef;
  609.     /**    Id of retriever       */
  610.     Uint32 m_senderData;
  611.     /**    Table id of retrieved table       */
  612.     Uint32 tableId;
  613.     /**    Starting page to retrieve data from   */
  614.     Uint32 retrievePage;
  615.     /**    Number of pages retrieved   */
  616.     Uint32 retrievedNoOfPages;
  617.     /**    Number of words retrieved   */
  618.     Uint32 retrievedNoOfWords;
  619.     /**    Number of words sent currently   */
  620.     Uint32 currentSent;
  621.     /**
  622.      * Long signal stuff
  623.      */
  624.     bool m_useLongSig;
  625.   };
  626.   RetrieveRecord c_retrieveRecord;
  627.   /**
  628.    * This record stores all the information needed 
  629.    * when a file is being read from disk
  630.    * 
  631.    * This is the info stored in one entry of the schema
  632.    * page. Each table has 4 words of info.
  633.    * Word 1: Schema version (upper 16 bits)
  634.    *         Table State (lower 16 bits)
  635.    * Word 2: Number of pages of table description
  636.    * Word 3: Global checkpoint id table was created
  637.    * Word 4: Currently zero
  638.    ****************************************************************************/
  639.   struct SchemaRecord {
  640.     /**    Schema page       */
  641.     Uint32 schemaPage;
  642.     /**    Old Schema page (used at node restart)   */
  643.     Uint32 oldSchemaPage;
  644.     
  645.     Callback m_callback;
  646.   };
  647.   SchemaRecord c_schemaRecord;
  648.   void initSchemaFile(SchemaFile *, Uint32 sz);
  649.   void computeChecksum(SchemaFile *);
  650.   bool validateChecksum(const SchemaFile *);
  651.   SchemaFile::TableEntry * getTableEntry(void * buf, Uint32 tableId, 
  652.  bool allowTooBig = false);
  653.   Uint32 computeChecksum(const Uint32 * src, Uint32 len);
  654.   /* ----------------------------------------------------------------------- */
  655.   // Node References
  656.   /* ----------------------------------------------------------------------- */
  657.   Uint16 c_masterNodeId;
  658.   /* ----------------------------------------------------------------------- */
  659.   // Various current system properties
  660.   /* ----------------------------------------------------------------------- */
  661.   Uint16 c_numberNode;
  662.   Uint16 c_noHotSpareNodes;
  663.   Uint16 c_noNodesFailed;
  664.   Uint32 c_failureNr;
  665.   /* ----------------------------------------------------------------------- */
  666.   // State variables
  667.   /* ----------------------------------------------------------------------- */
  668.   
  669.   enum BlockState {
  670.     BS_IDLE = 0,
  671.     BS_CREATE_TAB = 1,
  672.     BS_BUSY = 2,
  673.     BS_NODE_FAILURE = 3
  674.   };
  675.   BlockState c_blockState;
  676.   struct PackTable {
  677.     
  678.     enum PackTableState {
  679.       PTS_IDLE = 0,
  680.       PTS_ADD_TABLE_MASTER = 1,
  681.       PTS_ADD_TABLE_SLAVE = 2,
  682.       PTS_GET_TAB = 3,
  683.       PTS_RESTART = 4
  684.     } m_state;
  685.   } c_packTable;
  686.   Uint32 c_startPhase;
  687.   Uint32 c_restartType;
  688.   bool   c_initialStart;
  689.   bool   c_systemRestart;
  690.   bool   c_nodeRestart;
  691.   bool   c_initialNodeRestart;
  692.   Uint32 c_tabinfoReceived;
  693.   /**
  694.    * Temporary structure used when parsing table info
  695.    */
  696.   struct ParseDictTabInfoRecord {
  697.     DictTabInfo::RequestType requestType;
  698.     Uint32 errorCode;
  699.     Uint32 errorLine;
  700.     
  701.     SimpleProperties::UnpackStatus status;
  702.     Uint32 errorKey;
  703.     TableRecordPtr tablePtr;
  704.   };
  705.   // Operation records
  706.   /**
  707.    * Common part of operation records.  Uses KeyTable2.  Note that each
  708.    * seize/release invokes ctor/dtor automatically.
  709.    */
  710.   struct OpRecordCommon {
  711.     Uint32 key;         // key shared between master and slaves
  712.     Uint32 nextHash;
  713.     Uint32 prevHash;
  714.     Uint32 hashValue() const {
  715.       return key;
  716.     }
  717.     bool equal(const OpRecordCommon& rec) const {
  718.       return key == rec.key;
  719.     }
  720.   };
  721.   /**
  722.    * Create table record
  723.    */
  724.   struct CreateTableRecord : OpRecordCommon {
  725.     Uint32 m_senderRef;
  726.     Uint32 m_senderData;
  727.     Uint32 m_coordinatorRef;
  728.     
  729.     Uint32 m_errorCode;
  730.     void setErrorCode(Uint32 c){ if(m_errorCode == 0) m_errorCode = c;}
  731.     // For alter table
  732.     Uint32 m_changeMask;
  733.     bool m_alterTableFailed;
  734.     AlterTableRef m_alterTableRef;
  735.     Uint32 m_alterTableId;
  736.     /* Previous table name (used for reverting failed table rename) */
  737.     char previousTableName[MAX_TAB_NAME_SIZE];
  738.     Uint32 m_tablePtrI;
  739.     Uint32 m_tabInfoPtrI;
  740.     Uint32 m_fragmentsPtrI;
  741.     Uint32 m_dihAddFragPtr; // Connect ptr towards DIH
  742.     Uint32 m_lqhFragPtr;    // Connect ptr towards LQH
  743.     Callback m_callback;    // Who's using local create tab
  744.     MutexHandle2<DIH_START_LCP_MUTEX> m_startLcpMutex;
  745.     
  746.     struct CoordinatorData {
  747.       Uint32 m_gsn;
  748.       SafeCounterHandle m_counter;
  749.       CreateTabReq::RequestType m_requestType;
  750.     } m_coordinatorData;
  751.   };
  752.   typedef Ptr<CreateTableRecord> CreateTableRecordPtr;
  753.   /**
  754.    * Drop table record
  755.    */
  756.   struct DropTableRecord : OpRecordCommon {
  757.     DropTableReq m_request;
  758.     
  759.     Uint32 m_requestType;
  760.     Uint32 m_coordinatorRef;
  761.     
  762.     Uint32 m_errorCode;
  763.     void setErrorCode(Uint32 c){ if(m_errorCode == 0) m_errorCode = c;}
  764.     MutexHandle2<BACKUP_DEFINE_MUTEX> m_define_backup_mutex;
  765.     
  766.     /**
  767.      * When sending stuff around
  768.      */
  769.     struct CoordinatorData {
  770.       Uint32 m_gsn;
  771.       Uint32 m_block;
  772.       SignalCounter m_signalCounter;
  773.     } m_coordinatorData;
  774.     struct ParticipantData {
  775.       Uint32 m_gsn;
  776.       Uint32 m_block;
  777.       SignalCounter m_signalCounter;
  778.       Callback m_callback;
  779.     } m_participantData;
  780.   };
  781.   typedef Ptr<DropTableRecord> DropTableRecordPtr;
  782.   /**
  783.    * Request flags passed in signals along with request type and
  784.    * propagated across operations.
  785.    */
  786.   struct RequestFlag {
  787.     enum {
  788.       RF_LOCAL = 1 << 0,        // create on local node only
  789.       RF_NOBUILD = 1 << 1,      // no need to build index
  790.       RF_NOTCTRIGGER = 1 << 2,  // alter trigger: no trigger in TC
  791.       RF_FORCE = 1 << 4         // force drop
  792.     };
  793.   };
  794.   /**
  795.    * Operation record for create index.
  796.    */
  797.   struct OpCreateIndex : OpRecordCommon {
  798.     // original request (index id will be added)
  799.     CreateIndxReq m_request;
  800.     AttributeList m_attrList;
  801.     char m_indexName[MAX_TAB_NAME_SIZE];
  802.     bool m_storedIndex;
  803.     // coordinator DICT
  804.     Uint32 m_coordinatorRef;
  805.     bool m_isMaster;
  806.     // state info
  807.     CreateIndxReq::RequestType m_requestType;
  808.     Uint32 m_requestFlag;
  809.     // error info
  810.     CreateIndxRef::ErrorCode m_lastError;
  811.     CreateIndxRef::ErrorCode m_errorCode;
  812.     Uint32 m_errorLine;
  813.     Uint32 m_errorNode;
  814.     // counters
  815.     SignalCounter m_signalCounter;
  816.     // ctor
  817.     OpCreateIndex() {
  818.       memset(&m_request, 0, sizeof(m_request));
  819.       m_coordinatorRef = 0;
  820.       m_requestType = CreateIndxReq::RT_UNDEFINED;
  821.       m_requestFlag = 0;
  822.       m_lastError = CreateIndxRef::NoError;
  823.       m_errorCode = CreateIndxRef::NoError;
  824.       m_errorLine = 0;
  825.       m_errorNode = 0;
  826.     }
  827.     void save(const CreateIndxReq* req) {
  828.       m_request = *req;
  829.       m_requestType = req->getRequestType();
  830.       m_requestFlag = req->getRequestFlag();
  831.     }
  832.     bool hasLastError() {
  833.       return m_lastError != CreateIndxRef::NoError;
  834.     }
  835.     bool hasError() {
  836.       return m_errorCode != CreateIndxRef::NoError;
  837.     }
  838.     void setError(const CreateIndxRef* ref) {
  839.       m_lastError = CreateIndxRef::NoError;
  840.       if (ref != 0) {
  841.         m_lastError = ref->getErrorCode();
  842.         if (! hasError()) {
  843.           m_errorCode = m_lastError;
  844.           m_errorLine = ref->getErrorLine();
  845.           m_errorNode = ref->getErrorNode();
  846.         }
  847.       }
  848.     }
  849.     void setError(const CreateTableRef* ref) {
  850.       m_lastError = CreateIndxRef::NoError;
  851.       if (ref != 0) {
  852.         switch (ref->getErrorCode()) {
  853.         case CreateTableRef::TableAlreadyExist:
  854.           m_lastError = CreateIndxRef::IndexExists;
  855.           break;
  856.         default:
  857.           m_lastError = (CreateIndxRef::ErrorCode)ref->getErrorCode();
  858.           break;
  859.         }
  860.         if (! hasError()) {
  861.           m_errorCode = m_lastError;
  862.           m_errorLine = ref->getErrorLine();
  863.         }
  864.       }
  865.     }
  866.     void setError(const AlterIndxRef* ref) {
  867.       m_lastError = CreateIndxRef::NoError;
  868.       if (ref != 0) {
  869.         m_lastError = (CreateIndxRef::ErrorCode)ref->getErrorCode();
  870.         if (! hasError()) {
  871.           m_errorCode = m_lastError;
  872.           m_errorLine = ref->getErrorLine();
  873.           m_errorNode = ref->getErrorNode();
  874.         }
  875.       }
  876.     }
  877.   };
  878.   typedef Ptr<OpCreateIndex> OpCreateIndexPtr;
  879.   /**
  880.    * Operation record for drop index.
  881.    */
  882.   struct OpDropIndex : OpRecordCommon {
  883.     // original request
  884.     DropIndxReq m_request;
  885.     // coordinator DICT
  886.     Uint32 m_coordinatorRef;
  887.     bool m_isMaster;
  888.     // state info
  889.     DropIndxReq::RequestType m_requestType;
  890.     Uint32 m_requestFlag;
  891.     // error info
  892.     DropIndxRef::ErrorCode m_lastError;
  893.     DropIndxRef::ErrorCode m_errorCode;
  894.     Uint32 m_errorLine;
  895.     Uint32 m_errorNode;
  896.     // counters
  897.     SignalCounter m_signalCounter;
  898.     // ctor
  899.     OpDropIndex() {
  900.       memset(&m_request, 0, sizeof(m_request));
  901.       m_coordinatorRef = 0;
  902.       m_requestType = DropIndxReq::RT_UNDEFINED;
  903.       m_requestFlag = 0;
  904.       m_lastError = DropIndxRef::NoError;
  905.       m_errorCode = DropIndxRef::NoError;
  906.       m_errorLine = 0;
  907.       m_errorNode = 0;
  908.     }
  909.     void save(const DropIndxReq* req) {
  910.       m_request = *req;
  911.       m_requestType = req->getRequestType();
  912.       m_requestFlag = req->getRequestFlag();
  913.     }
  914.     bool hasLastError() {
  915.       return m_lastError != DropIndxRef::NoError;
  916.     }
  917.     bool hasError() {
  918.       return m_errorCode != DropIndxRef::NoError;
  919.     }
  920.     void setError(const DropIndxRef* ref) {
  921.       m_lastError = DropIndxRef::NoError;
  922.       if (ref != 0) {
  923.         m_lastError = ref->getErrorCode();
  924.         if (! hasError()) {
  925.           m_errorCode = ref->getErrorCode();
  926.           m_errorLine = ref->getErrorLine();
  927.           m_errorNode = ref->getErrorNode();
  928.         }
  929.       }
  930.     }
  931.     void setError(const AlterIndxRef* ref) {
  932.       m_lastError = DropIndxRef::NoError;
  933.       if (ref != 0) {
  934.         m_lastError = (DropIndxRef::ErrorCode)ref->getErrorCode();
  935.         if (! hasError()) {
  936.           m_errorCode = m_lastError;
  937.           m_errorLine = ref->getErrorLine();
  938.           m_errorNode = ref->getErrorNode();
  939.         }
  940.       }
  941.     }
  942.     void setError(const DropTableRef* ref) {
  943.       m_lastError = DropIndxRef::NoError;
  944.       if (ref != 0) {
  945. switch (ref->errorCode) {
  946. case DropTableRef::Busy:
  947.   m_lastError = DropIndxRef::Busy;
  948.   break;
  949. case DropTableRef::NoSuchTable:
  950.   m_lastError = DropIndxRef::IndexNotFound;
  951.   break;
  952. case DropTableRef::DropInProgress:
  953.   m_lastError = DropIndxRef::Busy;
  954.   break;
  955. case DropTableRef::NoDropTableRecordAvailable:
  956.   m_lastError = DropIndxRef::Busy;
  957.   break;
  958. default:
  959.   m_lastError = (DropIndxRef::ErrorCode)ref->errorCode;
  960.   break;
  961. }
  962.         if (! hasError()) {
  963.           m_errorCode = m_lastError;
  964.           m_errorLine = 0;
  965.           m_errorNode = 0;
  966.         }
  967.       }
  968.     }
  969.   };
  970.   typedef Ptr<OpDropIndex> OpDropIndexPtr;
  971.   /**
  972.    * Operation record for alter index.
  973.    */
  974.   struct OpAlterIndex : OpRecordCommon {
  975.     // original request plus buffer for attribute lists
  976.     AlterIndxReq m_request;
  977.     AttributeList m_attrList;
  978.     AttributeList m_tableKeyList;
  979.     // coordinator DICT
  980.     Uint32 m_coordinatorRef;
  981.     bool m_isMaster;
  982.     // state info
  983.     AlterIndxReq::RequestType m_requestType;
  984.     Uint32 m_requestFlag;
  985.     // error info
  986.     AlterIndxRef::ErrorCode m_lastError;
  987.     AlterIndxRef::ErrorCode m_errorCode;
  988.     Uint32 m_errorLine;
  989.     Uint32 m_errorNode;
  990.     // counters
  991.     SignalCounter m_signalCounter;
  992.     Uint32 m_triggerCounter;
  993.     // ctor
  994.     OpAlterIndex() {
  995.       memset(&m_request, 0, sizeof(m_request));
  996.       m_coordinatorRef = 0;
  997.       m_requestType = AlterIndxReq::RT_UNDEFINED;
  998.       m_requestFlag = 0;
  999.       m_lastError = AlterIndxRef::NoError;
  1000.       m_errorCode = AlterIndxRef::NoError;
  1001.       m_errorLine = 0;
  1002.       m_errorNode = 0;
  1003.       m_triggerCounter = 0;
  1004.     }
  1005.     void save(const AlterIndxReq* req) {
  1006.       m_request = *req;
  1007.       m_requestType = req->getRequestType();
  1008.       m_requestFlag = req->getRequestFlag();
  1009.     }
  1010.     bool hasLastError() {
  1011.       return m_lastError != AlterIndxRef::NoError;
  1012.     }
  1013.     bool hasError() {
  1014.       return m_errorCode != AlterIndxRef::NoError;
  1015.     }
  1016.     void setError(const AlterIndxRef* ref) {
  1017.       m_lastError = AlterIndxRef::NoError;
  1018.       if (ref != 0) {
  1019.         m_lastError = ref->getErrorCode();
  1020.         if (! hasError()) {
  1021.           m_errorCode = m_lastError;
  1022.           m_errorLine = ref->getErrorLine();
  1023.           m_errorNode = ref->getErrorNode();
  1024.         }
  1025.       }
  1026.     }
  1027.     void setError(const CreateIndxRef* ref) {
  1028.       m_lastError = AlterIndxRef::NoError;
  1029.       if (ref != 0) {
  1030.         m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
  1031.         if (! hasError()) {
  1032.           m_errorCode = m_lastError;
  1033.           m_errorLine = ref->getErrorLine();
  1034.           m_errorNode = ref->getErrorNode();
  1035.         }
  1036.       }
  1037.     }
  1038.     void setError(const DropIndxRef* ref) {
  1039.       m_lastError = AlterIndxRef::NoError;
  1040.       if (ref != 0) {
  1041.         m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
  1042.         if (! hasError()) {
  1043.           m_errorCode = m_lastError;
  1044.           m_errorLine = ref->getErrorLine();
  1045.           m_errorNode = ref->getErrorNode();
  1046.         }
  1047.       }
  1048.     }
  1049.     void setError(const BuildIndxRef* ref) {
  1050.       m_lastError = AlterIndxRef::NoError;
  1051.       if (ref != 0) {
  1052.         m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
  1053.         if (! hasError()) {
  1054.           m_errorCode = m_lastError;
  1055.           m_errorLine = 0;
  1056.           m_errorNode = 0;
  1057.         }
  1058.       }
  1059.     }
  1060.     void setError(const CreateTrigRef* ref) {
  1061.       m_lastError = AlterIndxRef::NoError;
  1062.       if (ref != 0) {
  1063.         m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
  1064.         if (! hasError()) {
  1065.           m_errorCode = m_lastError;
  1066.           m_errorLine = ref->getErrorLine();
  1067.           m_errorNode = ref->getErrorNode();
  1068.         }
  1069.       }
  1070.     }
  1071.     void setError(const DropTrigRef* ref) {
  1072.       m_lastError = AlterIndxRef::NoError;
  1073.       if (ref != 0) {
  1074.         m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
  1075.         if (! hasError()) {
  1076.           m_errorCode = m_lastError;
  1077.           m_errorLine = ref->getErrorLine();
  1078.           m_errorNode = ref->getErrorNode();
  1079.         }
  1080.       }
  1081.     }
  1082.   };
  1083.   typedef Ptr<OpAlterIndex> OpAlterIndexPtr;
  1084.   /**
  1085.    * Operation record for build index.
  1086.    */
  1087.   struct OpBuildIndex : OpRecordCommon {
  1088.     // original request plus buffer for attribute lists
  1089.     BuildIndxReq m_request;
  1090.     AttributeList m_attrList;
  1091.     AttributeList m_tableKeyList;
  1092.     // coordinator DICT
  1093.     Uint32 m_coordinatorRef;
  1094.     bool m_isMaster;
  1095.     // state info
  1096.     BuildIndxReq::RequestType m_requestType;
  1097.     Uint32 m_requestFlag;
  1098.     Uint32 m_constrTriggerId;
  1099.     // error info
  1100.     BuildIndxRef::ErrorCode m_lastError;
  1101.     BuildIndxRef::ErrorCode m_errorCode;
  1102.     Uint32 m_errorLine;
  1103.     Uint32 m_errorNode;
  1104.     // counters
  1105.     SignalCounter m_signalCounter;
  1106.     // ctor
  1107.     OpBuildIndex() {
  1108.       memset(&m_request, 0, sizeof(m_request));
  1109.       m_coordinatorRef = 0;
  1110.       m_requestType = BuildIndxReq::RT_UNDEFINED;
  1111.       m_requestFlag = 0;
  1112.       m_lastError = BuildIndxRef::NoError;
  1113.       m_errorCode = BuildIndxRef::NoError;
  1114.       m_errorLine = 0;
  1115.       m_errorNode = 0;
  1116.     }
  1117.     void save(const BuildIndxReq* req) {
  1118.       m_request = *req;
  1119.       m_requestType = req->getRequestType();
  1120.       m_requestFlag = req->getRequestFlag();
  1121.     }
  1122.     bool hasLastError() {
  1123.       return m_lastError != BuildIndxRef::NoError;
  1124.     }
  1125.     bool hasError() {
  1126.       return m_errorCode != BuildIndxRef::NoError;
  1127.     }
  1128.     void setError(const BuildIndxRef* ref) {
  1129.       m_lastError = BuildIndxRef::NoError;
  1130.       if (ref != 0) {
  1131.         m_lastError = ref->getErrorCode();
  1132.         if (! hasError()) {
  1133.           m_errorCode = m_lastError;
  1134.           m_errorLine = 0;
  1135.           m_errorNode = 0;
  1136.         }
  1137.       }
  1138.     }
  1139.     void setError(const AlterIndxRef* ref) {
  1140.       m_lastError = BuildIndxRef::NoError;
  1141.       if (ref != 0) {
  1142.         m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
  1143.         if (! hasError()) {
  1144.           m_errorCode = m_lastError;
  1145.           m_errorLine = ref->getErrorLine();
  1146.           m_errorNode = ref->getErrorNode();
  1147.         }
  1148.       }
  1149.     }
  1150.     void setError(const CreateTrigRef* ref) {
  1151.       m_lastError = BuildIndxRef::NoError;
  1152.       if (ref != 0) {
  1153.         m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
  1154.         if (! hasError()) {
  1155.           m_errorCode = m_lastError;
  1156.           m_errorLine = ref->getErrorLine();
  1157.           m_errorNode = ref->getErrorNode();
  1158.         }
  1159.       }
  1160.     }
  1161.     void setError(const DropTrigRef* ref) {
  1162.       m_lastError = BuildIndxRef::NoError;
  1163.       if (ref != 0) {
  1164.         m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
  1165.         if (! hasError()) {
  1166.           m_errorCode = m_lastError;
  1167.           m_errorLine = ref->getErrorLine();
  1168.           m_errorNode = ref->getErrorNode();
  1169.         }
  1170.       }
  1171.     }
  1172.   };
  1173.   typedef Ptr<OpBuildIndex> OpBuildIndexPtr;
  1174.   /**
  1175.    * Operation record for Util Signals.
  1176.    */
  1177.   struct OpSignalUtil : OpRecordCommon{
  1178.     Callback m_callback;
  1179.     Uint32 m_userData;
  1180.   };
  1181.   typedef Ptr<OpSignalUtil> OpSignalUtilPtr;
  1182.   /**
  1183.    * Operation record for subscribe-start-stop
  1184.    */
  1185.   struct OpSubEvent : OpRecordCommon {
  1186.     Uint32 m_senderRef;
  1187.     Uint32 m_senderData;
  1188.     Uint32 m_errorCode;
  1189.     RequestTracker m_reqTracker;
  1190.   };
  1191.   typedef Ptr<OpSubEvent> OpSubEventPtr;
  1192.   static const Uint32 sysTab_NDBEVENTS_0_szs[];
  1193.   /**
  1194.    * Operation record for create event.
  1195.    */
  1196.   struct OpCreateEvent : OpRecordCommon {
  1197.     // original request (event id will be added)
  1198.     CreateEvntReq m_request;
  1199.     //AttributeMask m_attrListBitmask;
  1200.     //    AttributeList m_attrList;
  1201.     sysTab_NDBEVENTS_0 m_eventRec;
  1202.     //    char m_eventName[MAX_TAB_NAME_SIZE];
  1203.     //    char m_tableName[MAX_TAB_NAME_SIZE];
  1204.     // coordinator DICT
  1205.     RequestTracker m_reqTracker;
  1206.     // state info
  1207.     CreateEvntReq::RequestType m_requestType;
  1208.     Uint32 m_requestFlag;
  1209.     // error info
  1210.     CreateEvntRef::ErrorCode m_errorCode;
  1211.     Uint32 m_errorLine;
  1212.     Uint32 m_errorNode;
  1213.     // ctor
  1214.     OpCreateEvent() {
  1215.       memset(&m_request, 0, sizeof(m_request));
  1216.       m_requestType = CreateEvntReq::RT_UNDEFINED;
  1217.       m_requestFlag = 0;
  1218.       m_errorCode = CreateEvntRef::NoError;
  1219.       m_errorLine = 0;
  1220.       m_errorNode = 0;
  1221.     }
  1222.     void init(const CreateEvntReq* req, Dbdict* dp) {
  1223.       m_request = *req;
  1224.       m_errorCode = CreateEvntRef::NoError;
  1225.       m_errorLine = 0;
  1226.       m_errorNode = 0;
  1227.       m_requestType = req->getRequestType();
  1228.       m_requestFlag = req->getRequestFlag();
  1229.     }
  1230.     bool hasError() {
  1231.       return m_errorCode != CreateEvntRef::NoError;
  1232.     }
  1233.     void setError(const CreateEvntRef* ref) {
  1234.       if (ref != 0 && ! hasError()) {
  1235.         m_errorCode = ref->getErrorCode();
  1236.         m_errorLine = ref->getErrorLine();
  1237.         m_errorNode = ref->getErrorNode();
  1238.       }
  1239.     }
  1240.   };
  1241.   typedef Ptr<OpCreateEvent> OpCreateEventPtr;
  1242.   /**
  1243.    * Operation record for drop event.
  1244.    */
  1245.   struct OpDropEvent : OpRecordCommon {
  1246.     // original request
  1247.     DropEvntReq m_request;
  1248.     //    char m_eventName[MAX_TAB_NAME_SIZE];
  1249.     sysTab_NDBEVENTS_0 m_eventRec;
  1250.     RequestTracker m_reqTracker;
  1251.     // error info
  1252.     DropEvntRef::ErrorCode m_errorCode;
  1253.     Uint32 m_errorLine;
  1254.     Uint32 m_errorNode;
  1255.     // ctor
  1256.     OpDropEvent() {
  1257.       memset(&m_request, 0, sizeof(m_request));
  1258.       m_errorCode = DropEvntRef::NoError;
  1259.       m_errorLine = 0;
  1260.       m_errorNode = 0;
  1261.     }
  1262.     void init(const DropEvntReq* req) {
  1263.       m_request = *req;
  1264.       m_errorCode = DropEvntRef::NoError;
  1265.       m_errorLine = 0;
  1266.       m_errorNode = 0;
  1267.     }
  1268.     bool hasError() {
  1269.       return m_errorCode != DropEvntRef::NoError;
  1270.     }
  1271.     void setError(const DropEvntRef* ref) {
  1272.       if (ref != 0 && ! hasError()) {
  1273.         m_errorCode = ref->getErrorCode();
  1274.         m_errorLine = ref->getErrorLine();
  1275.         m_errorNode = ref->getErrorNode();
  1276.       }
  1277.     }
  1278.   };
  1279.   typedef Ptr<OpDropEvent> OpDropEventPtr;
  1280.   /**
  1281.    * Operation record for create trigger.
  1282.    */
  1283.   struct OpCreateTrigger : OpRecordCommon {
  1284.     // original request (trigger id will be added)
  1285.     CreateTrigReq m_request;
  1286.     char m_triggerName[MAX_TAB_NAME_SIZE];
  1287.     // coordinator DICT
  1288.     Uint32 m_coordinatorRef;
  1289.     bool m_isMaster;
  1290.     // state info
  1291.     CreateTrigReq::RequestType m_requestType;
  1292.     Uint32 m_requestFlag;
  1293.     // error info
  1294.     CreateTrigRef::ErrorCode m_lastError;
  1295.     CreateTrigRef::ErrorCode m_errorCode;
  1296.     Uint32 m_errorLine;
  1297.     Uint32 m_errorNode;
  1298.     // counters
  1299.     SignalCounter m_signalCounter;
  1300.     // ctor
  1301.     OpCreateTrigger() {
  1302.       memset(&m_request, 0, sizeof(m_request));
  1303.       m_coordinatorRef = 0;
  1304.       m_requestType = CreateTrigReq::RT_UNDEFINED;
  1305.       m_requestFlag = 0;
  1306.       m_lastError = CreateTrigRef::NoError;
  1307.       m_errorCode = CreateTrigRef::NoError;
  1308.       m_errorLine = 0;
  1309.       m_errorNode = 0;
  1310.     }
  1311.     void save(const CreateTrigReq* req) {
  1312.       m_request = *req;
  1313.       m_requestType = req->getRequestType();
  1314.       m_requestFlag = req->getRequestFlag();
  1315.     }
  1316.     bool hasLastError() {
  1317.       return m_lastError != CreateTrigRef::NoError;
  1318.     }
  1319.     bool hasError() {
  1320.       return m_errorCode != CreateTrigRef::NoError;
  1321.     }
  1322.     void setError(const CreateTrigRef* ref) {
  1323.       m_lastError = CreateTrigRef::NoError;
  1324.       if (ref != 0) {
  1325.         m_lastError = ref->getErrorCode();
  1326.         if (! hasError()) {
  1327.           m_errorCode = m_lastError;
  1328.           m_errorLine = ref->getErrorLine();
  1329.           m_errorNode = ref->getErrorNode();
  1330.         }
  1331.       }
  1332.     }
  1333.     void setError(const AlterTrigRef* ref) {
  1334.       m_lastError = CreateTrigRef::NoError;
  1335.       if (ref != 0) {
  1336.         m_lastError = (CreateTrigRef::ErrorCode)ref->getErrorCode();
  1337.         if (! hasError()) {
  1338.           m_errorCode = m_lastError;
  1339.           m_errorLine = ref->getErrorLine();
  1340.           m_errorNode = ref->getErrorNode();
  1341.         }
  1342.       }
  1343.     }
  1344.   };
  1345.   typedef Ptr<OpCreateTrigger> OpCreateTriggerPtr;
  1346.   /**
  1347.    * Operation record for drop trigger.
  1348.    */
  1349.   struct OpDropTrigger : OpRecordCommon {
  1350.     // original request
  1351.     DropTrigReq m_request;
  1352.     // coordinator DICT
  1353.     Uint32 m_coordinatorRef;
  1354.     bool m_isMaster;
  1355.     // state info
  1356.     DropTrigReq::RequestType m_requestType;
  1357.     Uint32 m_requestFlag;
  1358.     // error info
  1359.     DropTrigRef::ErrorCode m_lastError;
  1360.     DropTrigRef::ErrorCode m_errorCode;
  1361.     Uint32 m_errorLine;
  1362.     Uint32 m_errorNode;
  1363.     // counters
  1364.     SignalCounter m_signalCounter;
  1365.     // ctor
  1366.     OpDropTrigger() {
  1367.       memset(&m_request, 0, sizeof(m_request));
  1368.       m_coordinatorRef = 0;
  1369.       m_requestType = DropTrigReq::RT_UNDEFINED;
  1370.       m_requestFlag = 0;
  1371.       m_lastError = DropTrigRef::NoError;
  1372.       m_errorCode = DropTrigRef::NoError;
  1373.       m_errorLine = 0;
  1374.       m_errorNode = 0;
  1375.     }
  1376.     void save(const DropTrigReq* req) {
  1377.       m_request = *req;
  1378.       m_requestType = req->getRequestType();
  1379.       m_requestFlag = req->getRequestFlag();
  1380.     }
  1381.     bool hasLastError() {
  1382.       return m_lastError != DropTrigRef::NoError;
  1383.     }
  1384.     bool hasError() {
  1385.       return m_errorCode != DropTrigRef::NoError;
  1386.     }
  1387.     void setError(const DropTrigRef* ref) {
  1388.       m_lastError = DropTrigRef::NoError;
  1389.       if (ref != 0) {
  1390.         m_lastError = ref->getErrorCode();
  1391.         if (! hasError()) {
  1392.           m_errorCode = m_lastError;
  1393.           m_errorLine = ref->getErrorLine();
  1394.           m_errorNode = ref->getErrorNode();
  1395.         }
  1396.       }
  1397.     }
  1398.     void setError(const AlterTrigRef* ref) {
  1399.       m_lastError = DropTrigRef::NoError;
  1400.       if (ref != 0) {
  1401.         m_lastError = (DropTrigRef::ErrorCode)ref->getErrorCode();
  1402.         if (! hasError()) {
  1403.           m_errorCode = m_lastError;
  1404.           m_errorLine = ref->getErrorLine();
  1405.           m_errorNode = ref->getErrorNode();
  1406.         }
  1407.       }
  1408.     }
  1409.   };
  1410.   typedef Ptr<OpDropTrigger> OpDropTriggerPtr;
  1411.   /**
  1412.    * Operation record for alter trigger.
  1413.    */
  1414.   struct OpAlterTrigger : OpRecordCommon {
  1415.     // original request
  1416.     AlterTrigReq m_request;
  1417.     // nodes participating in operation
  1418.     NdbNodeBitmask m_nodes;
  1419.     // coordinator DICT
  1420.     Uint32 m_coordinatorRef;
  1421.     bool m_isMaster;
  1422.     // state info
  1423.     AlterTrigReq::RequestType m_requestType;
  1424.     Uint32 m_requestFlag;
  1425.     // error info
  1426.     AlterTrigRef::ErrorCode m_lastError;
  1427.     AlterTrigRef::ErrorCode m_errorCode;
  1428.     Uint32 m_errorLine;
  1429.     Uint32 m_errorNode;
  1430.     // counters
  1431.     SignalCounter m_signalCounter;
  1432.     // ctor
  1433.     OpAlterTrigger() {
  1434.       memset(&m_request, 0, sizeof(m_request));
  1435.       m_coordinatorRef = 0;
  1436.       m_requestType = AlterTrigReq::RT_UNDEFINED;
  1437.       m_requestFlag = 0;
  1438.       m_lastError = AlterTrigRef::NoError;
  1439.       m_errorCode = AlterTrigRef::NoError;
  1440.       m_errorLine = 0;
  1441.       m_errorNode = 0;
  1442.     }
  1443.     void save(const AlterTrigReq* req) {
  1444.       m_request = *req;
  1445.       m_requestType = req->getRequestType();
  1446.       m_requestFlag = req->getRequestFlag();
  1447.     }
  1448.     bool hasLastError() {
  1449.       return m_lastError != AlterTrigRef::NoError;
  1450.     }
  1451.     bool hasError() {
  1452.       return m_errorCode != AlterTrigRef::NoError;
  1453.     }
  1454.     void setError(const AlterTrigRef* ref) {
  1455.       m_lastError = AlterTrigRef::NoError;
  1456.       if (ref != 0) {
  1457.         m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
  1458.         if (! hasError()) {
  1459.           m_errorCode = m_lastError;
  1460.           m_errorLine = ref->getErrorLine();
  1461.           m_errorNode = ref->getErrorNode();
  1462.         }
  1463.       }
  1464.     }
  1465.     void setError(const CreateTrigRef* ref) {
  1466.       m_lastError = AlterTrigRef::NoError;
  1467.       if (ref != 0) {
  1468.         m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
  1469.         if (! hasError()) {
  1470.           m_errorCode = m_lastError;
  1471.           m_errorLine = ref->getErrorLine();
  1472.           m_errorNode = ref->getErrorNode();
  1473.         }
  1474.       }
  1475.     }
  1476.     void setError(const DropTrigRef* ref) {
  1477.       m_lastError = AlterTrigRef::NoError;
  1478.       if (ref != 0) {
  1479.         m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
  1480.         if (! hasError()) {
  1481.           m_errorCode = m_lastError;
  1482.           m_errorLine = ref->getErrorLine();
  1483.           m_errorNode = ref->getErrorNode();
  1484.         }
  1485.       }
  1486.     }
  1487.   };
  1488.   typedef Ptr<OpAlterTrigger> OpAlterTriggerPtr;
  1489.   // Common operation record pool
  1490. public:
  1491.   STATIC_CONST( opCreateTableSize = sizeof(CreateTableRecord) );
  1492.   STATIC_CONST( opDropTableSize = sizeof(DropTableRecord) );
  1493.   STATIC_CONST( opCreateIndexSize = sizeof(OpCreateIndex) );
  1494.   STATIC_CONST( opDropIndexSize = sizeof(OpDropIndex) );
  1495.   STATIC_CONST( opAlterIndexSize = sizeof(OpAlterIndex) );
  1496.   STATIC_CONST( opBuildIndexSize = sizeof(OpBuildIndex) );
  1497.   STATIC_CONST( opCreateEventSize = sizeof(OpCreateEvent) );
  1498.   STATIC_CONST( opSubEventSize = sizeof(OpSubEvent) );
  1499.   STATIC_CONST( opDropEventSize = sizeof(OpDropEvent) );
  1500.   STATIC_CONST( opSignalUtilSize = sizeof(OpSignalUtil) );
  1501.   STATIC_CONST( opCreateTriggerSize = sizeof(OpCreateTrigger) );
  1502.   STATIC_CONST( opDropTriggerSize = sizeof(OpDropTrigger) );
  1503.   STATIC_CONST( opAlterTriggerSize = sizeof(OpAlterTrigger) );
  1504. private:
  1505. #define PTR_ALIGN(n) ((((n)+sizeof(void*)-1)>>2)&~((sizeof(void*)-1)>>2))
  1506.   union OpRecordUnion {
  1507.     Uint32 u_opCreateTable  [PTR_ALIGN(opCreateTableSize)];
  1508.     Uint32 u_opDropTable    [PTR_ALIGN(opDropTableSize)];
  1509.     Uint32 u_opCreateIndex  [PTR_ALIGN(opCreateIndexSize)];
  1510.     Uint32 u_opDropIndex    [PTR_ALIGN(opDropIndexSize)];
  1511.     Uint32 u_opCreateEvent  [PTR_ALIGN(opCreateEventSize)];
  1512.     Uint32 u_opSubEvent     [PTR_ALIGN(opSubEventSize)];
  1513.     Uint32 u_opDropEvent    [PTR_ALIGN(opDropEventSize)];
  1514.     Uint32 u_opSignalUtil   [PTR_ALIGN(opSignalUtilSize)];
  1515.     Uint32 u_opAlterIndex   [PTR_ALIGN(opAlterIndexSize)];
  1516.     Uint32 u_opBuildIndex   [PTR_ALIGN(opBuildIndexSize)];
  1517.     Uint32 u_opCreateTrigger[PTR_ALIGN(opCreateTriggerSize)];
  1518.     Uint32 u_opDropTrigger  [PTR_ALIGN(opDropTriggerSize)];
  1519.     Uint32 u_opAlterTrigger [PTR_ALIGN(opAlterTriggerSize)];
  1520.     Uint32 nextPool;
  1521.   };
  1522.   ArrayPool<OpRecordUnion> c_opRecordPool;
  1523.   
  1524.   // Operation records
  1525.   KeyTable2<CreateTableRecord, OpRecordUnion> c_opCreateTable;
  1526.   KeyTable2<DropTableRecord, OpRecordUnion> c_opDropTable;
  1527.   KeyTable2<OpCreateIndex, OpRecordUnion> c_opCreateIndex;
  1528.   KeyTable2<OpDropIndex, OpRecordUnion> c_opDropIndex;
  1529.   KeyTable2<OpAlterIndex, OpRecordUnion> c_opAlterIndex;
  1530.   KeyTable2<OpBuildIndex, OpRecordUnion> c_opBuildIndex;
  1531.   KeyTable2<OpCreateEvent, OpRecordUnion> c_opCreateEvent;
  1532.   KeyTable2<OpSubEvent, OpRecordUnion> c_opSubEvent;
  1533.   KeyTable2<OpDropEvent, OpRecordUnion> c_opDropEvent;
  1534.   KeyTable2<OpSignalUtil, OpRecordUnion> c_opSignalUtil;
  1535.   KeyTable2<OpCreateTrigger, OpRecordUnion> c_opCreateTrigger;
  1536.   KeyTable2<OpDropTrigger, OpRecordUnion> c_opDropTrigger;
  1537.   KeyTable2<OpAlterTrigger, OpRecordUnion> c_opAlterTrigger;
  1538.   // Unique key for operation  XXX move to some system table
  1539.   Uint32 c_opRecordSequence;
  1540.   // Statement blocks
  1541.   /* ------------------------------------------------------------ */
  1542.   // Start/Restart Handling
  1543.   /* ------------------------------------------------------------ */
  1544.   void sendSTTORRY(Signal* signal);
  1545.   void sendNDB_STTORRY(Signal* signal);
  1546.   void initSchemaFile(Signal* signal);
  1547.   
  1548.   /* ------------------------------------------------------------ */
  1549.   // Drop Table Handling
  1550.   /* ------------------------------------------------------------ */
  1551.   void releaseTableObject(Uint32 tableId, bool removeFromHash = true);
  1552.   
  1553.   /* ------------------------------------------------------------ */
  1554.   // General Stuff
  1555.   /* ------------------------------------------------------------ */
  1556.   Uint32 getFreeTableRecord(Uint32 primaryTableId);
  1557.   Uint32 getFreeTriggerRecord();
  1558.   bool getNewAttributeRecord(TableRecordPtr tablePtr,
  1559.      AttributeRecordPtr & attrPtr);
  1560.   void packTableIntoPages(Signal* signal, Uint32 tableId, Uint32 pageId);
  1561.   void packTableIntoPagesImpl(SimpleProperties::Writer &, TableRecordPtr);
  1562.   
  1563.   void sendGET_TABINFOREQ(Signal* signal,
  1564.                           Uint32 tableId);
  1565.   void sendTC_SCHVERREQ(Signal* signal,
  1566.                         Uint32 tableId,
  1567.                         BlockReference tcRef);
  1568.   
  1569.   /* ------------------------------------------------------------ */
  1570.   // System Restart Handling
  1571.   /* ------------------------------------------------------------ */
  1572.   void initSendSchemaData(Signal* signal);
  1573.   void sendSchemaData(Signal* signal);
  1574.   Uint32 sendSCHEMA_INFO(Signal* signal, Uint32 nodeId, Uint32* pagePointer);
  1575.   void checkSchemaStatus(Signal* signal);
  1576.   void sendDIHSTARTTAB_REQ(Signal* signal);
  1577.   
  1578.   /* ------------------------------------------------------------ */
  1579.   // Receive Table Handling
  1580.   /* ------------------------------------------------------------ */
  1581.   void handleTabInfoInit(SimpleProperties::Reader &, 
  1582.  ParseDictTabInfoRecord *,
  1583.  bool checkExist = true);
  1584.   void handleTabInfo(SimpleProperties::Reader & it, ParseDictTabInfoRecord *);
  1585.   
  1586.   void handleAddTableFailure(Signal* signal,
  1587.                              Uint32 failureLine,
  1588.                              Uint32 tableId);
  1589.   bool verifyTableCorrect(Signal* signal, Uint32 tableId);
  1590.   
  1591.   /* ------------------------------------------------------------ */
  1592.   // Add Table Handling
  1593.   /* ------------------------------------------------------------ */
  1594.   /* ------------------------------------------------------------ */
  1595.   // Add Fragment Handling
  1596.   /* ------------------------------------------------------------ */
  1597.   void sendLQHADDATTRREQ(Signal*, CreateTableRecordPtr, Uint32 attributePtrI);
  1598.   
  1599.   /* ------------------------------------------------------------ */
  1600.   // Read/Write Schema and Table files
  1601.   /* ------------------------------------------------------------ */
  1602.   void updateSchemaState(Signal* signal, Uint32 tableId, 
  1603.  SchemaFile::TableEntry*, Callback*);
  1604.   void startWriteSchemaFile(Signal* signal);
  1605.   void openSchemaFile(Signal* signal,
  1606.                       Uint32 fileNo,
  1607.                       Uint32 fsPtr,
  1608.                       bool writeFlag);
  1609.   void writeSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr);
  1610.   void writeSchemaConf(Signal* signal,
  1611.                                FsConnectRecordPtr fsPtr);
  1612.   void closeFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr);
  1613.   void closeWriteSchemaConf(Signal* signal,
  1614.                                FsConnectRecordPtr fsPtr);
  1615.   void initSchemaFile_conf(Signal* signal, Uint32 i, Uint32 returnCode);
  1616.   
  1617.   void writeTableFile(Signal* signal, Uint32 tableId, 
  1618.       SegmentedSectionPtr tabInfo, Callback*);
  1619.   void startWriteTableFile(Signal* signal, Uint32 tableId);
  1620.   void openTableFile(Signal* signal, 
  1621.                      Uint32 fileNo,
  1622.                      Uint32 fsPtr,
  1623.                      Uint32 tableId,
  1624.                      bool writeFlag);
  1625.   void writeTableFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr);
  1626.   void writeTableConf(Signal* signal,
  1627.                       FsConnectRecordPtr fsPtr);
  1628.   void closeWriteTableConf(Signal* signal,
  1629.                            FsConnectRecordPtr fsPtr);
  1630.   void startReadTableFile(Signal* signal, Uint32 tableId);
  1631.   void openReadTableRef(Signal* signal,
  1632.                         FsConnectRecordPtr fsPtr);
  1633.   void readTableFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr);
  1634.   void readTableConf(Signal* signal,
  1635.                      FsConnectRecordPtr fsPtr);
  1636.   void readTableRef(Signal* signal,
  1637.                     FsConnectRecordPtr fsPtr);
  1638.   void closeReadTableConf(Signal* signal,
  1639.                           FsConnectRecordPtr fsPtr);
  1640.   void startReadSchemaFile(Signal* signal);
  1641.   void openReadSchemaRef(Signal* signal,
  1642.                          FsConnectRecordPtr fsPtr);
  1643.   void readSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr);
  1644.   void readSchemaConf(Signal* signal, FsConnectRecordPtr fsPtr);
  1645.   void readSchemaRef(Signal* signal, FsConnectRecordPtr fsPtr);
  1646.   void closeReadSchemaConf(Signal* signal,
  1647.                            FsConnectRecordPtr fsPtr);
  1648.   /* ------------------------------------------------------------ */
  1649.   // Get table definitions
  1650.   /* ------------------------------------------------------------ */
  1651.   void sendGET_TABINFOREF(Signal* signal, 
  1652.   GetTabInfoReq*,
  1653.   GetTabInfoRef::ErrorCode errorCode);
  1654.   void sendGET_TABLEID_REF(Signal* signal, 
  1655.    GetTableIdReq * req,
  1656.    GetTableIdRef::ErrorCode errorCode);
  1657.   void sendGetTabResponse(Signal* signal);
  1658.   /* ------------------------------------------------------------ */
  1659.   // Indexes and triggers
  1660.   /* ------------------------------------------------------------ */
  1661.   // reactivate and rebuild indexes on start up
  1662.   void activateIndexes(Signal* signal, Uint32 i);
  1663.   void rebuildIndexes(Signal* signal, Uint32 i);
  1664.   // create index
  1665.   void createIndex_recvReply(Signal* signal, const CreateIndxConf* conf,
  1666.       const CreateIndxRef* ref);
  1667.   void createIndex_slavePrepare(Signal* signal, OpCreateIndexPtr opPtr);
  1668.   void createIndex_toCreateTable(Signal* signal, OpCreateIndexPtr opPtr);
  1669.   void createIndex_fromCreateTable(Signal* signal, OpCreateIndexPtr opPtr);
  1670.   void createIndex_toAlterIndex(Signal* signal, OpCreateIndexPtr opPtr);
  1671.   void createIndex_fromAlterIndex(Signal* signal, OpCreateIndexPtr opPtr);
  1672.   void createIndex_slaveCommit(Signal* signal, OpCreateIndexPtr opPtr);
  1673.   void createIndex_slaveAbort(Signal* signal, OpCreateIndexPtr opPtr);
  1674.   void createIndex_sendSlaveReq(Signal* signal, OpCreateIndexPtr opPtr);
  1675.   void createIndex_sendReply(Signal* signal, OpCreateIndexPtr opPtr, bool);
  1676.   // drop index
  1677.   void dropIndex_recvReply(Signal* signal, const DropIndxConf* conf,
  1678.       const DropIndxRef* ref);
  1679.   void dropIndex_slavePrepare(Signal* signal, OpDropIndexPtr opPtr);
  1680.   void dropIndex_toAlterIndex(Signal* signal, OpDropIndexPtr opPtr);
  1681.   void dropIndex_fromAlterIndex(Signal* signal, OpDropIndexPtr opPtr);
  1682.   void dropIndex_toDropTable(Signal* signal, OpDropIndexPtr opPtr);
  1683.   void dropIndex_fromDropTable(Signal* signal, OpDropIndexPtr opPtr);
  1684.   void dropIndex_slaveCommit(Signal* signal, OpDropIndexPtr opPtr);
  1685.   void dropIndex_slaveAbort(Signal* signal, OpDropIndexPtr opPtr);
  1686.   void dropIndex_sendSlaveReq(Signal* signal, OpDropIndexPtr opPtr);
  1687.   void dropIndex_sendReply(Signal* signal, OpDropIndexPtr opPtr, bool);
  1688.   // alter index
  1689.   void alterIndex_recvReply(Signal* signal, const AlterIndxConf* conf,
  1690.       const AlterIndxRef* ref);
  1691.   void alterIndex_slavePrepare(Signal* signal, OpAlterIndexPtr opPtr);
  1692.   void alterIndex_toCreateTc(Signal* signal, OpAlterIndexPtr opPtr);
  1693.   void alterIndex_fromCreateTc(Signal* signal, OpAlterIndexPtr opPtr);
  1694.   void alterIndex_toDropTc(Signal* signal, OpAlterIndexPtr opPtr);
  1695.   void alterIndex_fromDropTc(Signal* signal, OpAlterIndexPtr opPtr);
  1696.   void alterIndex_toCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr);
  1697.   void alterIndex_fromCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr);
  1698.   void alterIndex_toDropTrigger(Signal* signal, OpAlterIndexPtr opPtr);
  1699.   void alterIndex_fromDropTrigger(Signal* signal, OpAlterIndexPtr opPtr);
  1700.   void alterIndex_toBuildIndex(Signal* signal, OpAlterIndexPtr opPtr);
  1701.   void alterIndex_fromBuildIndex(Signal* signal, OpAlterIndexPtr opPtr);
  1702.   void alterIndex_slaveCommit(Signal* signal, OpAlterIndexPtr opPtr);
  1703.   void alterIndex_slaveAbort(Signal* signal, OpAlterIndexPtr opPtr);
  1704.   void alterIndex_sendSlaveReq(Signal* signal, OpAlterIndexPtr opPtr);
  1705.   void alterIndex_sendReply(Signal* signal, OpAlterIndexPtr opPtr, bool);
  1706.   // build index
  1707.   void buildIndex_recvReply(Signal* signal, const BuildIndxConf* conf,
  1708.       const BuildIndxRef* ref);
  1709.   void buildIndex_toCreateConstr(Signal* signal, OpBuildIndexPtr opPtr);
  1710.   void buildIndex_fromCreateConstr(Signal* signal, OpBuildIndexPtr opPtr);
  1711.   void buildIndex_buildTrix(Signal* signal, OpBuildIndexPtr opPtr);
  1712.   void buildIndex_toDropConstr(Signal* signal, OpBuildIndexPtr opPtr);
  1713.   void buildIndex_fromDropConstr(Signal* signal, OpBuildIndexPtr opPtr);
  1714.   void buildIndex_toOnline(Signal* signal, OpBuildIndexPtr opPtr);
  1715.   void buildIndex_fromOnline(Signal* signal, OpBuildIndexPtr opPtr);
  1716.   void buildIndex_sendSlaveReq(Signal* signal, OpBuildIndexPtr opPtr);
  1717.   void buildIndex_sendReply(Signal* signal, OpBuildIndexPtr opPtr, bool);
  1718.   // Events
  1719.   void 
  1720.   createEventUTIL_PREPARE(Signal* signal,
  1721.   Uint32 callbackData,
  1722.   Uint32 returnCode);
  1723.   void 
  1724.   createEventUTIL_EXECUTE(Signal *signal, 
  1725.   Uint32 callbackData,
  1726.   Uint32 returnCode);
  1727.   void 
  1728.   dropEventUTIL_PREPARE_READ(Signal* signal,
  1729.      Uint32 callbackData,
  1730.      Uint32 returnCode);
  1731.   void 
  1732.   dropEventUTIL_EXECUTE_READ(Signal* signal,
  1733.      Uint32 callbackData,
  1734.      Uint32 returnCode);
  1735.   void
  1736.   dropEventUTIL_PREPARE_DELETE(Signal* signal,
  1737.        Uint32 callbackData,
  1738.        Uint32 returnCode);
  1739.   void 
  1740.   dropEventUTIL_EXECUTE_DELETE(Signal *signal, 
  1741.        Uint32 callbackData,
  1742.        Uint32 returnCode);
  1743.   void
  1744.   dropEventUtilPrepareRef(Signal* signal,
  1745.   Uint32 callbackData,
  1746.   Uint32 returnCode);
  1747.   void
  1748.   dropEventUtilExecuteRef(Signal* signal,
  1749.   Uint32 callbackData,
  1750.   Uint32 returnCode);
  1751.   int
  1752.   sendSignalUtilReq(Callback *c,
  1753.     BlockReference ref, 
  1754.     GlobalSignalNumber gsn, 
  1755.     Signal* signal, 
  1756.     Uint32 length, 
  1757.     JobBufferLevel jbuf,
  1758.     LinearSectionPtr ptr[3],
  1759.     Uint32 noOfSections);
  1760.   int
  1761.   recvSignalUtilReq(Signal* signal, Uint32 returnCode);
  1762.   void completeSubStartReq(Signal* signal, Uint32 ptrI, Uint32 returnCode);
  1763.   void completeSubStopReq(Signal* signal, Uint32 ptrI, Uint32 returnCode);
  1764.   void completeSubRemoveReq(Signal* signal, Uint32 ptrI, Uint32 returnCode);
  1765.   
  1766.   void dropEvent_sendReply(Signal* signal,
  1767.    OpDropEventPtr evntRecPtr);
  1768.   void createEvent_RT_USER_CREATE(Signal* signal, OpCreateEventPtr evntRecPtr);
  1769.   void createEventComplete_RT_USER_CREATE(Signal* signal,
  1770.   OpCreateEventPtr evntRecPtr);
  1771.   void createEvent_RT_USER_GET(Signal* signal, OpCreateEventPtr evntRecPtr);
  1772.   void createEventComplete_RT_USER_GET(Signal* signal, OpCreateEventPtr evntRecPtr);
  1773.   void createEvent_RT_DICT_AFTER_GET(Signal* signal, OpCreateEventPtr evntRecPtr);
  1774.   void createEvent_nodeFailCallback(Signal* signal, Uint32 eventRecPtrI,
  1775.     Uint32 returnCode);
  1776.   void createEvent_sendReply(Signal* signal, OpCreateEventPtr evntRecPtr,
  1777.      LinearSectionPtr *ptr = NULL, int noLSP = 0);
  1778.   void prepareTransactionEventSysTable (Callback *c,
  1779. Signal* signal,
  1780. Uint32 senderData,
  1781. UtilPrepareReq::OperationTypeValue prepReq);
  1782.   void prepareUtilTransaction(Callback *c,
  1783.       Signal* signal,
  1784.       Uint32 senderData,
  1785.       Uint32 tableId,
  1786.       const char *tableName,
  1787.       UtilPrepareReq::OperationTypeValue prepReq,
  1788.       Uint32 noAttr,
  1789.       Uint32 attrIds[],
  1790.       const char *attrNames[]);
  1791.   void executeTransEventSysTable(Callback *c,
  1792.  Signal *signal,
  1793.  const Uint32 ptrI,
  1794.  sysTab_NDBEVENTS_0& m_eventRec,
  1795.  const Uint32 prepareId,
  1796.  UtilPrepareReq::OperationTypeValue prepReq);
  1797.   void executeTransaction(Callback *c,
  1798.   Signal* signal, 
  1799.   Uint32 senderData,
  1800.   Uint32 prepareId,
  1801.   Uint32 noAttr,
  1802.   LinearSectionPtr headerPtr,
  1803.   LinearSectionPtr dataPtr);
  1804.   void parseReadEventSys(Signal *signal, sysTab_NDBEVENTS_0& m_eventRec);
  1805.   // create trigger
  1806.   void createTrigger_recvReply(Signal* signal, const CreateTrigConf* conf,
  1807.       const CreateTrigRef* ref);
  1808.   void createTrigger_slavePrepare(Signal* signal, OpCreateTriggerPtr opPtr);
  1809.   void createTrigger_masterSeize(Signal* signal, OpCreateTriggerPtr opPtr);
  1810.   void createTrigger_slaveCreate(Signal* signal, OpCreateTriggerPtr opPtr);
  1811.   void createTrigger_toAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr);
  1812.   void createTrigger_fromAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr);
  1813.   void createTrigger_slaveCommit(Signal* signal, OpCreateTriggerPtr opPtr);
  1814.   void createTrigger_slaveAbort(Signal* signal, OpCreateTriggerPtr opPtr);
  1815.   void createTrigger_sendSlaveReq(Signal* signal, OpCreateTriggerPtr opPtr);
  1816.   void createTrigger_sendReply(Signal* signal, OpCreateTriggerPtr opPtr, bool);
  1817.   // drop trigger
  1818.   void dropTrigger_recvReply(Signal* signal, const DropTrigConf* conf,
  1819.       const DropTrigRef* ref);
  1820.   void dropTrigger_slavePrepare(Signal* signal, OpDropTriggerPtr opPtr);
  1821.   void dropTrigger_toAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr);
  1822.   void dropTrigger_fromAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr);
  1823.   void dropTrigger_slaveCommit(Signal* signal, OpDropTriggerPtr opPtr);
  1824.   void dropTrigger_slaveAbort(Signal* signal, OpDropTriggerPtr opPtr);
  1825.   void dropTrigger_sendSlaveReq(Signal* signal, OpDropTriggerPtr opPtr);
  1826.   void dropTrigger_sendReply(Signal* signal, OpDropTriggerPtr opPtr, bool);
  1827.   // alter trigger
  1828.   void alterTrigger_recvReply(Signal* signal, const AlterTrigConf* conf,
  1829.       const AlterTrigRef* ref);
  1830.   void alterTrigger_slavePrepare(Signal* signal, OpAlterTriggerPtr opPtr);
  1831.   void alterTrigger_toCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr);
  1832.   void alterTrigger_fromCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr);
  1833.   void alterTrigger_toDropLocal(Signal* signal, OpAlterTriggerPtr opPtr);
  1834.   void alterTrigger_fromDropLocal(Signal* signal, OpAlterTriggerPtr opPtr);
  1835.   void alterTrigger_slaveCommit(Signal* signal, OpAlterTriggerPtr opPtr);
  1836.   void alterTrigger_slaveAbort(Signal* signal, OpAlterTriggerPtr opPtr);
  1837.   void alterTrigger_sendSlaveReq(Signal* signal, OpAlterTriggerPtr opPtr);
  1838.   void alterTrigger_sendReply(Signal* signal, OpAlterTriggerPtr opPtr, bool);
  1839.   // support
  1840.   void getTableKeyList(TableRecordPtr tablePtr, AttributeList& list);
  1841.   void getIndexAttr(TableRecordPtr indexPtr, Uint32 itAttr, Uint32* id);
  1842.   void getIndexAttrList(TableRecordPtr indexPtr, AttributeList& list);
  1843.   void getIndexAttrMask(TableRecordPtr indexPtr, AttributeMask& mask);
  1844.   /* ------------------------------------------------------------ */
  1845.   // Initialisation
  1846.   /* ------------------------------------------------------------ */
  1847.   void initCommonData();
  1848.   void initRecords();
  1849.   void initConnectRecord();
  1850.   void initRetrieveRecord(Signal*, Uint32, Uint32 returnCode);
  1851.   void initSchemaRecord();
  1852.   void initRestartRecord();
  1853.   void initSendSchemaRecord();
  1854.   void initReadTableRecord();
  1855.   void initWriteTableRecord();
  1856.   void initReadSchemaRecord();
  1857.   void initWriteSchemaRecord();
  1858.   void initNodeRecords();
  1859.   void initTableRecords();
  1860.   void initialiseTableRecord(TableRecordPtr tablePtr);
  1861.   void initTriggerRecords();
  1862.   void initialiseTriggerRecord(TriggerRecordPtr triggerPtr);
  1863.   void initPageRecords();
  1864.   Uint32 getFsConnRecord();
  1865.   bool getIsFailed(Uint32 nodeId) const;
  1866.   void dropTable_backup_mutex_locked(Signal* signal, Uint32, Uint32);
  1867.   void dropTableRef(Signal * signal, DropTableReq *, DropTableRef::ErrorCode);
  1868.   void printTables(); // For debugging only
  1869.   int handleAlterTab(AlterTabReq * req,
  1870.      CreateTableRecord * regAlterTabPtr,
  1871.      TableRecordPtr origTablePtr,
  1872.      TableRecordPtr newTablePtr);
  1873.   void revertAlterTable(Signal * signal, 
  1874. Uint32 changeMask, 
  1875. Uint32 tableId,
  1876. CreateTableRecord * regAlterTabPtr);
  1877.   void alterTable_backup_mutex_locked(Signal* signal, Uint32, Uint32);
  1878.   void alterTableRef(Signal * signal, 
  1879.      AlterTableReq *, AlterTableRef::ErrorCode, 
  1880.      ParseDictTabInfoRecord* parseRecord = NULL);
  1881.   void alterTabRef(Signal * signal, 
  1882.    AlterTabReq *, AlterTableRef::ErrorCode, 
  1883.    ParseDictTabInfoRecord* parseRecord = NULL);
  1884.   void alterTab_writeSchemaConf(Signal* signal, 
  1885. Uint32 callbackData,
  1886. Uint32 returnCode);
  1887.   void alterTab_writeTableConf(Signal* signal, 
  1888.        Uint32 callbackData,
  1889.        Uint32 returnCode);
  1890.   void prepDropTab_nextStep(Signal* signal, DropTableRecordPtr);
  1891.   void prepDropTab_complete(Signal* signal, DropTableRecordPtr);
  1892.   void prepDropTab_writeSchemaConf(Signal* signal, Uint32 dropTabPtrI, Uint32);
  1893.   void dropTab_localDROP_TAB_CONF(Signal* signal);
  1894.   void dropTab_nextStep(Signal* signal, DropTableRecordPtr);
  1895.   void dropTab_complete(Signal* signal, Uint32 dropTabPtrI, Uint32);
  1896.   void dropTab_writeSchemaConf(Signal* signal, Uint32 dropTabPtrI, Uint32);
  1897.   void createTab_prepare(Signal* signal, CreateTabReq * req);
  1898.   void createTab_writeSchemaConf1(Signal* signal, Uint32 callback, Uint32);
  1899.   void createTab_writeTableConf(Signal* signal, Uint32 callbackData, Uint32);
  1900.   void createTab_dih(Signal*, CreateTableRecordPtr, 
  1901.      SegmentedSectionPtr, Callback*);
  1902.   void createTab_dihComplete(Signal* signal, Uint32 callbackData, Uint32);
  1903.   void createTab_startLcpMutex_locked(Signal* signal, Uint32, Uint32);
  1904.   void createTab_startLcpMutex_unlocked(Signal* signal, Uint32, Uint32);
  1905.   
  1906.   void createTab_commit(Signal* signal, CreateTabReq * req);  
  1907.   void createTab_writeSchemaConf2(Signal* signal, Uint32 callbackData, Uint32);
  1908.   void createTab_alterComplete(Signal*, Uint32 callbackData, Uint32);
  1909.   void createTab_drop(Signal* signal, CreateTabReq * req);
  1910.   void createTab_dropComplete(Signal* signal, Uint32 callbackData, Uint32);
  1911.   void createTab_reply(Signal* signal, CreateTableRecordPtr, Uint32 nodeId);
  1912.   void alterTab_activate(Signal*, CreateTableRecordPtr, Callback*);
  1913.   
  1914.   void restartCreateTab(Signal*, Uint32, const SchemaFile::TableEntry *, bool);
  1915.   void restartCreateTab_readTableConf(Signal* signal, Uint32 callback, Uint32);
  1916.   void restartCreateTab_writeTableConf(Signal* signal, Uint32 callback, Uint32);
  1917.   void restartCreateTab_dihComplete(Signal* signal, Uint32 callback, Uint32);
  1918.   void restartCreateTab_activateComplete(Signal*, Uint32 callback, Uint32);
  1919.   void restartDropTab(Signal* signal, Uint32 tableId);
  1920.   void restartDropTab_complete(Signal*, Uint32 callback, Uint32);
  1921.   
  1922.   void restart_checkSchemaStatusComplete(Signal*, Uint32 callback, Uint32);
  1923.   void restart_writeSchemaConf(Signal*, Uint32 callbackData, Uint32);
  1924.   void masterRestart_checkSchemaStatusComplete(Signal*, Uint32, Uint32);
  1925.   void sendSchemaComplete(Signal*, Uint32 callbackData, Uint32);
  1926.   // global metadata support
  1927.   friend class MetaData;
  1928.   int getMetaTablePtr(TableRecordPtr& tablePtr, Uint32 tableId, Uint32 tableVersion);
  1929.   int getMetaTable(MetaData::Table& table, Uint32 tableId, Uint32 tableVersion);
  1930.   int getMetaTable(MetaData::Table& table, const char* tableName);
  1931.   int getMetaAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, Uint32 attributeId);
  1932.   int getMetaAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, const char* attributeName);
  1933. };
  1934. #endif