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

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

MySQL数据库

开发平台：

Visual C++

DictTabInfo.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 DICT_TAB_INFO_HPP
  18. #define DICT_TAB_INFO_HPP
  20. #include "SignalData.hpp"
  21. #include <AttributeDescriptor.hpp>
  22. #include <SimpleProperties.hpp>
  23. #include <ndb_limits.h>
  24. #include <trigger_definitions.h>
  25. #include <NdbSqlUtil.hpp>
  27. #define DTIMAP(x, y, z) 
  28.   { DictTabInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, 0, (~0), 0 }
  30. #define DTIMAP2(x, y, z, u, v) 
  31.   { DictTabInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 }
  33. #define DTIMAPS(x, y, z, u, v) 
  34.   { DictTabInfo::y, offsetof(x, z), SimpleProperties::StringValue, u, v, 0 }
  36. #define DTIMAPB(x, y, z, u, v, l) 
  37.   { DictTabInfo::y, offsetof(x, z), SimpleProperties::BinaryValue, u, v, 
  38.                      offsetof(x, l) }
  40. #define DTIBREAK(x) 
  41.   { DictTabInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }
  43. class DictTabInfo {
  44.   /**
  45.    * Sender(s) / Reciver(s)
  46.    */
  47.   // Blocks
  48.   friend class Backup;
  49.   friend class Dbdict;
  50.   friend class Ndbcntr;
  51.   friend class Trix;
  52.   friend class DbUtil;
  53.   // API
  54.   friend class NdbSchemaOp;
  55.   
  56.   /**
  57.    * For printing
  58.    */
  59.   friend bool printDICTTABINFO(FILE * output, 
  60.                                const Uint32 * theData, 
  61.                                Uint32 len, 
  62.                                Uint16 receiverBlockNo);
  64. public:
  65.   enum RequestType {
  66.     CreateTableFromAPI  = 1,
  67.     AddTableFromDict    = 2, // Between DICT's
  68.     CopyTable           = 3, // Between DICT's
  69.     ReadTableFromDiskSR = 4, // Local in DICT
  70.     GetTabInfoConf      = 5,
  71.     AlterTableFromAPI  = 6
  72.   };
  74.   enum KeyValues {
  75.     TableName          = 1,  // String, Mandatory
  76.     TableId            = 2,  //Mandatory between DICT's otherwise not allowed
  77.     TableVersion       = 3,  //Mandatory between DICT's otherwise not allowed
  78.     TableLoggedFlag    = 4,  //Default Logged
  79.     NoOfKeyAttr        = 5,  //Default 1
  80.     NoOfAttributes     = 6,  //Mandatory
  81.     NoOfNullable       = 7,  //Deafult 0
  82.     NoOfVariable       = 8,  //Default 0
  83.     TableKValue        = 9,  //Default 6
  84.     MinLoadFactor      = 10, //Default 70
  85.     MaxLoadFactor      = 11, //Default 80
  86.     KeyLength          = 12, //Default 1  (No of words in primary key)
  87.     FragmentTypeVal    = 13, //Default AllNodesSmallTable
  88.     TableStorageVal    = 14, //Default StorageType::MainMemory
  89.     ScanOptimised      = 15, //Default updateOptimised
  90.     FragmentKeyTypeVal = 16, //Default PrimaryKey
  91.     SecondTableId      = 17, //Mandatory between DICT's otherwise not allowed
  92.     TableTypeVal       = 18, //Default TableType::UserTable
  93.     PrimaryTable       = 19, //Mandatory for index otherwise RNIL
  94.     PrimaryTableId     = 20, //ditto
  95.     IndexState         = 21,
  96.     InsertTriggerId    = 22,
  97.     UpdateTriggerId    = 23,
  98.     DeleteTriggerId    = 24,
  99.     CustomTriggerId    = 25,
  100.     FrmLen             = 26,
  101.     FrmData            = 27,
  102.     FragmentCount      = 128, // No of fragments in table (!fragment replicas)
  103.     TableEnd           = 999,
  104.     
  105.     AttributeName          = 1000, // String, Mandatory
  106.     AttributeId        = 1001, //Mandatory between DICT's otherwise not allowed
  107.     AttributeType          = 1002, //Default UnSignedType
  108.     AttributeSize          = 1003, //Default DictTabInfo::a32Bit
  109.     AttributeArraySize     = 1005, //Default 1
  110.     AttributeKeyFlag       = 1006, //Default noKey
  111.     AttributeStorage       = 1007, //Default MainMemory
  112.     AttributeNullableFlag  = 1008, //Default NotNullable
  113.     AttributeDGroup        = 1009, //Default NotDGroup
  114.     AttributeDKey          = 1010, //Default NotDKey
  115.     AttributeStoredInd     = 1011, //Default NotStored
  116.     AttributeGroup         = 1012, //Default 0
  117.     AttributeExtType       = 1013, //Default 0 (undefined)
  118.     AttributeExtPrecision  = 1014, //Default 0
  119.     AttributeExtScale      = 1015, //Default 0
  120.     AttributeExtLength     = 1016, //Default 0
  121.     AttributeAutoIncrement = 1017, //Default false
  122.     AttributeDefaultValue  = 1018, //Default value (printable string)
  123.     AttributeEnd           = 1999  //
  124.   };
  125.   // ----------------------------------------------------------------------
  126.   // Part of the protocol is that we only transfer parameters which do not
  127.   // have a default value. Thus the default values are part of the protocol.
  128.   // ----------------------------------------------------------------------
  130.   // FragmentKeyType constants
  131.   enum FragmentKeyType { 
  132.     PrimaryKey = 0,
  133.     DistributionKey = 1,
  134.     DistributionGroup = 2
  135.   };
  136.   
  137.   // FragmentType constants
  138.   enum FragmentType {
  139.     AllNodesSmallTable = 0,
  140.     AllNodesMediumTable = 1,
  141.     AllNodesLargeTable = 2,
  142.     SingleFragment = 3
  143.   };
  144.   
  145.   // TableStorage AND AttributeStorage constants
  146.   enum StorageType {
  147.     MainMemory = 0,
  148.     DiskMemory = 1
  149.   };
  151.   // TableType constants + objects
  152.   enum TableType {
  153.     UndefTableType = 0,
  154.     SystemTable = 1,
  155.     UserTable = 2,
  156.     UniqueHashIndex = 3,
  157.     HashIndex = 4,
  158.     UniqueOrderedIndex = 5,
  159.     OrderedIndex = 6,
  160.     // constant 10 hardcoded in Dbdict.cpp
  161.     HashIndexTrigger = 10 + TriggerType::SECONDARY_INDEX,
  162.     SubscriptionTrigger = 10 + TriggerType::SUBSCRIPTION,
  163.     ReadOnlyConstraint = 10 + TriggerType::READ_ONLY_CONSTRAINT,
  164.     IndexTrigger = 10 + TriggerType::ORDERED_INDEX
  165.   };
  166.   static inline bool
  167.   isTable(int tableType) {
  168.     return
  169.       tableType == SystemTable ||
  170.       tableType == UserTable;
  171.   }
  172.   static inline bool
  173.   isIndex(int tableType) {
  174.     return
  175.       tableType == UniqueHashIndex ||
  176.       tableType == HashIndex ||
  177.       tableType == UniqueOrderedIndex ||
  178.       tableType == OrderedIndex;
  179.   }
  180.   static inline bool
  181.   isUniqueIndex(int tableType) {
  182.     return
  183.       tableType == UniqueHashIndex ||
  184.       tableType == UniqueOrderedIndex;
  185.   }
  186.   static inline bool
  187.   isNonUniqueIndex(int tableType) {
  188.     return
  189.       tableType == HashIndex ||
  190.       tableType == OrderedIndex;
  191.   }
  192.   static inline bool
  193.   isHashIndex(int tableType) {
  194.     return
  195.       tableType == UniqueHashIndex ||
  196.       tableType == HashIndex;
  197.   }
  198.   static inline bool
  199.   isOrderedIndex(int tableType) {
  200.     return
  201.       tableType == UniqueOrderedIndex ||
  202.       tableType == OrderedIndex;
  203.   }
  205.   // Object state for translating from/to API
  206.   enum ObjectState {
  207.     StateUndefined = 0,
  208.     StateOffline = 1,
  209.     StateBuilding = 2,
  210.     StateDropping = 3,
  211.     StateOnline = 4,
  212.     StateBackup = 5,
  213.     StateBroken = 9
  214.   };
  216.   // Object store for translating from/to API
  217.   enum ObjectStore {
  218.     StoreUndefined = 0,
  219.     StoreTemporary = 1,
  220.     StorePermanent = 2
  221.   };
  222.   
  223.   // ScanOptimised constants
  224.   STATIC_CONST( updateOptimised = 0 );
  225.   STATIC_CONST( scanOptimised = 1 );
  226.   
  227.   // AttributeType constants
  228.   STATIC_CONST( SignedType = 0 );
  229.   STATIC_CONST( UnSignedType = 1 );
  230.   STATIC_CONST( FloatingPointType = 2 );
  231.   STATIC_CONST( StringType = 3 );
  232.   
  233.   // AttributeSize constants
  234.   STATIC_CONST( an8Bit = 3 );
  235.   STATIC_CONST( a16Bit = 4 );
  236.   STATIC_CONST( a32Bit = 5 );
  237.   STATIC_CONST( a64Bit = 6 );
  238.   STATIC_CONST( a128Bit = 7 );
  239.   
  240.   // AttributeDGroup constants
  241.   STATIC_CONST( NotDGroup = 0 );
  242.   STATIC_CONST( DGroup = 1 );
  243.   
  244.   // AttributeDKey constants
  245.   STATIC_CONST( NotDKey = 0 );
  246.   STATIC_CONST( DKey = 1 );
  247.   
  248.   // AttributeStoredInd constants
  249.   STATIC_CONST( NotStored = 0 );
  250.   STATIC_CONST( Stored = 1 );
  251.  
  252.   // Table data interpretation
  253.   struct Table {
  254.     char   TableName[MAX_TAB_NAME_SIZE];
  255.     Uint32 TableId;
  256.     Uint32 SecondTableId;
  257.     char   PrimaryTable[MAX_TAB_NAME_SIZE]; // Only used when "index"
  258.     Uint32 PrimaryTableId;
  259.     Uint32 TableLoggedFlag;
  260.     Uint32 NoOfKeyAttr;
  261.     Uint32 NoOfAttributes;
  262.     Uint32 NoOfNullable;
  263.     Uint32 NoOfVariable;
  264.     Uint32 TableKValue;
  265.     Uint32 MinLoadFactor;
  266.     Uint32 MaxLoadFactor;
  267.     Uint32 KeyLength;
  268.     Uint32 FragmentType;
  269.     Uint32 TableStorage;
  270.     Uint32 ScanOptimised;
  271.     Uint32 FragmentKeyType;
  272.     Uint32 TableType;
  273.     Uint32 TableVersion;
  274.     Uint32 IndexState;
  275.     Uint32 InsertTriggerId;
  276.     Uint32 UpdateTriggerId;
  277.     Uint32 DeleteTriggerId;
  278.     Uint32 CustomTriggerId;
  279.     Uint32 FrmLen;
  280.     char   FrmData[MAX_FRM_DATA_SIZE];
  281.     Uint32 FragmentCount;
  283.     void init();
  284.   };
  286.   static const
  287.   SimpleProperties::SP2StructMapping TableMapping[];
  289.   static const Uint32 TableMappingSize;
  291.   // AttributeExtType values
  292.   enum ExtType {
  293.     ExtUndefined = NdbSqlUtil::Type::Undefined,
  294.     ExtTinyint = NdbSqlUtil::Type::Tinyint,
  295.     ExtTinyunsigned = NdbSqlUtil::Type::Tinyunsigned,
  296.     ExtSmallint = NdbSqlUtil::Type::Smallint,
  297.     ExtSmallunsigned = NdbSqlUtil::Type::Smallunsigned,
  298.     ExtMediumint = NdbSqlUtil::Type::Mediumint,
  299.     ExtMediumunsigned = NdbSqlUtil::Type::Mediumunsigned,
  300.     ExtInt = NdbSqlUtil::Type::Int,
  301.     ExtUnsigned = NdbSqlUtil::Type::Unsigned,
  302.     ExtBigint = NdbSqlUtil::Type::Bigint,
  303.     ExtBigunsigned = NdbSqlUtil::Type::Bigunsigned,
  304.     ExtFloat = NdbSqlUtil::Type::Float,
  305.     ExtDouble = NdbSqlUtil::Type::Double,
  306.     ExtOlddecimal = NdbSqlUtil::Type::Olddecimal,
  307.     ExtOlddecimalunsigned = NdbSqlUtil::Type::Olddecimalunsigned,
  308.     ExtChar = NdbSqlUtil::Type::Char,
  309.     ExtVarchar = NdbSqlUtil::Type::Varchar,
  310.     ExtBinary = NdbSqlUtil::Type::Binary,
  311.     ExtVarbinary = NdbSqlUtil::Type::Varbinary,
  312.     ExtDatetime = NdbSqlUtil::Type::Datetime,
  313.     ExtDate = NdbSqlUtil::Type::Date,
  314.     ExtBlob = NdbSqlUtil::Type::Blob,
  315.     ExtText = NdbSqlUtil::Type::Text,
  316.     ExtTime = NdbSqlUtil::Type::Time,
  317.     ExtYear = NdbSqlUtil::Type::Year,
  318.     ExtTimestamp = NdbSqlUtil::Type::Timestamp
  319.   };
  321.   // Attribute data interpretation
  322.   struct Attribute {
  323.     char   AttributeName[MAX_TAB_NAME_SIZE];
  324.     Uint32 AttributeId;
  325.     Uint32 AttributeType;
  326.     Uint32 AttributeSize;
  327.     Uint32 AttributeArraySize;
  328.     Uint32 AttributeKeyFlag;
  329.     Uint32 AttributeStorage;
  330.     Uint32 AttributeNullableFlag;
  331.     Uint32 AttributeDGroup;
  332.     Uint32 AttributeDKey;
  333.     Uint32 AttributeStoredInd;
  334.     Uint32 AttributeGroup;
  335.     Uint32 AttributeExtType;
  336.     Uint32 AttributeExtPrecision;
  337.     Uint32 AttributeExtScale;
  338.     Uint32 AttributeExtLength;
  339.     Uint32 AttributeAutoIncrement;
  340.     char   AttributeDefaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE];
  341.     
  342.     void init();
  344.     inline
  345.     Uint32 sizeInWords()
  346.     {
  347.       return ((1 << AttributeSize) * AttributeArraySize + 31) >> 5;
  348.     }
  350.     // translate to old kernel types and sizes
  351.     inline bool
  352.     translateExtType() {
  353.       switch (AttributeExtType) {
  354.       case DictTabInfo::ExtUndefined:
  355.         break;
  356.       case DictTabInfo::ExtTinyint:
  357.         AttributeType = DictTabInfo::SignedType;
  358.         AttributeSize = DictTabInfo::an8Bit;
  359.         AttributeArraySize = AttributeExtLength;
  360. return true;
  361.       case DictTabInfo::ExtTinyunsigned:
  362.         AttributeType = DictTabInfo::UnSignedType;
  363.         AttributeSize = DictTabInfo::an8Bit;
  364.         AttributeArraySize = AttributeExtLength;
  365. return true;
  366.       case DictTabInfo::ExtSmallint:
  367.         AttributeType = DictTabInfo::SignedType;
  368.         AttributeSize = DictTabInfo::a16Bit;
  369.         AttributeArraySize = AttributeExtLength;
  370. return true;
  371.       case DictTabInfo::ExtSmallunsigned:
  372.         AttributeType = DictTabInfo::UnSignedType;
  373.         AttributeSize = DictTabInfo::a16Bit;
  374.         AttributeArraySize = AttributeExtLength;
  375. return true;
  376.       case DictTabInfo::ExtMediumint:
  377.         AttributeType = DictTabInfo::SignedType;
  378.         AttributeSize = DictTabInfo::an8Bit;
  379.         AttributeArraySize = 3 * AttributeExtLength;
  380. return true;
  381.       case DictTabInfo::ExtMediumunsigned:
  382.         AttributeType = DictTabInfo::UnSignedType;
  383.         AttributeSize = DictTabInfo::an8Bit;
  384.         AttributeArraySize = 3 * AttributeExtLength;
  385. return true;
  386.       case DictTabInfo::ExtInt:
  387.         AttributeType = DictTabInfo::SignedType;
  388.         AttributeSize = DictTabInfo::a32Bit;
  389.         AttributeArraySize = AttributeExtLength;
  390.         return true;
  391.       case DictTabInfo::ExtUnsigned:
  392.         AttributeType = DictTabInfo::UnSignedType;
  393.         AttributeSize = DictTabInfo::a32Bit;
  394.         AttributeArraySize = AttributeExtLength;
  395.         return true;
  396.       case DictTabInfo::ExtBigint:
  397.         AttributeType = DictTabInfo::SignedType;
  398.         AttributeSize = DictTabInfo::a64Bit;
  399.         AttributeArraySize = AttributeExtLength;
  400.         return true;
  401.       case DictTabInfo::ExtBigunsigned:
  402.         AttributeType = DictTabInfo::UnSignedType;
  403.         AttributeSize = DictTabInfo::a64Bit;
  404.         AttributeArraySize = AttributeExtLength;
  405.         return true;
  406.       case DictTabInfo::ExtFloat:
  407.         AttributeType = DictTabInfo::FloatingPointType;
  408.         AttributeSize = DictTabInfo::a32Bit;
  409.         AttributeArraySize = AttributeExtLength;
  410.         return true;
  411.       case DictTabInfo::ExtDouble:
  412.         AttributeType = DictTabInfo::FloatingPointType;
  413.         AttributeSize = DictTabInfo::a64Bit;
  414.         AttributeArraySize = AttributeExtLength;
  415.         return true;
  416.       case DictTabInfo::ExtOlddecimal:
  417.         AttributeType = DictTabInfo::StringType;
  418.         AttributeSize = DictTabInfo::an8Bit;
  419.         AttributeArraySize =
  420.           (1 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
  421.           AttributeExtLength;
  422.         return true;
  423.       case DictTabInfo::ExtOlddecimalunsigned:
  424.         AttributeType = DictTabInfo::StringType;
  425.         AttributeSize = DictTabInfo::an8Bit;
  426.         AttributeArraySize =
  427.           (0 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
  428.           AttributeExtLength;
  429.         return true;
  430.       case DictTabInfo::ExtChar:
  431.       case DictTabInfo::ExtBinary:
  432.         AttributeType = DictTabInfo::StringType;
  433.         AttributeSize = DictTabInfo::an8Bit;
  434.         AttributeArraySize = AttributeExtLength;
  435.         return true;
  436.       case DictTabInfo::ExtVarchar:
  437.       case DictTabInfo::ExtVarbinary:
  438.         AttributeType = DictTabInfo::StringType;
  439.         AttributeSize = DictTabInfo::an8Bit;
  440.         AttributeArraySize = AttributeExtLength + 2;
  441.         return true;
  442.       case DictTabInfo::ExtDatetime:
  443.         AttributeType = DictTabInfo::StringType;
  444.         AttributeSize = DictTabInfo::an8Bit;
  445.         AttributeArraySize = 8 * AttributeExtLength;
  446.         return true;
  447.       case DictTabInfo::ExtDate:
  448.         AttributeType = DictTabInfo::StringType;
  449.         AttributeSize = DictTabInfo::an8Bit;
  450.         AttributeArraySize = 3 * AttributeExtLength;
  451.         return true;
  452.       case DictTabInfo::ExtBlob:
  453.       case DictTabInfo::ExtText:
  454.         AttributeType = DictTabInfo::StringType;
  455.         AttributeSize = DictTabInfo::an8Bit;
  456.         // head + inline part [ attr precision lower half ]
  457.         AttributeArraySize = (NDB_BLOB_HEAD_SIZE << 2) + (AttributeExtPrecision & 0xFFFF);
  458.         return true;
  459.       case DictTabInfo::ExtTime:
  460.         AttributeType = DictTabInfo::StringType;
  461.         AttributeSize = DictTabInfo::an8Bit;
  462.         AttributeArraySize = 3 * AttributeExtLength;
  463.         return true;
  464.       case DictTabInfo::ExtYear:
  465.         AttributeType = DictTabInfo::StringType;
  466.         AttributeSize = DictTabInfo::an8Bit;
  467.         AttributeArraySize = 1 * AttributeExtLength;
  468.         return true;
  469.       case DictTabInfo::ExtTimestamp:
  470.         AttributeType = DictTabInfo::StringType;
  471.         AttributeSize = DictTabInfo::an8Bit;
  472.         AttributeArraySize = 4 * AttributeExtLength;
  473.         return true;
  474.       };
  475.       return false;
  476.     }
  477.     
  478.     inline void print(FILE *out) {
  479.       fprintf(out, "AttributeId = %dn", AttributeId);
  480.       fprintf(out, "AttributeType = %dn", AttributeType);
  481.       fprintf(out, "AttributeSize = %dn", AttributeSize);
  482.       fprintf(out, "AttributeArraySize = %dn", AttributeArraySize);
  483.       fprintf(out, "AttributeKeyFlag = %dn", AttributeKeyFlag);
  484.       fprintf(out, "AttributeStorage = %dn", AttributeStorage);
  485.       fprintf(out, "AttributeNullableFlag = %dn", AttributeNullableFlag);
  486.       fprintf(out, "AttributeDGroup = %dn", AttributeDGroup);
  487.       fprintf(out, "AttributeDKey = %dn", AttributeDKey);
  488.       fprintf(out, "AttributeStoredInd = %dn", AttributeStoredInd);
  489.       fprintf(out, "AttributeGroup = %dn", AttributeGroup);
  490.       fprintf(out, "AttributeAutoIncrement = %dn", AttributeAutoIncrement);
  491.       fprintf(out, "AttributeExtType = %dn", AttributeExtType);
  492.       fprintf(out, "AttributeExtPrecision = %dn", AttributeExtPrecision);
  493.       fprintf(out, "AttributeExtScale = %dn", AttributeExtScale);
  494.       fprintf(out, "AttributeExtLength = %dn", AttributeExtLength);
  495.       fprintf(out, "AttributeDefaultValue = "%s"n",
  496.         AttributeDefaultValue ? AttributeDefaultValue : "");
  497.     }
  498.   };
  499.   
  500.   static const
  501.   SimpleProperties::SP2StructMapping AttributeMapping[];
  503.   static const Uint32 AttributeMappingSize;
  505.   // Signal constants
  506.   STATIC_CONST( DataLength = 20 );
  507.   STATIC_CONST( HeaderLength = 5 );
  509. private:  
  510.   Uint32 senderRef;
  511.   Uint32 senderData;
  512.   Uint32 requestType;
  513.   Uint32 totalLen; 
  514.   Uint32 offset; 
  515.   
  516.   /**
  517.    * Length of this data = signal->length() - HeaderLength
  518.    * Sender block ref = signal->senderBlockRef()
  519.    */
  520.   
  521.   Uint32 tabInfoData[DataLength];
  522. };
  524. #endif