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

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 KERNEL_VM_METADATA_HPP
  14. #define KERNEL_VM_METADATA_HPP
  15. #include <ndb_types.h>
  16. #include <ndb_limits.h>
  17. #include <ErrorReporter.hpp>
  18. #include <signaldata/DictTabInfo.hpp>
  19. class SimulatedBlock;
  20. class Dbdict;
  21. class Dbdih;
  22. /*
  23.  * Common metadata for all blocks on the node.
  24.  *
  25.  * A database node has unique DICT and DIH instances.  Parts of their
  26.  * metadata are described by subclasses of MetaData.  Any block can
  27.  * access the metadata via a MetaData instance.
  28.  */
  29. class MetaData {
  30. public:
  31.   /*
  32.    * Methods return < 0 on error.
  33.    */
  34.   enum Error {
  35.     Locked = -1,
  36.     NotLocked = -2,
  37.     InvalidArgument = -3,
  38.     TableNotFound = -4,
  39.     InvalidTableVersion = -5,
  40.     AttributeNotFound = -6
  41.   };
  42.   /*
  43.    * Common data shared by all metadata instances.  Contains DICT and
  44.    * DIH pointers and counts of shared and exclusive locks.
  45.    */
  46.   class Common {
  47.   public:
  48.     Common(Dbdict& dbdict, Dbdih& dbdih);
  49.   private:
  50.     friend class MetaData;
  51.     Dbdict& m_dbdict;
  52.     Dbdih& m_dbdih;
  53.     unsigned m_lock[2];         // shared: 0 (false), exclusive: 1 (true)
  54.   };
  55.   /*
  56.    * Table metadata.  A base class of Dbdict::TableRecord.  This is
  57.    * actually fragment metadata but until "alter table" there is no
  58.    * difference.
  59.    */
  60.   class Table {
  61.   public:
  62.     /* Table id (array index in DICT and other blocks) */
  63.     Uint32 tableId;
  64.     /* Table version (incremented when tableId is re-used) */
  65.     Uint32 tableVersion;
  66.     /* Table name (may not be unique under "alter table") */
  67.     char tableName[MAX_TAB_NAME_SIZE];
  68.     /* Type of table or index */
  69.     DictTabInfo::TableType tableType;
  70.     /* Is table or index online (this flag is not used in DICT) */
  71.     bool online;
  72.     /* Primary table of index otherwise RNIL */
  73.     Uint32 primaryTableId;
  74.     /* Type of storage (memory/disk, not used) */
  75.     DictTabInfo::StorageType storageType;
  76.     /* Type of fragmentation (small/medium/large) */
  77.     DictTabInfo::FragmentType fragmentType;
  78.     /* Key type of fragmentation (pk/dist key/dist group) */
  79.     DictTabInfo::FragmentKeyType fragmentKeyType;
  80.     /* Global checkpoint identity when table created */
  81.     Uint32 gciTableCreated;
  82.     /* Number of attibutes in table */
  83.     Uint16 noOfAttributes;
  84.     /* Number of null attributes in table (should be computed) */
  85.     Uint16 noOfNullAttr;
  86.     /* Number of primary key attributes (should be computed) */
  87.     Uint16 noOfPrimkey;
  88.     /* Number of distinct character sets (computed) */
  89.     Uint16 noOfCharsets;
  90.     /* Length of primary key in words (should be computed) */
  91.     /* For ordered index this is tree node size in words */
  92.     Uint16 tupKeyLength;
  93.     /* K value for LH**3 algorithm (only 6 allowed currently) */
  94.     Uint8 kValue;
  95.     /* Local key length in words (currently 1) */
  96.     Uint8 localKeyLen;
  97.     /*
  98.      * Parameter for hash algorithm that specifies the load factor in
  99.      * percentage of fill level in buckets. A high value means we are
  100.      * splitting early and that buckets are only lightly used. A high
  101.      * value means that we have fill the buckets more and get more
  102.      * likelihood of overflow buckets.
  103.      */
  104.     Uint8 maxLoadFactor;
  105.     /*
  106.      * Used when shrinking to decide when to merge buckets.  Hysteresis
  107.      * is thus possible. Should be smaller but not much smaller than
  108.      * maxLoadFactor
  109.      */
  110.     Uint8 minLoadFactor;
  111.     /* Is the table logged (i.e. data survives system restart) */
  112.     bool storedTable;
  113.     /* Convenience routines */
  114.     bool isTable() const;
  115.     bool isIndex() const;
  116.     bool isUniqueIndex() const;
  117.     bool isNonUniqueIndex() const;
  118.     bool isHashIndex() const;
  119.     bool isOrderedIndex() const;
  120.   };
  121.   /*
  122.    * Attribute metadata.  A base class of Dbdict::AttributeRecord.
  123.    */
  124.   class Attribute {
  125.   public:
  126.     /* Attribute id within table (counted from 0) */
  127.     Uint16 attributeId;
  128.     /* Attribute number within tuple key (counted from 1) */
  129.     Uint16 tupleKey;
  130.     /* Attribute name (unique within table) */
  131.     char attributeName[MAX_ATTR_NAME_SIZE];
  132.     /* Attribute description (old-style packed descriptor) */
  133.     Uint32 attributeDescriptor;
  134.     /* Extended attributes */
  135.     Uint32 extType;
  136.     Uint32 extPrecision;
  137.     Uint32 extScale;
  138.     Uint32 extLength;
  139.     /* Autoincrement flag, only for ODBC/SQL */
  140.     bool autoIncrement;
  141.     /* Default value as null-terminated string, only for ODBC/SQL */
  142.     char defaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE];
  143.   };
  144.   /*
  145.    * Metadata is accessed via a MetaData instance.  The constructor
  146.    * needs a reference to MetaData::Common which can be obtained via
  147.    * the block.  The destructor releases any leftover locks.
  148.    */
  149.   MetaData(Common& common);
  150.   MetaData(SimulatedBlock* block);
  151.   ~MetaData();
  152.   /*
  153.    * Access methods.  Locking can be shared (read) or exclusive (write).
  154.    * Locking can be recursive (a count is kept).  Example (in a block):
  155.    *
  156.    *    MetaData md(this);
  157.    *    MetaData::Table table;
  158.    *    ret = md.lock(false);
  159.    *    ret = md.getTable(table, "SYSTAB_0");
  160.    *    ret = md.unlock();
  161.    */
  162.   int lock(bool exclusive);
  163.   int unlock(bool exclusive);
  164.   int getTable(MetaData::Table& table, Uint32 tableId, Uint32 tableVersion);
  165.   int getTable(MetaData::Table& table, const char* tableName);
  166.   int getAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, Uint32 attributeId);
  167.   int getAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, const char* attributeName);
  168. private:
  169.   Common& m_common;
  170.   unsigned m_lock[2];
  171. };
  172. // MetaData::Table
  173. inline bool
  174. MetaData::Table::isTable() const
  175. {
  176.   return DictTabInfo::isTable(tableType);
  177. }
  178. inline bool
  179. MetaData::Table::isIndex() const
  180. {
  181.   return DictTabInfo::isIndex(tableType);
  182. }
  183. inline bool
  184. MetaData::Table::isUniqueIndex() const
  185. {
  186.   return DictTabInfo::isUniqueIndex(tableType);
  187. }
  188. inline bool
  189. MetaData::Table::isNonUniqueIndex() const
  190. {
  191.   return DictTabInfo::isNonUniqueIndex(tableType);
  192. }
  193. inline bool
  194. MetaData::Table::isHashIndex() const
  195. {
  196.   return DictTabInfo::isHashIndex(tableType);
  197. }
  198. inline bool
  199. MetaData::Table::isOrderedIndex() const
  200. {
  201.   return DictTabInfo::isOrderedIndex(tableType);
  202. }
  203. #endif