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

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

MySQL数据库

开发平台：

Visual C++

Dbtux.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 DBTUX_H
  18. #define DBTUX_H
  20. #include <ndb_limits.h>
  21. #include <SimulatedBlock.hpp>
  22. #include <AttributeDescriptor.hpp>
  23. #include <AttributeHeader.hpp>
  24. #include <ArrayPool.hpp>
  25. #include <DataBuffer.hpp>
  26. #include <md5_hash.hpp>
  28. // big brother
  29. #include <Dbtup.hpp>
  31. // signal classes
  32. #include <signaldata/DictTabInfo.hpp>
  33. #include <signaldata/TuxContinueB.hpp>
  34. #include <signaldata/TupFrag.hpp>
  35. #include <signaldata/AlterIndx.hpp>
  36. #include <signaldata/DropTab.hpp>
  37. #include <signaldata/TuxMaint.hpp>
  38. #include <signaldata/AccScan.hpp>
  39. #include <signaldata/TuxBound.hpp>
  40. #include <signaldata/NextScan.hpp>
  41. #include <signaldata/AccLock.hpp>
  42. #include <signaldata/DumpStateOrd.hpp>
  44. // debug
  45. #ifdef VM_TRACE
  46. #include <NdbOut.hpp>
  47. #include <OutputStream.hpp>
  48. #endif
  50. // jams
  51. #undef jam
  52. #undef jamEntry
  53. #ifdef DBTUX_GEN_CPP
  54. #define jam()           jamLine(10000 + __LINE__)
  55. #define jamEntry()      jamEntryLine(10000 + __LINE__)
  56. #endif
  57. #ifdef DBTUX_META_CPP
  58. #define jam()           jamLine(20000 + __LINE__)
  59. #define jamEntry()      jamEntryLine(20000 + __LINE__)
  60. #endif
  61. #ifdef DBTUX_MAINT_CPP
  62. #define jam()           jamLine(30000 + __LINE__)
  63. #define jamEntry()      jamEntryLine(30000 + __LINE__)
  64. #endif
  65. #ifdef DBTUX_NODE_CPP
  66. #define jam()           jamLine(40000 + __LINE__)
  67. #define jamEntry()      jamEntryLine(40000 + __LINE__)
  68. #endif
  69. #ifdef DBTUX_TREE_CPP
  70. #define jam()           jamLine(50000 + __LINE__)
  71. #define jamEntry()      jamEntryLine(50000 + __LINE__)
  72. #endif
  73. #ifdef DBTUX_SCAN_CPP
  74. #define jam()           jamLine(60000 + __LINE__)
  75. #define jamEntry()      jamEntryLine(60000 + __LINE__)
  76. #endif
  77. #ifdef DBTUX_SEARCH_CPP
  78. #define jam()           jamLine(70000 + __LINE__)
  79. #define jamEntry()      jamEntryLine(70000 + __LINE__)
  80. #endif
  81. #ifdef DBTUX_CMP_CPP
  82. #define jam()           jamLine(80000 + __LINE__)
  83. #define jamEntry()      jamEntryLine(80000 + __LINE__)
  84. #endif
  85. #ifdef DBTUX_DEBUG_CPP
  86. #define jam()           jamLine(90000 + __LINE__)
  87. #define jamEntry()      jamEntryLine(90000 + __LINE__)
  88. #endif
  89. #ifndef jam
  90. #define jam()           jamLine(__LINE__)
  91. #define jamEntry()      jamEntryLine(__LINE__)
  92. #endif
  94. #undef max
  95. #undef min
  97. class Configuration;
  99. class Dbtux : public SimulatedBlock {
  100. public:
  101.   Dbtux(const Configuration& conf);
  102.   virtual ~Dbtux();
  104.   // pointer to TUP instance in this thread
  105.   Dbtup* c_tup;
  107. private:
  108.   // sizes are in words (Uint32)
  109.   STATIC_CONST( MaxIndexFragments = 2 * MAX_FRAG_PER_NODE );
  110.   STATIC_CONST( MaxIndexAttributes = MAX_ATTRIBUTES_IN_INDEX );
  111.   STATIC_CONST( MaxAttrDataSize = 2048 );
  112. public:
  113.   STATIC_CONST( DescPageSize = 256 );
  114. private:
  115.   STATIC_CONST( MaxTreeNodeSize = MAX_TTREE_NODE_SIZE );
  116.   STATIC_CONST( MaxPrefSize = MAX_TTREE_PREF_SIZE );
  117.   STATIC_CONST( ScanBoundSegmentSize = 7 );
  118.   STATIC_CONST( MaxAccLockOps = MAX_PARALLEL_OP_PER_SCAN );
  119.   BLOCK_DEFINES(Dbtux);
  121.   // forward declarations
  122.   struct DescEnt;
  124.   /*
  125.    * Pointer to array of Uint32.
  126.    */
  127.   struct Data {
  128.   private:
  129.     Uint32* m_data;
  130.   public:
  131.     Data();
  132.     Data(Uint32* data);
  133.     Data& operator=(Uint32* data);
  134.     operator Uint32*() const;
  135.     Data& operator+=(size_t n);
  136.     AttributeHeader& ah() const;
  137.   };
  138.   friend class Data;
  140.   /*
  141.    * Pointer to array of constant Uint32.
  142.    */
  143.   struct ConstData;
  144.   friend struct ConstData;
  145.   struct ConstData {
  146.   private:
  147.     const Uint32* m_data;
  148.   public:
  149.     ConstData();
  150.     ConstData(const Uint32* data);
  151.     ConstData& operator=(const Uint32* data);
  152.     operator const Uint32*() const;
  153.     ConstData& operator+=(size_t n);
  154.     const AttributeHeader& ah() const;
  155.     // non-const pointer can be cast to const pointer
  156.     ConstData(Data data);
  157.     ConstData& operator=(Data data);
  158.   };
  160.   // AttributeHeader size is assumed to be 1 word
  161.   STATIC_CONST( AttributeHeaderSize = 1 );
  163.   /*
  164.    * Logical tuple address, "local key".  Identifies table tuples.
  165.    */
  166.   typedef Uint32 TupAddr;
  167.   STATIC_CONST( NullTupAddr = (Uint32)-1 );
  169.   /*
  170.    * Physical tuple address in TUP.  Provides fast access to table tuple
  171.    * or index node.  Valid within the db node and across timeslices.
  172.    * Not valid between db nodes or across restarts.
  173.    *
  174.    * To avoid wasting an Uint16 the pageid is split in two.
  175.    */
  176.   struct TupLoc {
  177.   private:
  178.     Uint16 m_pageId1;           // page i-value (big-endian)
  179.     Uint16 m_pageId2;
  180.     Uint16 m_pageOffset;        // page offset in words
  181.   public:
  182.     TupLoc();
  183.     TupLoc(Uint32 pageId, Uint16 pageOffset);
  184.     Uint32 getPageId() const;
  185.     void setPageId(Uint32 pageId);
  186.     Uint32 getPageOffset() const;
  187.     void setPageOffset(Uint32 pageOffset);
  188.     bool operator==(const TupLoc& loc) const;
  189.     bool operator!=(const TupLoc& loc) const;
  190.   };
  192.   /*
  193.    * There is no const member NullTupLoc since the compiler may not be
  194.    * able to optimize it to TupLoc() constants.  Instead null values are
  195.    * constructed on the stack with TupLoc().
  196.    */
  197. #define NullTupLoc TupLoc()
  199.   // tree definitions
  201.   /*
  202.    * Tree entry.  Points to a tuple in primary table via physical
  203.    * address of "original" tuple and tuple version.
  204.    *
  205.    * ZTUP_VERSION_BITS must be 15 (or less).
  206.    */
  207.   struct TreeEnt;
  208.   friend struct TreeEnt;
  209.   struct TreeEnt {
  210.     TupLoc m_tupLoc;            // address of original tuple
  211.     unsigned m_tupVersion : 15; // version
  212.     unsigned m_fragBit : 1;     // which duplicated table fragment
  213.     TreeEnt();
  214.     // methods
  215.     bool eq(const TreeEnt ent) const;
  216.     int cmp(const TreeEnt ent) const;
  217.   };
  218.   STATIC_CONST( TreeEntSize = sizeof(TreeEnt) >> 2 );
  219.   static const TreeEnt NullTreeEnt;
  221.   /*
  222.    * Tree node has 1) fixed part 2) a prefix of index key data for min
  223.    * entry 3) max and min entries 4) rest of entries 5) one extra entry
  224.    * used as work space.
  225.    *
  226.    * struct TreeNode            part 1, size 6 words
  227.    * min prefix                 part 2, size TreeHead::m_prefSize
  228.    * max entry                  part 3
  229.    * min entry                  part 3
  230.    * rest of entries            part 4
  231.    * work entry                 part 5
  232.    *
  233.    * There are 3 links to other nodes: left child, right child, parent.
  234.    * Occupancy (number of entries) is at least 1 except temporarily when
  235.    * a node is about to be removed.
  236.    */
  237.   struct TreeNode;
  238.   friend struct TreeNode;
  239.   struct TreeNode {
  240.     TupLoc m_link[3];           // link to 0-left child 1-right child 2-parent
  241.     unsigned m_side : 2;        // we are 0-left child 1-right child 2-root
  242.     unsigned m_balance : 2;     // balance -1, 0, +1 plus 1 for Solaris CC
  243.     unsigned pad1 : 4;
  244.     Uint8 m_occup;              // current number of entries
  245.     Uint32 m_nodeScan;          // list of scans at this node
  246.     TreeNode();
  247.   };
  248.   STATIC_CONST( NodeHeadSize = sizeof(TreeNode) >> 2 );
  250.   /*
  251.    * Tree node "access size" was for an early version with signal
  252.    * interface to TUP.  It is now used only to compute sizes.
  253.    */
  254.   enum AccSize {
  255.     AccNone = 0,
  256.     AccHead = 1,                // part 1
  257.     AccPref = 2,                // parts 1-3
  258.     AccFull = 3                 // parts 1-5
  259.   };
  261.   /*
  262.    * Tree header.  There is one in each fragment.  Contains tree
  263.    * parameters and address of root node.
  264.    */
  265.   struct TreeHead;
  266.   friend struct TreeHead;
  267.   struct TreeHead {
  268.     Uint8 m_nodeSize;           // words in tree node
  269.     Uint8 m_prefSize;           // words in min prefix
  270.     Uint8 m_minOccup;           // min entries in internal node
  271.     Uint8 m_maxOccup;           // max entries in node
  272.     TupLoc m_root;              // root node
  273.     TreeHead();
  274.     // methods
  275.     unsigned getSize(AccSize acc) const;
  276.     Data getPref(TreeNode* node) const;
  277.     TreeEnt* getEntList(TreeNode* node) const;
  278.   };
  280.   /*
  281.    * Tree position.  Specifies node, position within node (from 0 to
  282.    * m_occup), and whether the position is at an existing entry or
  283.    * before one (if any).  Position m_occup points past the node and is
  284.    * also represented by position 0 of next node.  Includes direction
  285.    * used by scan.
  286.    */
  287.   struct TreePos;
  288.   friend struct TreePos;
  289.   struct TreePos {
  290.     TupLoc m_loc;               // physical node address
  291.     Uint16 m_pos;               // position 0 to m_occup
  292.     Uint8 m_match;              // at an existing entry
  293.     Uint8 m_dir;                // see scanNext()
  294.     TreePos();
  295.   };
  297.   // packed metadata
  299.   /*
  300.    * Descriptor page.  The "hot" metadata for an index is stored as
  301.    * a contiguous array of words on some page.
  302.    */
  303.   struct DescPage;
  304.   friend struct DescPage;
  305.   struct DescPage {
  306.     Uint32 m_nextPage;
  307.     Uint32 m_numFree;           // number of free words
  308.     union {
  309.     Uint32 m_data[DescPageSize];
  310.     Uint32 nextPool;
  311.     };
  312.     DescPage();
  313.   };
  314.   typedef Ptr<DescPage> DescPagePtr;
  315.   ArrayPool<DescPage> c_descPagePool;
  316.   Uint32 c_descPageList;
  318.   /*
  319.    * Header for index metadata.  Size must be multiple of word size.
  320.    */
  321.   struct DescHead {
  322.     unsigned m_indexId : 24;
  323.     unsigned pad1 : 8;
  324.   };
  325.   STATIC_CONST( DescHeadSize = sizeof(DescHead) >> 2 );
  327.   /*
  328.    * Attribute metadata.  Size must be multiple of word size.
  329.    *
  330.    * Prefix comparison of char data must use strxfrm and binary
  331.    * comparison.  The charset is currently unused.
  332.    */
  333.   struct DescAttr {
  334.     Uint32 m_attrDesc;          // standard AttributeDescriptor
  335.     Uint16 m_primaryAttrId;
  336.     unsigned m_typeId : 6;
  337.     unsigned m_charset : 10;
  338.   };
  339.   STATIC_CONST( DescAttrSize = sizeof(DescAttr) >> 2 );
  341.   /*
  342.    * Complete metadata for one index. The array of attributes has
  343.    * variable size.
  344.    */
  345.   friend struct DescEnt;
  346.   struct DescEnt {
  347.     DescHead m_descHead;
  348.     DescAttr m_descAttr[1];     // variable size data
  349.   };
  351.   // range scan
  352.  
  353.   /*
  354.    * Scan bounds are stored in linked list of segments.
  355.    */
  356.   typedef DataBuffer<ScanBoundSegmentSize> ScanBound;
  357.   typedef DataBuffer<ScanBoundSegmentSize>::ConstDataBufferIterator ScanBoundIterator;
  358.   typedef DataBuffer<ScanBoundSegmentSize>::DataBufferPool ScanBoundPool;
  359.   ScanBoundPool c_scanBoundPool;
  360.  
  361.   /*
  362.    * Scan operation.
  363.    *
  364.    * Tuples are locked one at a time.  The current lock op is set to
  365.    * RNIL as soon as the lock is obtained and passed to LQH.  We must
  366.    * however remember all locks which LQH has not returned for unlocking
  367.    * since they must be aborted by us when the scan is closed.
  368.    *
  369.    * Scan state describes the entry we are interested in.  There is
  370.    * a separate lock wait flag.  It may be for current entry or it may
  371.    * be for an entry we were moved away from.  In any case nothing
  372.    * happens with current entry before lock wait flag is cleared.
  373.    *
  374.    * An unfinished scan is always linked to some tree node, and has
  375.    * current position and direction (see comments at scanNext).  There
  376.    * is also a copy of latest entry found.
  377.    */
  378.   struct ScanOp;
  379.   friend struct ScanOp;
  380.   struct ScanOp {
  381.     enum {
  382.       Undef = 0,
  383.       First = 1,                // before first entry
  384.       Current = 2,              // at current before locking
  385.       Blocked = 3,              // at current waiting for ACC lock
  386.       Locked = 4,               // at current and locked or no lock needed
  387.       Next = 5,                 // looking for next extry
  388.       Last = 6,                 // after last entry
  389.       Aborting = 7,             // lock wait at scan close
  390.       Invalid = 9               // cannot return REF to LQH currently
  391.     };
  392.     Uint16 m_state;
  393.     Uint16 m_lockwait;
  394.     Uint32 m_userPtr;           // scanptr.i in LQH
  395.     Uint32 m_userRef;
  396.     Uint32 m_tableId;
  397.     Uint32 m_indexId;
  398.     Uint32 m_fragId;
  399.     Uint32 m_fragPtrI;
  400.     Uint32 m_transId1;
  401.     Uint32 m_transId2;
  402.     Uint32 m_savePointId;
  403.     // lock waited for or obtained and not yet passed to LQH
  404.     Uint32 m_accLockOp;
  405.     Uint8 m_readCommitted;      // no locking
  406.     Uint8 m_lockMode;
  407.     Uint8 m_keyInfo;
  408.     ScanBound m_boundMin;
  409.     ScanBound m_boundMax;
  410.     ScanBound* m_bound[2];      // pointers to above 2
  411.     Uint16 m_boundCnt[2];       // number of bounds in each
  412.     TreePos m_scanPos;          // position
  413.     TreeEnt m_scanEnt;          // latest entry found
  414.     Uint32 m_nodeScan;          // next scan at node (single-linked)
  415.     union {
  416.     Uint32 nextPool;
  417.     Uint32 nextList;
  418.     };
  419.     Uint32 prevList;
  420.     /*
  421.      * Locks obtained and passed to LQH but not yet returned by LQH.
  422.      * The max was increased from 16 to 992 (default 64).  Record max
  423.      * ever used in this scan.  TODO fix quadratic behaviour
  424.      */
  425.     Uint32 m_maxAccLockOps;
  426.     Uint32 m_accLockOps[MaxAccLockOps];
  427.     ScanOp(ScanBoundPool& scanBoundPool);
  428.   };
  429.   typedef Ptr<ScanOp> ScanOpPtr;
  430.   ArrayPool<ScanOp> c_scanOpPool;
  432.   // indexes and fragments
  434.   /*
  435.    * Ordered index.  Top level data structure.  The primary table (table
  436.    * being indexed) lives in TUP.
  437.    */
  438.   struct Index;
  439.   friend struct Index;
  440.   struct Index {
  441.     enum State {
  442.       NotDefined = 0,
  443.       Defining = 1,
  444.       Online = 2,               // triggers activated and build done
  445.       Dropping = 9
  446.     };
  447.     State m_state;
  448.     DictTabInfo::TableType m_tableType;
  449.     Uint32 m_tableId;
  450.     Uint16 m_fragOff;           // offset for duplicate fragId bits
  451.     Uint16 m_numFrags;
  452.     Uint32 m_fragId[MaxIndexFragments];
  453.     Uint32 m_fragPtrI[MaxIndexFragments];
  454.     Uint32 m_descPage;          // descriptor page
  455.     Uint16 m_descOff;           // offset within the page
  456.     Uint16 m_numAttrs;
  457.     bool m_storeNullKey;
  458.     union {
  459.     Uint32 nextPool;
  460.     };
  461.     Index();
  462.   };
  463.   typedef Ptr<Index> IndexPtr;
  464.   ArrayPool<Index> c_indexPool;
  466.   /*
  467.    * Fragment of an index, as known to DIH/TC.  Represents the two
  468.    * duplicate fragments known to LQH/ACC/TUP.  Includes tree header.
  469.    * There are no maintenance operation records yet.
  470.    */
  471.   struct Frag;
  472.   friend struct Frag;
  473.   struct Frag {
  474.     Uint32 m_tableId;           // copy from index level
  475.     Uint32 m_indexId;
  476.     Uint16 m_fragOff;
  477.     Uint16 m_fragId;
  478.     Uint32 m_descPage;          // copy from index level
  479.     Uint16 m_descOff;
  480.     Uint16 m_numAttrs;
  481.     bool m_storeNullKey;
  482.     TreeHead m_tree;
  483.     TupLoc m_freeLoc;           // list of free index nodes
  484.     DLList<ScanOp> m_scanList;  // current scans on this fragment
  485.     Uint32 m_tupIndexFragPtrI;
  486.     Uint32 m_tupTableFragPtrI[2];
  487.     Uint32 m_accTableFragPtrI[2];
  488.     union {
  489.     Uint32 nextPool;
  490.     };
  491.     Frag(ArrayPool<ScanOp>& scanOpPool);
  492.   };
  493.   typedef Ptr<Frag> FragPtr;
  494.   ArrayPool<Frag> c_fragPool;
  496.   /*
  497.    * Fragment metadata operation.
  498.    */
  499.   struct FragOp {
  500.     Uint32 m_userPtr;
  501.     Uint32 m_userRef;
  502.     Uint32 m_indexId;
  503.     Uint32 m_fragId;
  504.     Uint32 m_fragPtrI;
  505.     Uint32 m_fragNo;            // fragment number starting at zero
  506.     Uint32 m_numAttrsRecvd;
  507.     union {
  508.     Uint32 nextPool;
  509.     };
  510.     FragOp();
  511.   };
  512.   typedef Ptr<FragOp> FragOpPtr;
  513.   ArrayPool<FragOp> c_fragOpPool;
  515.   // node handles
  517.   /*
  518.    * A node handle is a reference to a tree node in TUP.  It is used to
  519.    * operate on the node.  Node handles are allocated on the stack.
  520.    */
  521.   struct NodeHandle;
  522.   friend struct NodeHandle;
  523.   struct NodeHandle {
  524.     Frag& m_frag;               // fragment using the node
  525.     TupLoc m_loc;               // physical node address
  526.     TreeNode* m_node;           // pointer to node storage
  527.     NodeHandle(Frag& frag);
  528.     NodeHandle(const NodeHandle& node);
  529.     NodeHandle& operator=(const NodeHandle& node);
  530.     // check if unassigned
  531.     bool isNull();
  532.     // getters
  533.     TupLoc getLink(unsigned i);
  534.     unsigned getChilds();       // cannot spell
  535.     unsigned getSide();
  536.     unsigned getOccup();
  537.     int getBalance();
  538.     Uint32 getNodeScan();
  539.     // setters
  540.     void setLink(unsigned i, TupLoc loc);
  541.     void setSide(unsigned i);
  542.     void setOccup(unsigned n);
  543.     void setBalance(int b);
  544.     void setNodeScan(Uint32 scanPtrI);
  545.     // access other parts of the node
  546.     Data getPref();
  547.     TreeEnt getEnt(unsigned pos);
  548.     TreeEnt getMinMax(unsigned i);
  549.     // for ndbrequire and ndbassert
  550.     void progError(int line, int cause, const char* file);
  551.   };
  553.   // methods
  555.   /*
  556.    * DbtuxGen.cpp
  557.    */
  558.   void execCONTINUEB(Signal* signal);
  559.   void execSTTOR(Signal* signal);
  560.   void execREAD_CONFIG_REQ(Signal* signal);
  561.   // utils
  562.   void setKeyAttrs(const Frag& frag);
  563.   void readKeyAttrs(const Frag& frag, TreeEnt ent, unsigned start, Data keyData);
  564.   void readTablePk(const Frag& frag, TreeEnt ent, Data pkData, unsigned& pkSize);
  565.   void copyAttrs(const Frag& frag, ConstData data1, Data data2, unsigned maxlen2 = MaxAttrDataSize);
  567.   /*
  568.    * DbtuxMeta.cpp
  569.    */
  570.   void execTUXFRAGREQ(Signal* signal);
  571.   void execTUX_ADD_ATTRREQ(Signal* signal);
  572.   void execALTER_INDX_REQ(Signal* signal);
  573.   void execDROP_TAB_REQ(Signal* signal);
  574.   bool allocDescEnt(IndexPtr indexPtr);
  575.   void freeDescEnt(IndexPtr indexPtr);
  576.   void abortAddFragOp(Signal* signal);
  577.   void dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData);
  579.   /*
  580.    * DbtuxMaint.cpp
  581.    */
  582.   void execTUX_MAINT_REQ(Signal* signal);
  583.   
  584.   /*
  585.    * DbtuxNode.cpp
  586.    */
  587.   int allocNode(Signal* signal, NodeHandle& node);
  588.   void selectNode(NodeHandle& node, TupLoc loc);
  589.   void insertNode(NodeHandle& node);
  590.   void deleteNode(NodeHandle& node);
  591.   void setNodePref(NodeHandle& node);
  592.   // node operations
  593.   void nodePushUp(NodeHandle& node, unsigned pos, const TreeEnt& ent, Uint32 scanList);
  594.   void nodePushUpScans(NodeHandle& node, unsigned pos);
  595.   void nodePopDown(NodeHandle& node, unsigned pos, TreeEnt& en, Uint32* scanList);
  596.   void nodePopDownScans(NodeHandle& node, unsigned pos);
  597.   void nodePushDown(NodeHandle& node, unsigned pos, TreeEnt& ent, Uint32& scanList);
  598.   void nodePushDownScans(NodeHandle& node, unsigned pos);
  599.   void nodePopUp(NodeHandle& node, unsigned pos, TreeEnt& ent, Uint32 scanList);
  600.   void nodePopUpScans(NodeHandle& node, unsigned pos);
  601.   void nodeSlide(NodeHandle& dstNode, NodeHandle& srcNode, unsigned cnt, unsigned i);
  602.   // scans linked to node
  603.   void addScanList(NodeHandle& node, unsigned pos, Uint32 scanList);
  604.   void removeScanList(NodeHandle& node, unsigned pos, Uint32& scanList);
  605.   void moveScanList(NodeHandle& node, unsigned pos);
  606.   void linkScan(NodeHandle& node, ScanOpPtr scanPtr);
  607.   void unlinkScan(NodeHandle& node, ScanOpPtr scanPtr);
  608.   bool islinkScan(NodeHandle& node, ScanOpPtr scanPtr);
  610.   /*
  611.    * DbtuxTree.cpp
  612.    */
  613.   // add entry
  614.   void treeAdd(Frag& frag, TreePos treePos, TreeEnt ent);
  615.   void treeAddFull(Frag& frag, NodeHandle lubNode, unsigned pos, TreeEnt ent);
  616.   void treeAddNode(Frag& frag, NodeHandle lubNode, unsigned pos, TreeEnt ent, NodeHandle parentNode, unsigned i);
  617.   void treeAddRebalance(Frag& frag, NodeHandle node, unsigned i);
  618.   // remove entry
  619.   void treeRemove(Frag& frag, TreePos treePos);
  620.   void treeRemoveInner(Frag& frag, NodeHandle lubNode, unsigned pos);
  621.   void treeRemoveSemi(Frag& frag, NodeHandle node, unsigned i);
  622.   void treeRemoveLeaf(Frag& frag, NodeHandle node);
  623.   void treeRemoveNode(Frag& frag, NodeHandle node);
  624.   void treeRemoveRebalance(Frag& frag, NodeHandle node, unsigned i);
  625.   // rotate
  626.   void treeRotateSingle(Frag& frag, NodeHandle& node, unsigned i);
  627.   void treeRotateDouble(Frag& frag, NodeHandle& node, unsigned i);
  629.   /*
  630.    * DbtuxScan.cpp
  631.    */
  632.   void execACC_SCANREQ(Signal* signal);
  633.   void execTUX_BOUND_INFO(Signal* signal);
  634.   void execNEXT_SCANREQ(Signal* signal);
  635.   void execACC_CHECK_SCAN(Signal* signal);
  636.   void execACCKEYCONF(Signal* signal);
  637.   void execACCKEYREF(Signal* signal);
  638.   void execACC_ABORTCONF(Signal* signal);
  639.   void scanFirst(ScanOpPtr scanPtr);
  640.   void scanNext(ScanOpPtr scanPtr);
  641.   bool scanVisible(ScanOpPtr scanPtr, TreeEnt ent);
  642.   void scanClose(Signal* signal, ScanOpPtr scanPtr);
  643.   void addAccLockOp(ScanOp& scan, Uint32 accLockOp);
  644.   void removeAccLockOp(ScanOp& scan, Uint32 accLockOp);
  645.   void releaseScanOp(ScanOpPtr& scanPtr);
  647.   /*
  648.    * DbtuxSearch.cpp
  649.    */
  650.   void searchToAdd(Frag& frag, ConstData searchKey, TreeEnt searchEnt, TreePos& treePos);
  651.   void searchToRemove(Frag& frag, ConstData searchKey, TreeEnt searchEnt, TreePos& treePos);
  652.   void searchToScan(Frag& frag, ConstData boundInfo, unsigned boundCount, TreePos& treePos);
  654.   /*
  655.    * DbtuxCmp.cpp
  656.    */
  657.   int cmpSearchKey(const Frag& frag, unsigned& start, ConstData searchKey, ConstData entryData, unsigned maxlen = MaxAttrDataSize);
  658.   int cmpScanBound(const Frag& frag, unsigned dir, ConstData boundInfo, unsigned boundCount, ConstData entryData, unsigned maxlen = MaxAttrDataSize);
  660.   /*
  661.    * DbtuxDebug.cpp
  662.    */
  663.   void execDUMP_STATE_ORD(Signal* signal);
  664. #ifdef VM_TRACE
  665.   struct PrintPar {
  666.     char m_path[100];           // LR prefix
  667.     unsigned m_side;            // expected side
  668.     TupLoc m_parent;            // expected parent address
  669.     int m_depth;                // returned depth
  670.     unsigned m_occup;           // returned occupancy
  671.     TreeEnt m_minmax[2];        // returned subtree min and max
  672.     bool m_ok;                  // returned status
  673.     PrintPar();
  674.   };
  675.   void printTree(Signal* signal, Frag& frag, NdbOut& out);
  676.   void printNode(Frag& frag, NdbOut& out, TupLoc loc, PrintPar& par);
  677.   friend class NdbOut& operator<<(NdbOut&, const TupLoc&);
  678.   friend class NdbOut& operator<<(NdbOut&, const TreeEnt&);
  679.   friend class NdbOut& operator<<(NdbOut&, const TreeNode&);
  680.   friend class NdbOut& operator<<(NdbOut&, const TreeHead&);
  681.   friend class NdbOut& operator<<(NdbOut&, const TreePos&);
  682.   friend class NdbOut& operator<<(NdbOut&, const DescAttr&);
  683.   friend class NdbOut& operator<<(NdbOut&, const ScanOp&);
  684.   friend class NdbOut& operator<<(NdbOut&, const Index&);
  685.   friend class NdbOut& operator<<(NdbOut&, const Frag&);
  686.   friend class NdbOut& operator<<(NdbOut&, const FragOp&);
  687.   friend class NdbOut& operator<<(NdbOut&, const NodeHandle&);
  688.   FILE* debugFile;
  689.   NdbOut debugOut;
  690.   unsigned debugFlags;
  691.   enum {
  692.     DebugMeta = 1,              // log create and drop index
  693.     DebugMaint = 2,             // log maintenance ops
  694.     DebugTree = 4,              // log and check tree after each op
  695.     DebugScan = 8               // log scans
  696.   };
  697.   STATIC_CONST( DataFillByte = 0xa2 );
  698.   STATIC_CONST( NodeFillByte = 0xa4 );
  699. #endif
  701.   // start up info
  702.   Uint32 c_internalStartPhase;
  703.   Uint32 c_typeOfStart;
  705.   /*
  706.    * Global data set at operation start.  Unpacked from index metadata.
  707.    * Not passed as parameter to methods.  Invalid across timeslices.
  708.    *
  709.    * TODO inline all into index metadata
  710.    */
  712.   // index key attr ids with sizes in AttributeHeader format
  713.   Data c_keyAttrs;
  715.   // pointers to index key comparison functions
  716.   NdbSqlUtil::Cmp** c_sqlCmp;
  718.   /*
  719.    * Other buffers used during the operation.
  720.    */
  722.   // buffer for search key data with headers
  723.   Data c_searchKey;
  725.   // buffer for current entry key data with headers
  726.   Data c_entryKey;
  728.   // buffer for scan bounds and keyinfo (primary key)
  729.   Data c_dataBuffer;
  731.   // inlined utils
  732.   DescEnt& getDescEnt(Uint32 descPage, Uint32 descOff);
  733.   Uint32 getTupAddr(const Frag& frag, TreeEnt ent);
  734.   static unsigned min(unsigned x, unsigned y);
  735.   static unsigned max(unsigned x, unsigned y);
  736. };
  738. // Dbtux::Data
  740. inline
  741. Dbtux::Data::Data() :
  742.   m_data(0)
  743. {
  744. }
  746. inline
  747. Dbtux::Data::Data(Uint32* data) :
  748.   m_data(data)
  749. {
  750. }
  752. inline Dbtux::Data&
  753. Dbtux::Data::operator=(Uint32* data)
  754. {
  755.   m_data = data;
  756.   return *this;
  757. }
  759. inline
  760. Dbtux::Data::operator Uint32*() const
  761. {
  762.   return m_data;
  763. }
  765. inline Dbtux::Data&
  766. Dbtux::Data::operator+=(size_t n)
  767. {
  768.   m_data += n;
  769.   return *this;
  770. }
  772. inline AttributeHeader&
  773. Dbtux::Data::ah() const
  774. {
  775.   return *reinterpret_cast<AttributeHeader*>(m_data);
  776. }
  778. // Dbtux::ConstData
  780. inline
  781. Dbtux::ConstData::ConstData() :
  782.   m_data(0)
  783. {
  784. }
  786. inline
  787. Dbtux::ConstData::ConstData(const Uint32* data) :
  788.   m_data(data)
  789. {
  790. }
  792. inline Dbtux::ConstData&
  793. Dbtux::ConstData::operator=(const Uint32* data)
  794. {
  795.   m_data = data;
  796.   return *this;
  797. }
  799. inline
  800. Dbtux::ConstData::operator const Uint32*() const
  801. {
  802.   return m_data;
  803. }
  805. inline Dbtux::ConstData&
  806. Dbtux::ConstData::operator+=(size_t n)
  807. {
  808.   m_data += n;
  809.   return *this;
  810. }
  812. inline const AttributeHeader&
  813. Dbtux::ConstData::ah() const
  814. {
  815.   return *reinterpret_cast<const AttributeHeader*>(m_data);
  816. }
  818. inline
  819. Dbtux::ConstData::ConstData(Data data) :
  820.   m_data(static_cast<Uint32*>(data))
  821. {
  822. }
  824. inline Dbtux::ConstData&
  825. Dbtux::ConstData::operator=(Data data)
  826. {
  827.   m_data = static_cast<Uint32*>(data);
  828.   return *this;
  829. }
  831. // Dbtux::TupLoc
  833. inline
  834. Dbtux::TupLoc::TupLoc() :
  835.   m_pageId1(RNIL >> 16),
  836.   m_pageId2(RNIL & 0xFFFF),
  837.   m_pageOffset(0)
  838. {
  839. }
  841. inline
  842. Dbtux::TupLoc::TupLoc(Uint32 pageId, Uint16 pageOffset) :
  843.   m_pageId1(pageId >> 16),
  844.   m_pageId2(pageId & 0xFFFF),
  845.   m_pageOffset(pageOffset)
  846. {
  847. }
  849. inline Uint32
  850. Dbtux::TupLoc::getPageId() const
  851. {
  852.   return (m_pageId1 << 16) | m_pageId2;
  853. }
  855. inline void
  856. Dbtux::TupLoc::setPageId(Uint32 pageId)
  857. {
  858.   m_pageId1 = (pageId >> 16);
  859.   m_pageId2 = (pageId & 0xFFFF);
  860. }
  862. inline Uint32
  863. Dbtux::TupLoc::getPageOffset() const
  864. {
  865.   return (Uint32)m_pageOffset;
  866. }
  868. inline void
  869. Dbtux::TupLoc::setPageOffset(Uint32 pageOffset)
  870. {
  871.   m_pageOffset = (Uint16)pageOffset;
  872. }
  874. inline bool
  875. Dbtux::TupLoc::operator==(const TupLoc& loc) const
  876. {
  877.   return
  878.     m_pageId1 == loc.m_pageId1 &&
  879.     m_pageId2 == loc.m_pageId2 &&
  880.     m_pageOffset == loc.m_pageOffset;
  881. }
  883. inline bool
  884. Dbtux::TupLoc::operator!=(const TupLoc& loc) const
  885. {
  886.   return ! (*this == loc);
  887. }
  889. // Dbtux::TreeEnt
  891. inline
  892. Dbtux::TreeEnt::TreeEnt() :
  893.   m_tupLoc(),
  894.   m_tupVersion(0),
  895.   m_fragBit(0)
  896. {
  897. }
  899. inline bool
  900. Dbtux::TreeEnt::eq(const TreeEnt ent) const
  901. {
  902.   return
  903.     m_tupLoc == ent.m_tupLoc &&
  904.     m_tupVersion == ent.m_tupVersion &&
  905.     m_fragBit == ent.m_fragBit;
  906. }
  908. inline int
  909. Dbtux::TreeEnt::cmp(const TreeEnt ent) const
  910. {
  911.   if (m_tupLoc.getPageId() < ent.m_tupLoc.getPageId())
  912.     return -1;
  913.   if (m_tupLoc.getPageId() > ent.m_tupLoc.getPageId())
  914.     return +1;
  915.   if (m_tupLoc.getPageOffset() < ent.m_tupLoc.getPageOffset())
  916.     return -1;
  917.   if (m_tupLoc.getPageOffset() > ent.m_tupLoc.getPageOffset())
  918.     return +1;
  919.   if (m_tupVersion < ent.m_tupVersion)
  920.     return -1;
  921.   if (m_tupVersion > ent.m_tupVersion)
  922.     return +1;
  923.   if (m_fragBit < ent.m_fragBit)
  924.     return -1;
  925.   if (m_fragBit > ent.m_fragBit)
  926.     return +1;
  927.   return 0;
  928. }
  930. // Dbtux::TreeNode
  932. inline
  933. Dbtux::TreeNode::TreeNode() :
  934.   m_side(2),
  935.   m_balance(0 + 1),
  936.   pad1(0),
  937.   m_occup(0),
  938.   m_nodeScan(RNIL)
  939. {
  940.   m_link[0] = NullTupLoc;
  941.   m_link[1] = NullTupLoc;
  942.   m_link[2] = NullTupLoc;
  943. }
  945. // Dbtux::TreeHead
  947. inline
  948. Dbtux::TreeHead::TreeHead() :
  949.   m_nodeSize(0),
  950.   m_prefSize(0),
  951.   m_minOccup(0),
  952.   m_maxOccup(0),
  953.   m_root()
  954. {
  955. }
  957. inline unsigned
  958. Dbtux::TreeHead::getSize(AccSize acc) const
  959. {
  960.   switch (acc) {
  961.   case AccNone:
  962.     return 0;
  963.   case AccHead:
  964.     return NodeHeadSize;
  965.   case AccPref:
  966.     return NodeHeadSize + m_prefSize + 2 * TreeEntSize;
  967.   case AccFull:
  968.     return m_nodeSize;
  969.   }
  970.   return 0;
  971. }
  973. inline Dbtux::Data
  974. Dbtux::TreeHead::getPref(TreeNode* node) const
  975. {
  976.   Uint32* ptr = (Uint32*)node + NodeHeadSize;
  977.   return ptr;
  978. }
  980. inline Dbtux::TreeEnt*
  981. Dbtux::TreeHead::getEntList(TreeNode* node) const
  982. {
  983.   Uint32* ptr = (Uint32*)node + NodeHeadSize + m_prefSize;
  984.   return (TreeEnt*)ptr;
  985. }
  987. // Dbtux::TreePos
  989. inline
  990. Dbtux::TreePos::TreePos() :
  991.   m_loc(),
  992.   m_pos(ZNIL),
  993.   m_match(false),
  994.   m_dir(255)
  995. {
  996. }
  998. // Dbtux::DescPage
  1000. inline
  1001. Dbtux::DescPage::DescPage() :
  1002.   m_nextPage(RNIL),
  1003.   m_numFree(ZNIL)
  1004. {
  1005.   for (unsigned i = 0; i < DescPageSize; i++) {
  1006. #ifdef VM_TRACE
  1007.     m_data[i] = 0x13571357;
  1008. #else
  1009.     m_data[i] = 0;
  1010. #endif
  1011.   }
  1012. }
  1014. // Dbtux::ScanOp
  1016. inline
  1017. Dbtux::ScanOp::ScanOp(ScanBoundPool& scanBoundPool) :
  1018.   m_state(Undef),
  1019.   m_lockwait(false),
  1020.   m_userPtr(RNIL),
  1021.   m_userRef(RNIL),
  1022.   m_tableId(RNIL),
  1023.   m_indexId(RNIL),
  1024.   m_fragPtrI(RNIL),
  1025.   m_transId1(0),
  1026.   m_transId2(0),
  1027.   m_savePointId(0),
  1028.   m_accLockOp(RNIL),
  1029.   m_readCommitted(0),
  1030.   m_lockMode(0),
  1031.   m_keyInfo(0),
  1032.   m_boundMin(scanBoundPool),
  1033.   m_boundMax(scanBoundPool),
  1034.   m_scanPos(),
  1035.   m_scanEnt(),
  1036.   m_nodeScan(RNIL),
  1037.   m_maxAccLockOps(0)
  1038. {
  1039.   m_bound[0] = &m_boundMin;
  1040.   m_bound[1] = &m_boundMax;
  1041.   m_boundCnt[0] = 0;
  1042.   m_boundCnt[1] = 0;
  1043. #ifdef VM_TRACE
  1044.   for (unsigned i = 0; i < MaxAccLockOps; i++) {
  1045.     m_accLockOps[i] = 0x1f1f1f1f;
  1046.   }
  1047. #endif
  1048. }
  1050. // Dbtux::Index
  1052. inline
  1053. Dbtux::Index::Index() :
  1054.   m_state(NotDefined),
  1055.   m_tableType(DictTabInfo::UndefTableType),
  1056.   m_tableId(RNIL),
  1057.   m_numFrags(0),
  1058.   m_descPage(RNIL),
  1059.   m_descOff(0),
  1060.   m_numAttrs(0),
  1061.   m_storeNullKey(false)
  1062. {
  1063.   for (unsigned i = 0; i < MaxIndexFragments; i++) {
  1064.     m_fragId[i] = ZNIL;
  1065.     m_fragPtrI[i] = RNIL;
  1066.   };
  1067. }
  1069. // Dbtux::Frag
  1071. inline
  1072. Dbtux::Frag::Frag(ArrayPool<ScanOp>& scanOpPool) :
  1073.   m_tableId(RNIL),
  1074.   m_indexId(RNIL),
  1075.   m_fragOff(ZNIL),
  1076.   m_fragId(ZNIL),
  1077.   m_descPage(RNIL),
  1078.   m_descOff(0),
  1079.   m_numAttrs(ZNIL),
  1080.   m_storeNullKey(false),
  1081.   m_tree(),
  1082.   m_freeLoc(),
  1083.   m_scanList(scanOpPool),
  1084.   m_tupIndexFragPtrI(RNIL)
  1085. {
  1086.   m_tupTableFragPtrI[0] = RNIL;
  1087.   m_tupTableFragPtrI[1] = RNIL;
  1088.   m_accTableFragPtrI[0] = RNIL;
  1089.   m_accTableFragPtrI[1] = RNIL;
  1090. }
  1092. // Dbtux::FragOp
  1094. inline
  1095. Dbtux::FragOp::FragOp() :
  1096.   m_userPtr(RNIL),
  1097.   m_userRef(RNIL),
  1098.   m_indexId(RNIL),
  1099.   m_fragId(ZNIL),
  1100.   m_fragPtrI(RNIL),
  1101.   m_fragNo(ZNIL),
  1102.   m_numAttrsRecvd(ZNIL)
  1103. {
  1104. }
  1106. // Dbtux::NodeHandle
  1108. inline
  1109. Dbtux::NodeHandle::NodeHandle(Frag& frag) :
  1110.   m_frag(frag),
  1111.   m_loc(),
  1112.   m_node(0)
  1113. {
  1114. }
  1116. inline
  1117. Dbtux::NodeHandle::NodeHandle(const NodeHandle& node) :
  1118.   m_frag(node.m_frag),
  1119.   m_loc(node.m_loc),
  1120.   m_node(node.m_node)
  1121. {
  1122. }
  1124. inline Dbtux::NodeHandle&
  1125. Dbtux::NodeHandle::operator=(const NodeHandle& node)
  1126. {
  1127.   ndbassert(&m_frag == &node.m_frag);
  1128.   m_loc = node.m_loc;
  1129.   m_node = node.m_node;
  1130.   return *this;
  1131. }
  1133. inline bool
  1134. Dbtux::NodeHandle::isNull()
  1135. {
  1136.   return m_node == 0;
  1137. }
  1139. inline Dbtux::TupLoc
  1140. Dbtux::NodeHandle::getLink(unsigned i)
  1141. {
  1142.   ndbrequire(i <= 2);
  1143.   return m_node->m_link[i];
  1144. }
  1146. inline unsigned
  1147. Dbtux::NodeHandle::getChilds()
  1148. {
  1149.   return (m_node->m_link[0] != NullTupLoc) + (m_node->m_link[1] != NullTupLoc);
  1150. }
  1152. inline unsigned
  1153. Dbtux::NodeHandle::getSide()
  1154. {
  1155.   return m_node->m_side;
  1156. }
  1158. inline unsigned
  1159. Dbtux::NodeHandle::getOccup()
  1160. {
  1161.   return m_node->m_occup;
  1162. }
  1164. inline int
  1165. Dbtux::NodeHandle::getBalance()
  1166. {
  1167.   return (int)m_node->m_balance - 1;
  1168. }
  1170. inline Uint32
  1171. Dbtux::NodeHandle::getNodeScan()
  1172. {
  1173.   return m_node->m_nodeScan;
  1174. }
  1176. inline void
  1177. Dbtux::NodeHandle::setLink(unsigned i, TupLoc loc)
  1178. {
  1179.   ndbrequire(i <= 2);
  1180.   m_node->m_link[i] = loc;
  1181. }
  1183. inline void
  1184. Dbtux::NodeHandle::setSide(unsigned i)
  1185. {
  1186.   ndbrequire(i <= 2);
  1187.   m_node->m_side = i;
  1188. }
  1190. inline void
  1191. Dbtux::NodeHandle::setOccup(unsigned n)
  1192. {
  1193.   TreeHead& tree = m_frag.m_tree;
  1194.   ndbrequire(n <= tree.m_maxOccup);
  1195.   m_node->m_occup = n;
  1196. }
  1198. inline void
  1199. Dbtux::NodeHandle::setBalance(int b)
  1200. {
  1201.   ndbrequire(abs(b) <= 1);
  1202.   m_node->m_balance = (unsigned)(b + 1);
  1203. }
  1205. inline void
  1206. Dbtux::NodeHandle::setNodeScan(Uint32 scanPtrI)
  1207. {
  1208.   m_node->m_nodeScan = scanPtrI;
  1209. }
  1211. inline Dbtux::Data
  1212. Dbtux::NodeHandle::getPref()
  1213. {
  1214.   TreeHead& tree = m_frag.m_tree;
  1215.   return tree.getPref(m_node);
  1216. }
  1218. inline Dbtux::TreeEnt
  1219. Dbtux::NodeHandle::getEnt(unsigned pos)
  1220. {
  1221.   TreeHead& tree = m_frag.m_tree;
  1222.   TreeEnt* entList = tree.getEntList(m_node);
  1223.   const unsigned occup = m_node->m_occup;
  1224.   ndbrequire(pos < occup);
  1225.   return entList[(1 + pos) % occup];
  1226. }
  1228. inline Dbtux::TreeEnt
  1229. Dbtux::NodeHandle::getMinMax(unsigned i)
  1230. {
  1231.   const unsigned occup = m_node->m_occup;
  1232.   ndbrequire(i <= 1 && occup != 0);
  1233.   return getEnt(i == 0 ? 0 : occup - 1);
  1234. }
  1236. // parameters for methods
  1238. #ifdef VM_TRACE
  1239. inline
  1240. Dbtux::PrintPar::PrintPar() :
  1241.   // caller fills in
  1242.   m_path(),
  1243.   m_side(255),
  1244.   m_parent(),
  1245.   // default return values
  1246.   m_depth(0),
  1247.   m_occup(0),
  1248.   m_ok(true)
  1249. {
  1250. }
  1251. #endif
  1253. // utils
  1255. inline Dbtux::DescEnt&
  1256. Dbtux::getDescEnt(Uint32 descPage, Uint32 descOff)
  1257. {
  1258.   DescPagePtr pagePtr;
  1259.   pagePtr.i = descPage;
  1260.   c_descPagePool.getPtr(pagePtr);
  1261.   ndbrequire(descOff < DescPageSize);
  1262.   DescEnt* descEnt = (DescEnt*)&pagePtr.p->m_data[descOff];
  1263.   return *descEnt;
  1264. }
  1266. inline Uint32
  1267. Dbtux::getTupAddr(const Frag& frag, TreeEnt ent)
  1268. {
  1269.   const Uint32 tableFragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
  1270.   const TupLoc tupLoc = ent.m_tupLoc;
  1271.   Uint32 tupAddr = NullTupAddr;
  1272.   c_tup->tuxGetTupAddr(tableFragPtrI, tupLoc.getPageId(), tupLoc.getPageOffset(), tupAddr);
  1273.   jamEntry();
  1274.   return tupAddr;
  1275. }
  1277. inline unsigned
  1278. Dbtux::min(unsigned x, unsigned y)
  1279. {
  1280.   return x < y ? x : y;
  1281. }
  1283. inline unsigned
  1284. Dbtux::max(unsigned x, unsigned y)
  1285. {
  1286.   return x > y ? x : y;
  1287. }
  1289. #endif