DictTabInfo.hpp 21.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/* Copyright (C) 2003 MySQL AB

   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; either version 2 of the License, or
   (at your option) any later version.

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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>
unknown's avatar
unknown committed
25
#include <ndb_global.h>
26

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
#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_LENGTH ((8 * 9) - 8)

#ifndef NOT_FIXED_DEC
#define NOT_FIXED_DEC                   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

49 50 51 52 53 54 55 56 57 58 59 60 61 62
#define DTIMAP(x, y, z) \
  { DictTabInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, 0, (~0), 0 }

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

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

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

#define DTIBREAK(x) \
unknown's avatar
unknown committed
63
  { DictTabInfo::x, 0, SimpleProperties::InvalidValue, 0, 0, 0 }
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

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,
unknown's avatar
unknown committed
93
    AlterTableFromAPI   = 6
94
  };
unknown's avatar
unknown committed
95
  
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
  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,
unknown's avatar
unknown committed
120
    FragmentCount      = 128, // No of fragments in table (!fragment replicas)
unknown's avatar
unknown committed
121 122
    FragmentDataLen    = 129,
    FragmentData       = 130, // CREATE_FRAGMENTATION reply
unknown's avatar
unknown committed
123 124
    TablespaceId       = 131,
    TablespaceVersion  = 132,
unknown's avatar
unknown committed
125 126 127 128 129 130 131 132 133
    TablespaceDataLen  = 133,
    TablespaceData     = 134,
    RangeListDataLen   = 135,
    RangeListData      = 136,
    ReplicaDataLen     = 137,
    ReplicaData        = 138,
    MaxRowsLow         = 139,
    MaxRowsHigh        = 140,
    DefaultNoPartFlag  = 141,
134
    LinearHashFlag     = 142,
unknown's avatar
unknown committed
135 136 137 138

    RowGCIFlag         = 150,
    RowChecksumFlag    = 151,
    
139 140 141 142
    TableEnd           = 999,
    
    AttributeName          = 1000, // String, Mandatory
    AttributeId        = 1001, //Mandatory between DICT's otherwise not allowed
143
    AttributeType          = 1002, //for osu 4.1->5.0.x
144 145 146
    AttributeSize          = 1003, //Default DictTabInfo::a32Bit
    AttributeArraySize     = 1005, //Default 1
    AttributeKeyFlag       = 1006, //Default noKey
unknown's avatar
unknown committed
147
    AttributeStorageType   = 1007, //Default NDB_STORAGETYPE_MEMORY
148 149
    AttributeNullableFlag  = 1008, //Default NotNullable
    AttributeDKey          = 1010, //Default NotDKey
150
    AttributeExtType       = 1013, //Default ExtUnsigned
151 152 153 154
    AttributeExtPrecision  = 1014, //Default 0
    AttributeExtScale      = 1015, //Default 0
    AttributeExtLength     = 1016, //Default 0
    AttributeAutoIncrement = 1017, //Default false
unknown's avatar
unknown committed
155 156
    AttributeDefaultValue  = 1018, //Default value (printable string),
    AttributeArrayType     = 1019, //Default NDB_ARRAYTYPE_FIXED
157 158 159 160 161 162 163
    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.
  // ----------------------------------------------------------------------

unknown's avatar
unknown committed
164

165 166 167 168 169 170
  
  // FragmentType constants
  enum FragmentType {
    AllNodesSmallTable = 0,
    AllNodesMediumTable = 1,
    AllNodesLargeTable = 2,
171 172 173 174 175 176
    SingleFragment = 3,
    DistrKeyHash = 4,
    DistrKeyLin = 5,
    UserDefined = 6,
    DistrKeyUniqueHashIndex = 7,
    DistrKeyOrderedIndex = 8
177 178 179 180 181 182 183 184 185 186 187 188
  };
  
  // 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
unknown's avatar
unknown committed
189 190 191 192 193 194 195 196 197
    HashIndexTrigger = 11,
    SubscriptionTrigger = 16,
    ReadOnlyConstraint = 17,
    IndexTrigger = 18,
    
    Tablespace = 20,        ///< Tablespace
    LogfileGroup = 21,      ///< Logfile group
    Datafile = 22,          ///< Datafile
    Undofile = 23           ///< Undofile
198
  };
199 200 201 202

  // used 1) until type BlobTable added 2) in upgrade code
  static bool
  isBlobTableName(const char* name, Uint32* ptab_id = 0, Uint32* pcol_no = 0);
unknown's avatar
unknown committed
203
  
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
  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;
  }
unknown's avatar
unknown committed
242 243 244 245 246 247 248 249 250 251 252 253 254 255
  static inline bool
  isTrigger(int tableType) {
    return
      tableType == HashIndexTrigger ||
      tableType == SubscriptionTrigger ||
      tableType == ReadOnlyConstraint ||
      tableType == IndexTrigger;
  }
  static inline bool
  isFilegroup(int tableType) {
    return
      tableType == Tablespace ||
      tableType == LogfileGroup;
  }
256

unknown's avatar
unknown committed
257 258 259 260 261 262 263
  static inline bool
  isFile(int tableType) {
    return
      tableType == Datafile||
      tableType == Undofile;
  }
  
264 265 266 267 268 269 270
  // Object state for translating from/to API
  enum ObjectState {
    StateUndefined = 0,
    StateOffline = 1,
    StateBuilding = 2,
    StateDropping = 3,
    StateOnline = 4,
unknown's avatar
unknown committed
271
    StateBackup = 5,
272 273 274 275 276 277 278 279 280 281 282
    StateBroken = 9
  };

  // Object store for translating from/to API
  enum ObjectStore {
    StoreUndefined = 0,
    StoreTemporary = 1,
    StorePermanent = 2
  };
  
  // AttributeSize constants
283
  STATIC_CONST( aBit = 0 );
unknown's avatar
unknown committed
284 285 286 287 288
  STATIC_CONST( an8Bit = 3 );
  STATIC_CONST( a16Bit = 4 );
  STATIC_CONST( a32Bit = 5 );
  STATIC_CONST( a64Bit = 6 );
  STATIC_CONST( a128Bit = 7 );
unknown's avatar
unknown committed
289
    
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
  // 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 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;
unknown's avatar
unknown committed
313 314
    Uint32 TablespaceId;
    Uint32 TablespaceVersion;
unknown's avatar
unknown committed
315 316 317
    Uint32 MaxRowsLow;
    Uint32 MaxRowsHigh;
    Uint32 DefaultNoPartFlag;
318
    Uint32 LinearHashFlag;
unknown's avatar
unknown committed
319 320 321 322 323
    /*
      TODO RONM:
      We need to replace FRM, Fragment Data, Tablespace Data and in
      very particular RangeListData with dynamic arrays
    */
324 325
    Uint32 FrmLen;
    char   FrmData[MAX_FRM_DATA_SIZE];
unknown's avatar
unknown committed
326
    Uint32 FragmentCount;
unknown's avatar
unknown committed
327 328
    Uint32 ReplicaDataLen;
    Uint16 ReplicaData[MAX_FRAGMENT_DATA_BYTES];
unknown's avatar
unknown committed
329
    Uint32 FragmentDataLen;
unknown's avatar
unknown committed
330 331 332 333 334
    Uint16 FragmentData[3*MAX_NDB_PARTITIONS];
    Uint32 TablespaceDataLen;
    Uint32 TablespaceData[2*MAX_NDB_PARTITIONS];
    Uint32 RangeListDataLen;
    char   RangeListData[4*2*MAX_NDB_PARTITIONS*2];
unknown's avatar
unknown committed
335
    
unknown's avatar
unknown committed
336 337 338
    Uint32 RowGCIFlag;
    Uint32 RowChecksumFlag;
    
unknown's avatar
unknown committed
339
    Table() {}
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
    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,
363 364
    ExtOlddecimal = NdbSqlUtil::Type::Olddecimal,
    ExtOlddecimalunsigned = NdbSqlUtil::Type::Olddecimalunsigned,
365 366
    ExtDecimal = NdbSqlUtil::Type::Decimal,
    ExtDecimalunsigned = NdbSqlUtil::Type::Decimalunsigned,
367 368 369 370 371
    ExtChar = NdbSqlUtil::Type::Char,
    ExtVarchar = NdbSqlUtil::Type::Varchar,
    ExtBinary = NdbSqlUtil::Type::Binary,
    ExtVarbinary = NdbSqlUtil::Type::Varbinary,
    ExtDatetime = NdbSqlUtil::Type::Datetime,
unknown's avatar
unknown committed
372
    ExtDate = NdbSqlUtil::Type::Date,
unknown's avatar
unknown committed
373
    ExtBlob = NdbSqlUtil::Type::Blob,
374
    ExtText = NdbSqlUtil::Type::Text,
unknown's avatar
unknown committed
375 376
    ExtBit = NdbSqlUtil::Type::Bit,
    ExtLongvarchar = NdbSqlUtil::Type::Longvarchar,
unknown's avatar
Merge  
unknown committed
377
    ExtLongvarbinary = NdbSqlUtil::Type::Longvarbinary,
378 379 380
    ExtTime = NdbSqlUtil::Type::Time,
    ExtYear = NdbSqlUtil::Type::Year,
    ExtTimestamp = NdbSqlUtil::Type::Timestamp
381 382 383 384 385 386
  };

  // Attribute data interpretation
  struct Attribute {
    char   AttributeName[MAX_TAB_NAME_SIZE];
    Uint32 AttributeId;
387
    Uint32 AttributeType; // for osu 4.1->5.0.x
388 389
    Uint32 AttributeSize;
    Uint32 AttributeArraySize;
unknown's avatar
unknown committed
390
    Uint32 AttributeArrayType;
391 392 393 394 395 396 397 398
    Uint32 AttributeKeyFlag;
    Uint32 AttributeNullableFlag;
    Uint32 AttributeDKey;
    Uint32 AttributeExtType;
    Uint32 AttributeExtPrecision;
    Uint32 AttributeExtScale;
    Uint32 AttributeExtLength;
    Uint32 AttributeAutoIncrement;
unknown's avatar
unknown committed
399
    Uint32 AttributeStorageType;
400 401
    char   AttributeDefaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE];
    
unknown's avatar
unknown committed
402
    Attribute() {}
403 404 405 406 407 408 409 410
    void init();

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

unknown's avatar
unknown committed
411
    // compute old-sty|e attribute size and array size
412 413 414 415
    inline bool
    translateExtType() {
      switch (AttributeExtType) {
      case DictTabInfo::ExtUndefined:
unknown's avatar
unknown committed
416
        return false;
417 418 419 420
      case DictTabInfo::ExtTinyint:
      case DictTabInfo::ExtTinyunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
421
	break;
422 423 424 425
      case DictTabInfo::ExtSmallint:
      case DictTabInfo::ExtSmallunsigned:
        AttributeSize = DictTabInfo::a16Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
426
	break;
427 428 429 430
      case DictTabInfo::ExtMediumint:
      case DictTabInfo::ExtMediumunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 3 * AttributeExtLength;
unknown's avatar
unknown committed
431
	break;
432 433 434 435
      case DictTabInfo::ExtInt:	
      case DictTabInfo::ExtUnsigned:
        AttributeSize = DictTabInfo::a32Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
436
        break;
437 438 439 440
      case DictTabInfo::ExtBigint:
      case DictTabInfo::ExtBigunsigned:
        AttributeSize = DictTabInfo::a64Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
441
        break;
442 443 444
      case DictTabInfo::ExtFloat:
        AttributeSize = DictTabInfo::a32Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
445
        break;
446 447 448
      case DictTabInfo::ExtDouble:
        AttributeSize = DictTabInfo::a64Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
449
        break;
450 451 452 453 454
      case DictTabInfo::ExtOlddecimal:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize =
          (1 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
          AttributeExtLength;
unknown's avatar
Merge  
unknown committed
455
        break;
456 457 458 459 460
      case DictTabInfo::ExtOlddecimalunsigned:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize =
          (0 + AttributeExtPrecision + (int(AttributeExtScale) > 0)) *
          AttributeExtLength;
unknown's avatar
Merge  
unknown committed
461
        break;
462 463 464 465 466 467 468 469 470 471 472 473 474
      case DictTabInfo::ExtDecimal:
      case DictTabInfo::ExtDecimalunsigned:
        {
          // copy from Field_new_decimal ctor
          uint precision = AttributeExtPrecision;
          uint scale = AttributeExtScale;
          if (precision > DECIMAL_MAX_LENGTH || scale >= NOT_FIXED_DEC)
            precision = DECIMAL_MAX_LENGTH;
          uint bin_size = my_decimal_get_binary_size(precision, scale);
          AttributeSize = DictTabInfo::an8Bit;
          AttributeArraySize = bin_size * AttributeExtLength;
        }
        break;
475 476 477 478
      case DictTabInfo::ExtChar:
      case DictTabInfo::ExtBinary:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
479
        break;
480 481
      case DictTabInfo::ExtVarchar:
      case DictTabInfo::ExtVarbinary:
unknown's avatar
unknown committed
482 483
        if (AttributeExtLength > 0xff)
          return false;
484
        AttributeSize = DictTabInfo::an8Bit;
unknown's avatar
unknown committed
485 486
        AttributeArraySize = AttributeExtLength + 1;
        break;
487
      case DictTabInfo::ExtDatetime:
488
        // to fix
489 490
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 8 * AttributeExtLength;
unknown's avatar
unknown committed
491
        break;
unknown's avatar
unknown committed
492
      case DictTabInfo::ExtDate:
493
        // to fix
494
        AttributeSize = DictTabInfo::an8Bit;
unknown's avatar
unknown committed
495
        AttributeArraySize = 3 * AttributeExtLength;
unknown's avatar
unknown committed
496
        break;
unknown's avatar
unknown committed
497
      case DictTabInfo::ExtBlob:
unknown's avatar
unknown committed
498
      case DictTabInfo::ExtText:
unknown's avatar
unknown committed
499
        AttributeSize = DictTabInfo::an8Bit;
unknown's avatar
unknown committed
500
        // head + inline part (length in precision lower half)
unknown's avatar
unknown committed
501
        AttributeArraySize = (NDB_BLOB_HEAD_SIZE << 2) + (AttributeExtPrecision & 0xFFFF);
unknown's avatar
unknown committed
502
        break;
503 504 505
      case DictTabInfo::ExtBit:
	AttributeSize = DictTabInfo::aBit;
	AttributeArraySize = AttributeExtLength;
unknown's avatar
unknown committed
506 507 508 509 510 511 512 513
	break;
      case DictTabInfo::ExtLongvarchar:
      case DictTabInfo::ExtLongvarbinary:
        if (AttributeExtLength > 0xffff)
          return false;
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = AttributeExtLength + 2;
        break;
unknown's avatar
Merge  
unknown committed
514 515 516 517
      case DictTabInfo::ExtTime:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 3 * AttributeExtLength;
        break;
518 519 520
      case DictTabInfo::ExtYear:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 1 * AttributeExtLength;
unknown's avatar
Merge  
unknown committed
521
        break;
522 523 524
      case DictTabInfo::ExtTimestamp:
        AttributeSize = DictTabInfo::an8Bit;
        AttributeArraySize = 4 * AttributeExtLength;
unknown's avatar
Merge  
unknown committed
525
        break;
unknown's avatar
unknown committed
526 527
      default:
        return false;
528
      };
unknown's avatar
unknown committed
529
      return true;
530 531 532 533 534 535 536
    }
    
    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);
unknown's avatar
unknown committed
537
      fprintf(out, "AttributeArrayType = %d\n", AttributeArrayType);
538
      fprintf(out, "AttributeKeyFlag = %d\n", AttributeKeyFlag);
unknown's avatar
unknown committed
539
      fprintf(out, "AttributeStorageType = %d\n", AttributeStorageType);
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
      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, "AttributeDefaultValue = \"%s\"\n",
        AttributeDefaultValue ? AttributeDefaultValue : "");
    }
  };
  
  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];
unknown's avatar
unknown committed
575 576

public:
unknown's avatar
unknown committed
577
  enum Depricated
unknown's avatar
unknown committed
578 579 580
  {
    AttributeDGroup    = 1009, //Default NotDGroup
    AttributeStoredInd = 1011, //Default NotStored
unknown's avatar
unknown committed
581
    TableStorageVal    = 14, //Disk storage specified per attribute
unknown's avatar
unknown committed
582 583 584
    SecondTableId      = 17, //Mandatory between DICT's otherwise not allowed
    FragmentKeyTypeVal = 16 //Default PrimaryKey
  };
unknown's avatar
unknown committed
585 586
    
  enum Unimplemented
unknown's avatar
unknown committed
587 588
  {
    ScanOptimised      = 15, //Default updateOptimised
unknown's avatar
ndb -  
unknown committed
589 590
    AttributeGroup     = 1012, //Default 0
    FileNo             = 102
unknown's avatar
unknown committed
591
  };
592 593
};

unknown's avatar
unknown committed
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
#define DFGIMAP(x, y, z) \
  { DictFilegroupInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, 0, (~0), 0 }

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

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

#define DFGIMAPB(x, y, z, u, v, l) \
  { DictFilegroupInfo::y, offsetof(x, z), SimpleProperties::BinaryValue, u, v, \
                     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,
unknown's avatar
ndb -  
unknown committed
622
    FileId            = 103,
unknown's avatar
unknown committed
623 624 625 626 627
    FileFGroupId      = 104,
    FileFGroupVersion = 105,
    FileSizeHi        = 106,
    FileSizeLo        = 107,
    FileFreeExtents   = 108,
unknown's avatar
ndb -  
unknown committed
628
    FileVersion       = 109,
unknown's avatar
unknown committed
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
    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,
unknown's avatar
unknown committed
651 652 653
    LF_UndoGrowMaxSize = 2004,
    LF_UndoFreeWordsHi = 2006,
    LF_UndoFreeWordsLo = 2007
unknown's avatar
unknown committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
  };

  // 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;
unknown's avatar
unknown committed
689 690
    Uint32 LF_UndoFreeWordsHi;
    Uint32 LF_UndoFreeWordsLo;
unknown's avatar
unknown committed
691
    Filegroup() {}
unknown's avatar
unknown committed
692 693 694 695 696 697 698 699 700
    void init();
  };
  static const Uint32 MappingSize;
  static const SimpleProperties::SP2StructMapping Mapping[];

  struct File {
    char FileName[PATH_MAX];
    Uint32 FileType;
    Uint32 FileId;
unknown's avatar
ndb -  
unknown committed
701
    Uint32 FileVersion;
unknown's avatar
unknown committed
702 703 704 705 706
    Uint32 FilegroupId;
    Uint32 FilegroupVersion;
    Uint32 FileSizeHi;
    Uint32 FileSizeLo;
    Uint32 FileFreeExtents;
unknown's avatar
unknown committed
707 708

    File() {}
unknown's avatar
unknown committed
709 710 711 712 713 714
    void init();
  };
  static const Uint32 FileMappingSize;
  static const SimpleProperties::SP2StructMapping FileMapping[];
};

715
#endif