/*
   Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
*/

#ifndef DICT_TAB_INFO_HPP
#define DICT_TAB_INFO_HPP

#include "SignalData.hpp"
#include <AttributeDescriptor.hpp>
#include <SimpleProperties.hpp>
#include <ndb_limits.h>
#include <NdbSqlUtil.hpp>
#include <ndb_global.h>

#define JAM_FILE_ID 87


#ifndef my_decimal_h

// sql/my_decimal.h requires many more sql/*.h new to ndb
// for now, copy the bit we need  TODO proper fix

#define DECIMAL_MAX_FIELD_SIZE ((9 * 9) - (2 * 8))

#ifndef DECIMAL_NOT_SPECIFIED
#define DECIMAL_NOT_SPECIFIED 31
#endif

C_MODE_START
extern int decimal_bin_size(int, int);
C_MODE_END

inline int my_decimal_get_binary_size(uint precision, uint scale)
{
  return decimal_bin_size((int)precision, (int)scale);
}

#endif

#define DTIMAP(x, y, z) \
  { DictTabInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, 0, UINT_MAX32, 0 }

#define DTIMAP2(x, y, z, u, v) \
  { DictTabInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 }

#define DTIMAPS(x, y, z, u, v) \
  { DictTabInfo::y, my_offsetof(x, z), SimpleProperties::StringValue, u, v, 0 }

#define DTIMAPB(x, y, z, u, v, l) \
  { DictTabInfo::y, my_offsetof(x, z), SimpleProperties::BinaryValue, u, v, \
                     my_offsetof(x, l) }

#define DTIBREAK(x) \
  { DictTabInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }

class DictTabInfo {
  /**
   * Sender(s) / Reciver(s)
   */
  // Blocks
  friend class Backup;
  friend class Dbdict;
  friend class Ndbcntr;
  friend class Trix;
  friend class DbUtil;
  // API
  friend class NdbSchemaOp;
  
  /**
   * For printing
   */
  friend bool printDICTTABINFO(FILE * output, 
                               const Uint32 * theData, 
                               Uint32 len, 
                               Uint16 receiverBlockNo);

public:
  enum RequestType {
    CreateTableFromAPI  = 1,
    AddTableFromDict    = 2, // Between DICT's
    CopyTable           = 3, // Between DICT's
    ReadTableFromDiskSR = 4, // Local in DICT
    GetTabInfoConf      = 5,
    AlterTableFromAPI   = 6
  };
  
  enum KeyValues {
    TableName          = 1,  // String, Mandatory
    TableId            = 2,  //Mandatory between DICT's otherwise not allowed
    TableVersion       = 3,  //Mandatory between DICT's otherwise not allowed
    TableLoggedFlag    = 4,  //Default Logged
    NoOfKeyAttr        = 5,  //Default 1
    NoOfAttributes     = 6,  //Mandatory
    NoOfNullable       = 7,  //Deafult 0
    NoOfVariable       = 8,  //Default 0
    TableKValue        = 9,  //Default 6
    MinLoadFactor      = 10, //Default 70
    MaxLoadFactor      = 11, //Default 80
    KeyLength          = 12, //Default 1  (No of words in primary key)
    FragmentTypeVal    = 13, //Default AllNodesSmallTable
    TableTypeVal       = 18, //Default TableType::UserTable
    PrimaryTable       = 19, //Mandatory for index otherwise RNIL
    PrimaryTableId     = 20, //ditto
    IndexState         = 21,
    InsertTriggerId    = 22,
    UpdateTriggerId    = 23,
    DeleteTriggerId    = 24,
    CustomTriggerId    = 25,
    FrmLen             = 26,
    FrmData            = 27,

    TableTemporaryFlag = 28,  //Default not Temporary
    ForceVarPartFlag   = 29,

    FragmentCount      = 128, // No of fragments in table (!fragment replicas)
    FragmentDataLen    = 129,
    FragmentData       = 130, // CREATE_FRAGMENTATION reply
    TablespaceId       = 131,
    TablespaceVersion  = 132,
    TablespaceDataLen  = 133,
    TablespaceData     = 134,
    RangeListDataLen   = 135,
    RangeListData      = 136,
    ReplicaDataLen     = 137,
    ReplicaData        = 138,
    MaxRowsLow         = 139,
    MaxRowsHigh        = 140,
    DefaultNoPartFlag  = 141,
    LinearHashFlag     = 142,
    MinRowsLow         = 143,
    MinRowsHigh        = 144,

    RowGCIFlag         = 150,
    RowChecksumFlag    = 151,
    
    SingleUserMode     = 152,

    HashMapObjectId    = 153,
    HashMapVersion     = 154,

    TableStorageType   = 155,

    ExtraRowGCIBits    = 156,
    ExtraRowAuthorBits = 157,

    TableEnd           = 999,
    
    AttributeName          = 1000, // String, Mandatory
    AttributeId        = 1001, //Mandatory between DICT's otherwise not allowed
    AttributeType          = 1002, //for osu 4.1->5.0.x
    AttributeSize          = 1003, //Default DictTabInfo::a32Bit
    AttributeArraySize     = 1005, //Default 1
    AttributeKeyFlag       = 1006, //Default noKey
    AttributeStorageType   = 1007, //Default NDB_STORAGETYPE_MEMORY
    AttributeNullableFlag  = 1008, //Default NotNullable
    AttributeDynamic       = 1009, //Default not dynamic
    AttributeDKey          = 1010, //Default NotDKey
    AttributeExtType       = 1013, //Default ExtUnsigned
    AttributeExtPrecision  = 1014, //Default 0
    AttributeExtScale      = 1015, //Default 0
    AttributeExtLength     = 1016, //Default 0
    AttributeAutoIncrement = 1017, //Default false
    AttributeArrayType     = 1019, //Default NDB_ARRAYTYPE_FIXED
    AttributeDefaultValueLen = 1020, //Actual Length saved in AttributeDefaultValue
    /* Default value (Binary type, not printable as string),
     * For backward compatibility, the new keyValue
     * (not use the old keyValue 1018) is added
       when restoring data from low backup version data.
    */
    AttributeDefaultValue = 1021,
    AttributeEnd           = 1999  //
  };
  // ----------------------------------------------------------------------
  // Part of the protocol is that we only transfer parameters which do not
  // have a default value. Thus the default values are part of the protocol.
  // ----------------------------------------------------------------------


  
  // FragmentType constants
  enum FragmentType {
    AllNodesSmallTable = 0,
    AllNodesMediumTable = 1,
    AllNodesLargeTable = 2,
    SingleFragment = 3,
    DistrKeyHash = 4,
    DistrKeyLin = 5,
    UserDefined = 6,
    DistrKeyOrderedIndex = 8, // alias
    HashMapPartition = 9
  };
  
  // TableType constants + objects
  enum TableType {
    UndefTableType = 0,
    SystemTable = 1,
    UserTable = 2,
    UniqueHashIndex = 3,
    HashIndex = 4,
    UniqueOrderedIndex = 5,
    OrderedIndex = 6,
    // constant 10 hardcoded in Dbdict.cpp
    HashIndexTrigger = 11,
    SubscriptionTrigger = 16,
    ReadOnlyConstraint = 17,
    IndexTrigger = 18,
    ReorgTrigger = 19,
    
    Tablespace = 20,        ///< Tablespace
    LogfileGroup = 21,      ///< Logfile group
    Datafile = 22,          ///< Datafile
    Undofile = 23,          ///< Undofile
    HashMap = 24,

    ForeignKey = 25,        // The definition
    FKParentTrigger = 26,
    FKChildTrigger = 27,

    SchemaTransaction = 30
  };

  // used 1) until type BlobTable added 2) in upgrade code
  static bool
  isBlobTableName(const char* name, Uint32* ptab_id = 0, Uint32* pcol_no = 0);
  
  static inline bool
  isTable(int tableType) {
    return
      tableType == SystemTable ||
      tableType == UserTable;
  }
  static inline bool
  isIndex(int tableType) {
    return
      tableType == UniqueHashIndex ||
      tableType == HashIndex ||
      tableType == UniqueOrderedIndex ||
      tableType == OrderedIndex;
  }
  static inline bool
  isUniqueIndex(int tableType) {
    return
      tableType == UniqueHashIndex ||
      tableType == UniqueOrderedIndex;
  }
  static inline bool
  isNonUniqueIndex(int tableType) {
    return
      tableType == HashIndex ||
      tableType == OrderedIndex;
  }
  static inline bool
  isHashIndex(int tableType) {
    return
      tableType == UniqueHashIndex ||
      tableType == HashIndex;
  }
  static inline bool
  isOrderedIndex(int tableType) {
    return
      tableType == UniqueOrderedIndex ||
      tableType == OrderedIndex;
  }
  static inline bool
  isTrigger(int tableType) {
    return
      tableType == HashIndexTrigger ||
      tableType == SubscriptionTrigger ||
      tableType == ReadOnlyConstraint ||
      tableType == IndexTrigger ||
      tableType == ReorgTrigger ||
      tableType == FKParentTrigger ||
      tableType == FKChildTrigger;
  }
  static inline bool
  isFilegroup(int tableType) {
    return
      tableType == Tablespace ||
      tableType == LogfileGroup;
  }

  static inline bool
  isFile(int tableType) {
    return
      tableType == Datafile||
      tableType == Undofile;
  }

  static inline bool
  isHashMap(int tableType) {
    return
      tableType == HashMap;
  }

  static inline bool
  isForeignKey(int tableType) {
    return tableType == ForeignKey;
  }

  // Object state for translating from/to API
  enum ObjectState {
    StateUndefined = 0,
    StateOffline = 1,
    StateBuilding = 2,
    StateDropping = 3,
    StateOnline = 4,
    StateBackup = 5,
    StateBroken = 9
  };

  // Object store for translating from/to API
  enum ObjectStore {
    StoreUndefined = 0,
    StoreNotLogged = 1,
    StorePermanent = 2
  };
  
  // AttributeSize constants
  STATIC_CONST( aBit = 0 );
  STATIC_CONST( an8Bit = 3 );
  STATIC_CONST( a16Bit = 4 );
  STATIC_CONST( a32Bit = 5 );
  STATIC_CONST( a64Bit = 6 );
  STATIC_CONST( a128Bit = 7 );
    
  // Table data interpretation
  struct Table {
    char   TableName[MAX_TAB_NAME_SIZE];
    Uint32 TableId;
    char   PrimaryTable[MAX_TAB_NAME_SIZE]; // Only used when "index"
    Uint32 PrimaryTableId;
    Uint32 TableLoggedFlag;
    Uint32 TableTemporaryFlag;
    Uint32 ForceVarPartFlag;
    Uint32 NoOfKeyAttr;
    Uint32 NoOfAttributes;
    Uint32 NoOfNullable;
    Uint32 NoOfVariable;
    Uint32 TableKValue;
    Uint32 MinLoadFactor;
    Uint32 MaxLoadFactor;
    Uint32 KeyLength;
    Uint32 FragmentType;
    Uint32 TableType;
    Uint32 TableVersion;
    Uint32 IndexState;
    Uint32 InsertTriggerId;
    Uint32 UpdateTriggerId;
    Uint32 DeleteTriggerId;
    Uint32 CustomTriggerId;
    Uint32 TablespaceId;
    Uint32 TablespaceVersion;
    Uint32 DefaultNoPartFlag;
    Uint32 LinearHashFlag;
    /*
      TODO RONM:
      We need to replace FRM, Fragment Data, Tablespace Data and in
      very particular RangeListData with dynamic arrays
    */
    Uint32 FrmLen;
    char   FrmData[MAX_FRM_DATA_SIZE];
    Uint32 FragmentCount;
    Uint32 ReplicaDataLen;
    Uint16 ReplicaData[MAX_FRAGMENT_DATA_ENTRIES];
    Uint32 FragmentDataLen;
    Uint16 FragmentData[3*MAX_NDB_PARTITIONS];

    Uint32 MaxRowsLow;
    Uint32 MaxRowsHigh;
    Uint32 MinRowsLow;
    Uint32 MinRowsHigh;

    Uint32 TablespaceDataLen;
    Uint32 TablespaceData[2*MAX_NDB_PARTITIONS];
    Uint32 RangeListDataLen;
    Uint32 RangeListData[2*MAX_NDB_PARTITIONS*2];
    
    Uint32 RowGCIFlag;
    Uint32 RowChecksumFlag;

    Uint32 SingleUserMode;

    Uint32 HashMapObjectId;
    Uint32 HashMapVersion;

    Uint32 TableStorageType;

    Uint32 ExtraRowGCIBits;
    Uint32 ExtraRowAuthorBits;

    Table() {}
    void init();
  };

  static const
  SimpleProperties::SP2StructMapping TableMapping[];

  static const Uint32 TableMappingSize;

  // AttributeExtType values
  enum ExtType {
    ExtUndefined = NdbSqlUtil::Type::Undefined,
    ExtTinyint = NdbSqlUtil::Type::Tinyint,
    ExtTinyunsigned = NdbSqlUtil::Type::Tinyunsigned,
    ExtSmallint = NdbSqlUtil::Type::Smallint,
    ExtSmallunsigned = NdbSqlUtil::Type::Smallunsigned,
    ExtMediumint = NdbSqlUtil::Type::Mediumint,
    ExtMediumunsigned = NdbSqlUtil::Type::Mediumunsigned,
    ExtInt = NdbSqlUtil::Type::Int,
    ExtUnsigned = NdbSqlUtil::Type::Unsigned,
    ExtBigint = NdbSqlUtil::Type::Bigint,
    ExtBigunsigned = NdbSqlUtil::Type::Bigunsigned,
    ExtFloat = NdbSqlUtil::Type::Float,
    ExtDouble = NdbSqlUtil::Type::Double,
    ExtOlddecimal = NdbSqlUtil::Type::Olddecimal,
    ExtOlddecimalunsigned = NdbSqlUtil::Type::Olddecimalunsigned,
    ExtDecimal = NdbSqlUtil::Type::Decimal,
    ExtDecimalunsigned = NdbSqlUtil::Type::Decimalunsigned,
    ExtChar = NdbSqlUtil::Type::Char,
    ExtVarchar = NdbSqlUtil::Type::Varchar,
    ExtBinary = NdbSqlUtil::Type::Binary,
    ExtVarbinary = NdbSqlUtil::Type::Varbinary,
    ExtDatetime = NdbSqlUtil::Type::Datetime,
    ExtDate = NdbSqlUtil::Type::Date,
    ExtBlob = NdbSqlUtil::Type::Blob,
    ExtText = NdbSqlUtil::Type::Text,
    ExtBit = NdbSqlUtil::Type::Bit,
    ExtLongvarchar = NdbSqlUtil::Type::Longvarchar,
    ExtLongvarbinary = NdbSqlUtil::Type::Longvarbinary,
    ExtTime = NdbSqlUtil::Type::Time,
    ExtYear = NdbSqlUtil::Type::Year,
    ExtTimestamp = NdbSqlUtil::Type::Timestamp,
    ExtTime2 = NdbSqlUtil::Type::Time2,
    ExtDatetime2 = NdbSqlUtil::Type::Datetime2,
    ExtTimestamp2 = NdbSqlUtil::Type::Timestamp2
  };

  // Attribute data interpretation
  struct Attribute {
    char   AttributeName[MAX_TAB_NAME_SIZE];
    Uint32 AttributeId;
    Uint32 AttributeType; // for osu 4.1->5.0.x
    Uint32 AttributeSize;
    Uint32 AttributeArraySize;
    Uint32 AttributeArrayType;
    Uint32 AttributeKeyFlag;
    Uint32 AttributeNullableFlag;
    Uint32 AttributeDKey;
    Uint32 AttributeExtType;
    Uint32 AttributeExtPrecision;
    Uint32 AttributeExtScale;
    Uint32 AttributeExtLength;
    Uint32 AttributeAutoIncrement;
    Uint32 AttributeStorageType;
    Uint32 AttributeDynamic;
    Uint32 AttributeDefaultValueLen;  //byte sizes
    Uint8  AttributeDefaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE];
    
    Attribute() {}
    void init();

    inline
    Uint32 sizeInWords()
    {
      return ((1 << AttributeSize) * AttributeArraySize + 31) >> 5;
    }

    // compute old-sty|e attribute size and array size
    inline bool
    translateExtType() {
      switch (AttributeExtType) {
      case DictTabInfo::ExtUndefined:
        return false;
      case DictTabInfo::ExtTinyint:
      case DictTabInfo::ExtTinyunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength;
	break;
      case DictTabInfo::ExtSmallint:
      case DictTabInfo::ExtSmallunsigned:
        AttributeSize = DictTabInfo::a16Bit;
        AttributeArraySize = AttributeExtLength;
	break;
      case DictTabInfo::ExtMediumint:
      case DictTabInfo::ExtMediumunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 3 * AttributeExtLength;
	break;
      case DictTabInfo::ExtInt:	
      case DictTabInfo::ExtUnsigned:
        AttributeSize = DictTabInfo::a32Bit;
        AttributeArraySize = AttributeExtLength;
        break;
      case DictTabInfo::ExtBigint:
      case DictTabInfo::ExtBigunsigned:
        AttributeSize = DictTabInfo::a64Bit;
        AttributeArraySize = AttributeExtLength;
        break;
      case DictTabInfo::ExtFloat:
        AttributeSize = DictTabInfo::a32Bit;
        AttributeArraySize = AttributeExtLength;
        break;
      case DictTabInfo::ExtDouble:
        AttributeSize = DictTabInfo::a64Bit;
        AttributeArraySize = AttributeExtLength;
        break;
      case DictTabInfo::ExtOlddecimal:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize =
          (1 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
          AttributeExtLength;
        break;
      case DictTabInfo::ExtOlddecimalunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize =
          (0 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
          AttributeExtLength;
        break;
      case DictTabInfo::ExtDecimal:
      case DictTabInfo::ExtDecimalunsigned:
        {
          // copy from Field_new_decimal ctor
          uint precision = AttributeExtPrecision;
          uint scale = AttributeExtScale;
          if (precision > DECIMAL_MAX_FIELD_SIZE ||
              scale >= DECIMAL_NOT_SPECIFIED)
            return false;
          uint bin_size = my_decimal_get_binary_size(precision, scale);
          AttributeSize = DictTabInfo::an8Bit;
          AttributeArraySize = bin_size * AttributeExtLength;
        }
        break;
      case DictTabInfo::ExtChar:
      case DictTabInfo::ExtBinary:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength;
        break;
      case DictTabInfo::ExtVarchar:
      case DictTabInfo::ExtVarbinary:
        if (AttributeExtLength > 0xff)
          return false;
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength + 1;
        break;
      case DictTabInfo::ExtDatetime:
        // to fix
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 8 * AttributeExtLength;
        break;
      case DictTabInfo::ExtDate:
        // to fix
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 3 * AttributeExtLength;
        break;
      case DictTabInfo::ExtBlob:
      case DictTabInfo::ExtText:
        AttributeSize = DictTabInfo::an8Bit;
        if (unlikely(AttributeArrayType == NDB_ARRAYTYPE_FIXED)) {
          // head + inline part (length in precision lower half)
          AttributeArraySize = (NDB_BLOB_V1_HEAD_SIZE << 2) +
                               (AttributeExtPrecision & 0xFFFF);
        } else {
          AttributeArraySize = (NDB_BLOB_V2_HEAD_SIZE << 2) +
                               (AttributeExtPrecision & 0xFFFF);
        }
        break;
      case DictTabInfo::ExtBit:
	AttributeSize = DictTabInfo::aBit;
	AttributeArraySize = AttributeExtLength;
	break;
      case DictTabInfo::ExtLongvarchar:
      case DictTabInfo::ExtLongvarbinary:
        if (AttributeExtLength > 0xffff)
          return false;
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength + 2;
        break;
      case DictTabInfo::ExtTime:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 3 * AttributeExtLength;
        break;
      case DictTabInfo::ExtYear:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 1 * AttributeExtLength;
        break;
      case DictTabInfo::ExtTimestamp:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 4 * AttributeExtLength;
        break;
      // fractional time types, see wl#946
      case DictTabInfo::ExtTime2:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = (3 + (1 + AttributeExtPrecision) / 2)
                             * AttributeExtLength;
        break;
      case DictTabInfo::ExtDatetime2:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = (5 + (1 + AttributeExtPrecision) / 2)
                             * AttributeExtLength;
        break;
      case DictTabInfo::ExtTimestamp2:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = (4 + (1 + AttributeExtPrecision) / 2)
                             * AttributeExtLength;
        break;
      default:
        return false;
      };
      return true;
    }
    
    inline void print(FILE *out) {
      fprintf(out, "AttributeId = %d\n", AttributeId);
      fprintf(out, "AttributeType = %d\n", AttributeType);
      fprintf(out, "AttributeSize = %d\n", AttributeSize);
      fprintf(out, "AttributeArraySize = %d\n", AttributeArraySize);
      fprintf(out, "AttributeArrayType = %d\n", AttributeArrayType);
      fprintf(out, "AttributeKeyFlag = %d\n", AttributeKeyFlag);
      fprintf(out, "AttributeStorageType = %d\n", AttributeStorageType);
      fprintf(out, "AttributeNullableFlag = %d\n", AttributeNullableFlag);
      fprintf(out, "AttributeDKey = %d\n", AttributeDKey);
      fprintf(out, "AttributeGroup = %d\n", AttributeGroup);
      fprintf(out, "AttributeAutoIncrement = %d\n", AttributeAutoIncrement);
      fprintf(out, "AttributeExtType = %d\n", AttributeExtType);
      fprintf(out, "AttributeExtPrecision = %d\n", AttributeExtPrecision);
      fprintf(out, "AttributeExtScale = %d\n", AttributeExtScale);
      fprintf(out, "AttributeExtLength = %d\n", AttributeExtLength);
      fprintf(out, "AttributeDefaultValueLen = %d\n",
              AttributeDefaultValueLen);
      fprintf(out, "AttributeDefaultValue: \n");
      for (unsigned int i = 0; i < AttributeDefaultValueLen; i++)
        fprintf(out, "0x%x", AttributeDefaultValue[i]);
    }
  };
  
  static const
  SimpleProperties::SP2StructMapping AttributeMapping[];

  static const Uint32 AttributeMappingSize;

  // Signal constants
  STATIC_CONST( DataLength = 20 );
  STATIC_CONST( HeaderLength = 5 );

private:  
  Uint32 senderRef;
  Uint32 senderData;
  Uint32 requestType;
  Uint32 totalLen; 
  Uint32 offset; 
  
  /**
   * Length of this data = signal->length() - HeaderLength
   * Sender block ref = signal->senderBlockRef()
   */
  
  Uint32 tabInfoData[DataLength];

public:
  enum Deprecated
  {
    AttributeDGroup    = 1009, //Default NotDGroup
    AttributeStoredInd = 1011, //Default NotStored
    TableStorageVal    = 14, //Disk storage specified per attribute
    SecondTableId      = 17, //Mandatory between DICT's otherwise not allowed
    FragmentKeyTypeVal = 16 //Default PrimaryKey
  };
    
  enum Unimplemented
  {
    ScanOptimised      = 15, //Default updateOptimised
    AttributeGroup     = 1012, //Default 0
    FileNo             = 102
  };
};

#define DFGIMAP(x, y, z) \
  { DictFilegroupInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, 0, UINT_MAX32, 0 }

#define DFGIMAP2(x, y, z, u, v) \
  { DictFilegroupInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 }

#define DFGIMAPS(x, y, z, u, v) \
  { DictFilegroupInfo::y, my_offsetof(x, z), SimpleProperties::StringValue, u, v, 0 }

#define DFGIMAPB(x, y, z, u, v, l) \
  { DictFilegroupInfo::y, my_offsetof(x, z), SimpleProperties::BinaryValue, u, v, \
                     my_offsetof(x, l) }

#define DFGIBREAK(x) \
  { DictFilegroupInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }

struct DictFilegroupInfo {
  enum KeyValues {
    FilegroupName     = 1,
    FilegroupType     = 2,
    FilegroupId       = 3,
    FilegroupVersion  = 4,

    /**
     * File parameters
     */
    FileName          = 100,
    FileType          = 101,
    FileId            = 103,
    FileFGroupId      = 104,
    FileFGroupVersion = 105,
    FileSizeHi        = 106,
    FileSizeLo        = 107,
    FileFreeExtents   = 108,
    FileVersion       = 109,
    FileEnd           = 199, //    

    /**
     * Tablespace parameters
     */
    TS_ExtentSize          = 1000, // specified in bytes
    TS_LogfileGroupId      = 1001, 
    TS_LogfileGroupVersion = 1002, 
    TS_GrowLimit           = 1003, // In bytes
    TS_GrowSizeHi          = 1004,
    TS_GrowSizeLo          = 1005,
    TS_GrowPattern         = 1006,
    TS_GrowMaxSize         = 1007,

    /**
     * Logfile group parameters
     */
    LF_UndoBufferSize  = 2005, // In bytes
    LF_UndoGrowLimit   = 2000, // In bytes
    LF_UndoGrowSizeHi  = 2001,
    LF_UndoGrowSizeLo  = 2002,
    LF_UndoGrowPattern = 2003,
    LF_UndoGrowMaxSize = 2004,
    LF_UndoFreeWordsHi = 2006,
    LF_UndoFreeWordsLo = 2007
  };

  // FragmentType constants
  enum FileTypeValues {
    Datafile = 0,
    Undofile = 1
    //, Redofile
  };
 
  struct GrowSpec {
    Uint32 GrowLimit;
    Uint32 GrowSizeHi;
    Uint32 GrowSizeLo;
    char   GrowPattern[PATH_MAX];
    Uint32 GrowMaxSize;
  };
  
  // Table data interpretation
  struct Filegroup {
    char   FilegroupName[MAX_TAB_NAME_SIZE];
    Uint32 FilegroupType; // ObjType
    Uint32 FilegroupId;
    Uint32 FilegroupVersion;

    union {
      Uint32 TS_ExtentSize;
      Uint32 LF_UndoBufferSize;
    };
    Uint32 TS_LogfileGroupId;
    Uint32 TS_LogfileGroupVersion;
    union {
      GrowSpec TS_DataGrow;
      GrowSpec LF_UndoGrow;
    };
    //GrowSpec LF_RedoGrow;
    Uint32 LF_UndoFreeWordsHi;
    Uint32 LF_UndoFreeWordsLo;
    Filegroup() {}
    void init();
  };
  static const Uint32 MappingSize;
  static const SimpleProperties::SP2StructMapping Mapping[];

  struct File {
    char FileName[PATH_MAX];
    Uint32 FileType;
    Uint32 FileId;
    Uint32 FileVersion;
    Uint32 FilegroupId;
    Uint32 FilegroupVersion;
    Uint32 FileSizeHi;
    Uint32 FileSizeLo;
    Uint32 FileFreeExtents;

    File() {}
    void init();
  };
  static const Uint32 FileMappingSize;
  static const SimpleProperties::SP2StructMapping FileMapping[];
};

#define DHMIMAP(x, y, z) \
  { DictHashMapInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, 0, UINT_MAX32, 0 }

#define DHMIMAP2(x, y, z, u, v) \
  { DictHashMapInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 }

#define DHMIMAPS(x, y, z, u, v) \
  { DictHashMapInfo::y, my_offsetof(x, z), SimpleProperties::StringValue, u, v, 0 }

#define DHMIMAPB(x, y, z, u, v, l) \
  { DictHashMapInfo::y, my_offsetof(x, z), SimpleProperties::BinaryValue, u, v, \
                     my_offsetof(x, l) }

#define DHMIBREAK(x) \
  { DictHashMapInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }

struct DictHashMapInfo {
  enum KeyValues {
    HashMapName    = 1,
    HashMapBuckets = 2,
    HashMapValues  = 3
  };

  // Table data interpretation
  struct HashMap {
    char   HashMapName[MAX_TAB_NAME_SIZE];
    Uint32 HashMapBuckets;
    Uint16 HashMapValues[NDB_MAX_HASHMAP_BUCKETS];
    Uint32 HashMapObjectId;
    Uint32 HashMapVersion;
    HashMap() {}
    void init();
  };
  static const Uint32 MappingSize;
  static const SimpleProperties::SP2StructMapping Mapping[];
};

/**
 * Foreign Keys
 */
struct DictForeignKeyInfo
{
  enum KeyValues {
    ForeignKeyName               = 1,
    ForeignKeyId                 = 2,
    ForeignKeyVersion            = 3,
    ForeignKeyParentTableId      = 4,
    ForeignKeyParentTableVersion = 5,
    ForeignKeyChildTableId       = 6,
    ForeignKeyChildTableVersion  = 7,
    ForeignKeyParentIndexId      = 8,
    ForeignKeyParentIndexVersion = 9,
    ForeignKeyChildIndexId       = 10,
    ForeignKeyChildIndexVersion  = 11,
    ForeignKeyOnUpdateAction     = 12,
    ForeignKeyOnDeleteAction     = 13,
    ForeignKeyParentTableName    = 14,
    ForeignKeyParentIndexName    = 15,
    ForeignKeyChildTableName     = 16,
    ForeignKeyChildIndexName     = 17,
    ForeignKeyParentColumnsLength= 18,
    ForeignKeyParentColumns      = 19,
    ForeignKeyChildColumnsLength = 20,
    ForeignKeyChildColumns       = 21
  };

  // Table data interpretation
  struct ForeignKey {
    char   Name[MAX_TAB_NAME_SIZE];
    char   ParentTableName[MAX_TAB_NAME_SIZE];
    char   ParentIndexName[MAX_TAB_NAME_SIZE];
    char   ChildTableName[MAX_TAB_NAME_SIZE];
    char   ChildIndexName[MAX_TAB_NAME_SIZE];
    Uint32 ForeignKeyId;
    Uint32 ForeignKeyVersion;
    Uint32 ParentTableId;
    Uint32 ParentTableVersion;
    Uint32 ChildTableId;
    Uint32 ChildTableVersion;
    Uint32 ParentIndexId;
    Uint32 ParentIndexVersion;
    Uint32 ChildIndexId;
    Uint32 ChildIndexVersion;
    Uint32 OnUpdateAction;
    Uint32 OnDeleteAction;
    Uint32 ParentColumnsLength;
    Uint32 ParentColumns[MAX_ATTRIBUTES_IN_INDEX];
    Uint32 ChildColumnsLength;
    Uint32 ChildColumns[MAX_ATTRIBUTES_IN_INDEX];
    ForeignKey() {}
    void init();
  };
  static const Uint32 MappingSize;
  static const SimpleProperties::SP2StructMapping Mapping[];
};

void
ndbout_print(const DictForeignKeyInfo::ForeignKey& fk, char* buf, size_t sz);

class NdbOut&
operator<<(class NdbOut& out, const DictForeignKeyInfo::ForeignKey& fk);

#define DFKIMAP(x, y, z) \
  { DictForeignKeyInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, 0, UINT_MAX32, 0 }

#define DFKIMAP2(x, y, z, u, v) \
  { DictForeignKeyInfo::y, my_offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 }

#define DFKIMAPS(x, y, z, u, v) \
  { DictForeignKeyInfo::y, my_offsetof(x, z), SimpleProperties::StringValue, u, v, 0 }

#define DFKIMAPB(x, y, z, u, v, l) \
  { DictForeignKeyInfo::y, my_offsetof(x, z), SimpleProperties::BinaryValue, u, v, \
                     my_offsetof(x, l) }

#define DFKIBREAK(x) \
  { DictForeignKeyInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }

#undef JAM_FILE_ID

#endif
