NdbDictionary.hpp

/*
   Copyright (c) 2003, 2010, 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 NdbDictionary_H
#define NdbDictionary_H

#include <ndb_types.h>

class Ndb;
struct charset_info_st;
typedef struct charset_info_st CHARSET_INFO;

/* Forward declaration only. */
class NdbRecord;

class NdbDictionary {
public:
  NdbDictionary() {}                          /* Remove gcc warning */
  class Object {
  public:
    Object() {}                               /* Remove gcc warning */
    virtual ~Object() {}                      /* Remove gcc warning */
    enum Status {
      New,                    

      Changed,                


      Retrieved,              

      Invalid,                

      Altered                 

    };

    virtual Status getObjectStatus() const = 0;

    virtual int getObjectVersion() const = 0;
    
    virtual int getObjectId() const = 0;
    
    enum Type {
      TypeUndefined = 0,      
      SystemTable = 1,        
      UserTable = 2,          
      UniqueHashIndex = 3,    
      OrderedIndex = 6,       
      HashIndexTrigger = 7,   
      IndexTrigger = 8,       
      SubscriptionTrigger = 9,
      ReadOnlyConstraint = 10,
      TableEvent = 11,        
      Tablespace = 20,        
      LogfileGroup = 21,      
      Datafile = 22,          
      Undofile = 23,          
      ReorgTrigger = 19,
      HashMap = 24
    };

    enum State {
      StateUndefined = 0,     
      StateOffline = 1,       
      StateBuilding = 2,      
      StateDropping = 3,      
      StateOnline = 4,        
      StateBackup = 5,        
      StateBroken = 9         
    };

    enum Store {
      StoreUndefined = 0,     
      StoreNotLogged = 1,     
      StorePermanent = 2      
    };

    enum FragmentType { 
      FragUndefined = 0,      
      FragSingle = 1,         
      FragAllSmall = 2,       
      FragAllMedium = 3,      
      FragAllLarge = 4,       
      DistrKeyHash = 5,
      DistrKeyLin = 6,
      UserDefined = 7,
      HashMapPartition = 9
    };
  private:
    Object&operator=(const Object&);
  };

  class Dictionary; // Forward declaration
  
  class ObjectId : public Object 
  {
  public:
    ObjectId();
    virtual ~ObjectId();
    
    virtual Status getObjectStatus() const;
    
    virtual int getObjectVersion() const;
    
    virtual int getObjectId() const;
    
  private:
    friend class NdbDictObjectImpl;
    class NdbDictObjectImpl & m_impl;

    ObjectId(const ObjectId&); // Not impl.
    ObjectId&operator=(const ObjectId&);
  };
  
  class Table; // forward declaration
  class Tablespace; // forward declaration
  class HashMap; // Forward
//  class NdbEventOperation; // forward declaration

  class Column {
  public:
    enum Type {
      Undefined = NDB_TYPE_UNDEFINED,   
      Tinyint = NDB_TYPE_TINYINT,       
      Tinyunsigned = NDB_TYPE_TINYUNSIGNED,  
      Smallint = NDB_TYPE_SMALLINT,      
      Smallunsigned = NDB_TYPE_SMALLUNSIGNED, 
      Mediumint = NDB_TYPE_MEDIUMINT,     
      Mediumunsigned = NDB_TYPE_MEDIUMUNSIGNED,
      Int = NDB_TYPE_INT,           
      Unsigned = NDB_TYPE_UNSIGNED,      
      Bigint = NDB_TYPE_BIGINT,        
      Bigunsigned = NDB_TYPE_BIGUNSIGNED,   
      Float = NDB_TYPE_FLOAT,         
      Double = NDB_TYPE_DOUBLE,        
      Olddecimal = NDB_TYPE_OLDDECIMAL,    
      Olddecimalunsigned = NDB_TYPE_OLDDECIMALUNSIGNED,
      Decimal = NDB_TYPE_DECIMAL,    
      Decimalunsigned = NDB_TYPE_DECIMALUNSIGNED,
      Char = NDB_TYPE_CHAR,          
      Varchar = NDB_TYPE_VARCHAR,       
      Binary = NDB_TYPE_BINARY,        
      Varbinary = NDB_TYPE_VARBINARY,     
      Datetime = NDB_TYPE_DATETIME,    
      Date = NDB_TYPE_DATE,            
      Blob = NDB_TYPE_BLOB,        
      Text = NDB_TYPE_TEXT,         
      Bit = NDB_TYPE_BIT,          
      Longvarchar = NDB_TYPE_LONGVARCHAR,  
      Longvarbinary = NDB_TYPE_LONGVARBINARY, 
      Time = NDB_TYPE_TIME,        
      Year = NDB_TYPE_YEAR,   
      Timestamp = NDB_TYPE_TIMESTAMP  
    };

    /*
     * Array type specifies internal attribute format.
     *
     * - ArrayTypeFixed is stored as fixed number of bytes.  This type
     *   is fastest to access but can waste space.
     *
     * - ArrayTypeVar is stored as variable number of bytes with a fixed
     *   overhead of 2 bytes.
     *
     * Default is ArrayTypeVar for Var* types and ArrayTypeFixed for
     * others.  The default is normally ok.
     */
    enum ArrayType {
      ArrayTypeFixed = NDB_ARRAYTYPE_FIXED,          // 0 length bytes
      ArrayTypeShortVar = NDB_ARRAYTYPE_SHORT_VAR,   // 1 length bytes
      ArrayTypeMediumVar = NDB_ARRAYTYPE_MEDIUM_VAR // 2 length bytes
    };

    /*
     * Storage type specifies whether attribute is stored in memory or
     * on disk.  Default is memory.  Disk attributes are potentially
     * much slower to access and cannot be indexed in version 5.1.
     */
    enum StorageType {
      StorageTypeMemory = NDB_STORAGETYPE_MEMORY,
      StorageTypeDisk = NDB_STORAGETYPE_DISK,
      StorageTypeDefault = NDB_STORAGETYPE_DEFAULT
    };

    const char* getName() const;

    bool getNullable() const;
    
    bool getPrimaryKey() const;

    int getColumnNo() const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    int getAttrId() const;
#endif

    bool equal(const Column& column) const;


    Type getType() const;

    int getPrecision() const;

    int getScale() const;

    int getLength() const;

    CHARSET_INFO* getCharset() const;

    int getCharsetNumber() const;

    int getInlineSize() const;

    int getPartSize() const;

    int getStripeSize() const;

    int getSize() const;

    bool getPartitionKey() const;
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    inline bool getDistributionKey() const { return getPartitionKey(); };
#endif

    ArrayType getArrayType() const;
    StorageType getStorageType() const;

    bool getDynamic() const;

    bool getIndexSourced() const;

    Column(const char * name = "");
    Column(const Column& column); 
    ~Column();

    int setName(const char * name);

    void setNullable(bool);

    void setPrimaryKey(bool);

    void setType(Type type);

    void setPrecision(int);

    void setScale(int);

    void setLength(int length);

    void setCharset(CHARSET_INFO* cs);

    void setInlineSize(int size);

    void setPartSize(int size);

    void setStripeSize(int size);

    void setPartitionKey(bool enable);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    inline void setDistributionKey(bool enable)
    { setPartitionKey(enable); };
#endif

    void setArrayType(ArrayType type);
    void setStorageType(StorageType type);

    void setDynamic(bool);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    int setDefaultValue(const char*);
#endif
    /* setDefaultValue
     * Set buf to NULL for no default value, or null default value for
     * NULLABLE column, otherwise set buf to pointer to default value.
     * The len parameter is the number of significant bytes of default
     * value supplied, which is the type size for fixed size types.
     * For variable length types, the leading 1 or 2 bytes pointed to 
     * by buf also contain length information as normal for the type.
     */
    int setDefaultValue(const void* buf, unsigned int len);

    /* getDefaultValue
     * Get the default value data for this column.
     * Optional int len* will be updated with the significant length 
     * of the default value, or set to 0 for NULL or no default.
     */
    const void* getDefaultValue(unsigned int* len = 0) const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    const Table * getBlobTable() const;

    void setAutoIncrement(bool);
    bool getAutoIncrement() const;
    void setAutoIncrementInitialValue(Uint64 val);

    static const Column * FRAGMENT;
    static const Column * FRAGMENT_FIXED_MEMORY;
    static const Column * FRAGMENT_VARSIZED_MEMORY;
    static const Column * ROW_COUNT;
    static const Column * COMMIT_COUNT;
    static const Column * ROW_SIZE;
    static const Column * RANGE_NO;
    static const Column * DISK_REF;
    static const Column * RECORDS_IN_RANGE;
    static const Column * ROWID;
    static const Column * ROW_GCI;
    static const Column * ROW_GCI64;
    static const Column * ROW_AUTHOR;
    static const Column * ANY_VALUE;
    static const Column * COPY_ROWID;
    static const Column * LOCK_REF;
    static const Column * OP_ID;
    static const Column * OPTIMIZE;
    static const Column * FRAGMENT_EXTENT_SPACE;
    static const Column * FRAGMENT_FREE_EXTENT_SPACE;

    int getSizeInBytes() const;

    int getBlobVersion() const; // NDB_BLOB_V1 or NDB_BLOB_V2
    void setBlobVersion(int blobVersion); // default NDB_BLOB_V2

    int isBindable(const Column&) const;
#endif
    
  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbRecAttr;
    friend class NdbColumnImpl;
#endif
    class NdbColumnImpl & m_impl;
    Column(NdbColumnImpl&);
    Column& operator=(const Column&);
  };

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  typedef Column Attribute;
#endif
  
  class Table : public Object {
  public:
    /*
     * Single user mode specifies access rights to table during single user mode
     */
    enum SingleUserMode {
      SingleUserModeLocked    = NDB_SUM_LOCKED,
      SingleUserModeReadOnly  = NDB_SUM_READONLY,
      SingleUserModeReadWrite = NDB_SUM_READ_WRITE
    };

    const char * getName() const;

    int getTableId() const;
    
    const Column* getColumn(const char * name) const;
    
    Column* getColumn(const int attributeId);

    Column* getColumn(const char * name);
    
    const Column* getColumn(const int attributeId) const;
    
    bool getLogging() const;

    FragmentType getFragmentType() const;
    
    int getKValue() const;

    int getMinLoadFactor() const;

    int getMaxLoadFactor() const;

    int getNoOfColumns() const;
    
    int getNoOfAutoIncrementColumns() const;
    
    int getNoOfPrimaryKeys() const;

    const char* getPrimaryKey(int no) const;
    
    bool equal(const Table&) const;

    const void* getFrmData() const;
    Uint32 getFrmLength() const;

    const NdbRecord* getDefaultRecord() const;

    Table(const char * name = "");

    Table(const Table& table); 
    virtual ~Table();
    
    Table& operator=(const Table& table);

    int setName(const char * name);

    int addColumn(const Column &);
    
    void setLogging(bool); 
  
    void setLinearFlag(Uint32 flag);
    bool getLinearFlag() const;

    void setFragmentCount(Uint32);

    Uint32 getFragmentCount() const;

    void setFragmentType(FragmentType);

    void setKValue(int kValue);
    
    void setMinLoadFactor(int);

    void setMaxLoadFactor(int);

    int setTablespaceName(const char * name);
    const char * getTablespaceName() const;
    int setTablespace(const class Tablespace &);
    bool getTablespace(Uint32 *id= 0, Uint32 *version= 0) const;

    bool getHashMap(Uint32* id = 0, Uint32* version = 0) const;
    int setHashMap(const class HashMap &);

    Object::Type getObjectType() const;

    virtual Object::Status getObjectStatus() const;
    void setStatusInvalid() const;

    virtual int getObjectVersion() const;

    void setDefaultNoPartitionsFlag(Uint32 indicator);
    Uint32 getDefaultNoPartitionsFlag() const;
   
    virtual int getObjectId() const;

    int setFrm(const void* data, Uint32 len);

    int setFragmentData(const Uint32 * nodegroups, Uint32 cnt);

    const Uint32 *getFragmentData() const;
    Uint32 getFragmentDataLen() const;

    int setRangeListData(const Int32* data, Uint32 cnt);

    const Int32 *getRangeListData() const;
    Uint32 getRangeListDataLen() const;

    Uint32 getFragmentNodes(Uint32 fragmentId, 
                            Uint32* nodeIdArrayPtr,
                            Uint32 arraySize) const;

    void setObjectType(Object::Type type);

    void setMaxRows(Uint64 maxRows);
    Uint64 getMaxRows() const;

    void setMinRows(Uint64 minRows);
    Uint64 getMinRows() const;

    void setSingleUserMode(enum SingleUserMode);
    enum SingleUserMode getSingleUserMode() const;


    void setRowGCIIndicator(bool value);
    bool getRowGCIIndicator() const;

    void setRowChecksumIndicator(bool value);
    bool getRowChecksumIndicator() const;
 
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    const char *getMysqlName() const;

    void setStoredTable(bool x) { setLogging(x); }
    bool getStoredTable() const { return getLogging(); }

    int getRowSizeInBytes() const ;
    int createTableInDb(Ndb*, bool existingEqualIsOk = true) const ;

    int getReplicaCount() const ;

    bool getTemporary() const;
    void setTemporary(bool); 

    bool getForceVarPart() const;
    void setForceVarPart(bool);

    int checkColumns(const Uint32* bitmap, unsigned len_in_bytes) const;

    void assignObjId(const ObjectId &);

    void setStorageType(Column::StorageType);
    Column::StorageType getStorageType() const;

    void setExtraRowGciBits(Uint32);
    Uint32 getExtraRowGciBits() const;

    void setExtraRowAuthorBits(Uint32);
    Uint32 getExtraRowAuthorBits() const;
#endif

    // these 2 are not de-doxygenated

    int aggregate(struct NdbError& error);

    int validate(struct NdbError& error);

    Uint32 getPartitionId(Uint32 hashvalue) const ;

    /*
     * Return TRUE if any of the columns in the table have a 
     * non NULL default value defined
     */ 
    bool hasDefaultValues() const;

  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class Ndb;
    friend class NdbDictionaryImpl;
    friend class NdbTableImpl;
    friend class NdbEventOperationImpl;
#endif
    class NdbTableImpl & m_impl;
    Table(NdbTableImpl&);
  };
  
  class Index : public Object {
  public:
    
    const char * getName() const;
    
    const char * getTable() const;

    unsigned getNoOfColumns() const;

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

    int getNoOfIndexColumns() const;
#endif

    const Column * getColumn(unsigned no) const ;

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

    const char * getIndexColumn(int no) const ;
#endif

    enum Type {
      Undefined = 0,          
      UniqueHashIndex = 3,    

      OrderedIndex = 6        
    };

    Type getType() const;
    
    bool getLogging() const;

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

    const NdbRecord* getDefaultRecord() const;

    Index(const char * name = "");
    virtual ~Index();

    int setName(const char * name);

    int setTable(const char * name);

    int addColumn(const Column & c);

    int addColumnName(const char * name);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

    int addIndexColumn(const char * name);
#endif

    int  addColumnNames(unsigned noOfNames, const char ** names);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

    int addIndexColumns(int noOfNames, const char ** names);
#endif

    void setType(Type type);

    void setLogging(bool enable); 

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    void setStoredIndex(bool x) { setLogging(x); }
    bool getStoredIndex() const { return getLogging(); }

    bool getTemporary() const;
    void setTemporary(bool); 
#endif
    
  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbIndexImpl;
    friend class NdbIndexStat;
#endif
    class NdbIndexImpl & m_impl;
    Index(NdbIndexImpl&);
  };

  class OptimizeTableHandle {
  public:
    OptimizeTableHandle();
    ~OptimizeTableHandle();
    int next();
    int close();
  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbOptimizeTableHandleImpl;
    friend class NdbOptimizeIndexHandleImpl;
    friend class NdbDicitionaryImpl;
#endif
    class NdbOptimizeTableHandleImpl & m_impl;
    OptimizeTableHandle(NdbOptimizeTableHandleImpl &);
  };

  class OptimizeIndexHandle {
  public:
    OptimizeIndexHandle();
    ~OptimizeIndexHandle();
    int next();
    int close();
  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbOptimizeIndexHandleImpl;
    friend class NdbDicitionaryImpl;
#endif
    class NdbOptimizeIndexHandleImpl & m_impl;
    OptimizeIndexHandle(NdbOptimizeIndexHandleImpl &);
  };

  class Event : public Object  {
  public:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

#endif
    enum TableEvent { 
      TE_INSERT      =1<<0, 
      TE_DELETE      =1<<1, 
      TE_UPDATE      =1<<2, 
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
      TE_SCAN        =1<<3, 
      TE_FIRST_NON_DATA_EVENT =1<<4,
#endif
      TE_DROP        =1<<4, 
      TE_ALTER       =1<<5, 
      TE_CREATE      =1<<6, 
      TE_GCP_COMPLETE=1<<7, 
      TE_CLUSTER_FAILURE=1<<8, 
      TE_STOP        =1<<9, 
      TE_NODE_FAILURE=1<<10, 
      TE_SUBSCRIBE   =1<<11, 
      TE_UNSUBSCRIBE =1<<12, 
      TE_ALL=0xFFFF         

    };
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    enum _TableEvent { 
      _TE_INSERT=0,
      _TE_DELETE=1,
      _TE_UPDATE=2,
      _TE_SCAN=3,
      _TE_FIRST_NON_DATA_EVENT=4,
      _TE_DROP=4,
      _TE_ALTER=5,
      _TE_CREATE=6,
      _TE_GCP_COMPLETE=7,
      _TE_CLUSTER_FAILURE=8,
      _TE_STOP=9,
      _TE_NODE_FAILURE=10,
      _TE_SUBSCRIBE=11,
      _TE_UNSUBSCRIBE=12,
      _TE_NUL=13, // internal (e.g. INS o DEL within same GCI)
      _TE_ACTIVE=14 // internal (node becomes active)
    };
#endif

    enum EventDurability { 
      ED_UNDEFINED
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
      = 0
#endif
#if 0 // not supported
      ,ED_SESSION = 1, 
      // Only this API can use it
      // and it's deleted after api has disconnected or ndb has restarted
      
      ED_TEMPORARY = 2
      // All API's can use it,
      // But's its removed when ndb is restarted
#endif
      ,ED_PERMANENT    

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
      = 3
#endif
    };

    enum EventReport {
      ER_UPDATED = 0,
      ER_ALL = 1, // except not-updated blob inlines
      ER_SUBSCRIBE = 2,
      ER_DDL = 4
    };

    Event(const char *name);
    Event(const char *name, const NdbDictionary::Table& table);
    virtual ~Event();
    int setName(const char *name);
    const char *getName() const;
    const NdbDictionary::Table * getTable() const;
    void setTable(const NdbDictionary::Table& table);
    int setTable(const char *tableName);
    const char* getTableName() const;
    void addTableEvent(const TableEvent te);
    bool getTableEvent(const TableEvent te) const;
    void setDurability(EventDurability);
    EventDurability getDurability() const;
    void setReport(EventReport);
    EventReport getReport() const;
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    void addColumn(const Column &c);
#endif

    void addEventColumn(unsigned attrId);
    void addEventColumn(const char * columnName);
    void addEventColumns(int n, const char ** columnNames);

    int getNoOfEventColumns() const;

    const Column * getEventColumn(unsigned no) const;

    void mergeEvents(bool flag);

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    void print();
#endif

  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbEventImpl;
    friend class NdbEventOperationImpl;
#endif
    class NdbEventImpl & m_impl;
    Event(NdbEventImpl&);
  };

  /* Flags for createRecord(). */
  enum NdbRecordFlags {
    /*
      Use special mysqld varchar format in index keys, used only from
      inside mysqld.
    */
    RecMysqldShrinkVarchar= 0x1,
    /* Use the mysqld record format for bitfields, only used inside mysqld. */
    RecMysqldBitfield= 0x2
  };
  struct RecordSpecification {
    /*
      Column described by this entry (the column maximum size defines field
      size in row).
      Note that even when creating an NdbRecord for an index, the column
      pointers must be to columns obtained from the underlying table, not
      from the index itself.
      Note that pseudo columns cannot be used as part of a RecordSpecification.
      To read pesudo column values, use the extra get value and set value 
      APIs.
    */
    const Column *column;
    /*
      Offset of data from start of a row.
      
      For reading blobs, the blob handle (NdbBlob *) will be written into the
      result row when the operation is created, not the actual blob data. 
      So at least sizeof(NdbBlob *) must be available in the row.  Other 
      operations do not write the blob handle into the row.
      In any case, a blob handle can always be obtained with a call to 
      NdbOperation/NdbScanOperation::getBlobHandle().
    */
    Uint32 offset;
    /*
      Offset from start of row of byte containing NULL bit.
      Not used for columns that are not NULLable.
    */
    Uint32 nullbit_byte_offset;
    /* NULL bit, 0-7. Not used for columns that are not NULLable. */
    Uint32 nullbit_bit_in_byte;
  };

  /* Types of NdbRecord object */
  enum RecordType {
    TableAccess,
    IndexAccess
  };
  
  /*
    Return the type of the passed NdbRecord object
  */
  static RecordType getRecordType(const NdbRecord* record);
  
  /*
    Return the name of the table object that the NdbRecord
    refers to.
    This method returns Null if the NdbRecord object is not a 
    TableAccess NdbRecord.
  */
  static const char* getRecordTableName(const NdbRecord* record);
  
  /*
    Return the name of the index object that the NdbRecord
    refers to.
    This method returns Null if the NdbRecord object is not an
    IndexAccess NdbRecord
  */
  static const char* getRecordIndexName(const NdbRecord* record);
  
  /*
    Get the first Attribute Id specified in the NdbRecord object.
    Returns false if no Attribute Ids are specified.
  */
  static bool getFirstAttrId(const NdbRecord* record, Uint32& firstAttrId);

  /* Get the next Attribute Id specified in the NdbRecord object
     after the attribute Id passed in.
     Returns false if there are no more attribute Ids
  */
  static bool getNextAttrId(const NdbRecord* record, Uint32& attrId);

  /* Get offset of the given attribute id's storage from the start
     of the NdbRecord row.
     Returns false if the attribute id is not present
  */
  static bool getOffset(const NdbRecord* record, Uint32 attrId, Uint32& offset);
  
  /* Get offset of the given attribute id's null bit from the start
     of the NdbRecord row.
     Returns false if the attribute is not present or if the
     attribute is not nullable
  */
  static bool getNullBitOffset(const NdbRecord* record, 
                               Uint32 attrId, 
                               Uint32& nullbit_byte_offset,
                               Uint32& nullbit_bit_in_byte);

  /*
    Return pointer to beginning of storage of data specified by
    attrId.
    This method looks up the offset of the column which is stored in
    the NdbRecord object, and returns the value of row + offset.
    There are row-const and non-row-const versions.
    
    @param record : Pointer to NdbRecord object describing the row format
    @param row : Pointer to the start of row data
    @param attrId : Attribute id of column
    @return : Pointer to start of the attribute in the row.  Null if the
    attribute is not part of the NdbRecord definition
  */
  static const char* getValuePtr(const NdbRecord* record,
                                 const char* row,
                                 Uint32 attrId);
  
  static char* getValuePtr(const NdbRecord* record,
                           char* row,
                           Uint32 attrId);
  
  /*
    Return a bool indicating whether the null bit for the given
    column is set to true or false.
    The location of the null bit in relation to the row pointer is
    obtained from the passed NdbRecord object.
    If the column is not nullable, false will be returned.
    If the column is not part of the NdbRecord definition, false will
    be returned.
    
    @param record : Pointer to NdbRecord object describing the row format
    @param row : Pointer to the start of row data
    @param attrId : Attibute id of column
    @return : true if attrId exists in NdbRecord, is nullable, and null bit
    in row is set, false otherwise.
  */
  static bool isNull(const NdbRecord* record,
                     const char* row,
                     Uint32 attrId);
  
  /*
    Set the null bit for the given column to the supplied value.
    The offset for the null bit is obtained from the passed 
    NdbRecord object.
    
    If the attrId is not part of the NdbRecord, or is not nullable
    then an error will be returned.
    
    @param record : Pointer to NdbRecord object describing the row format
    @param row : Pointer to the start of row data
    @param atrId : Attribute id of the column
    @param value : Value to set null bit to
    @returns : 0 in success, -1 if the attrId is not part of the record,
    or is not nullable
  */
  static int setNull(const NdbRecord* record,
                     char* row,
                     Uint32 attrId,
                     bool value);
  
  /*
    Return the number of bytes needed to store one row of data
    laid out as described by the passed NdbRecord structure.
  */
  static Uint32 getRecordRowLength(const NdbRecord* record);
  
  /*
    Return an empty column presence bitmask.
    This bitmask can be used with any NdbRecord to specify that
    no NdbRecord columns are to be included in the operation.
  */
  static const unsigned char* getEmptyBitmask();
  
  struct AutoGrowSpecification {
    Uint32 min_free;
    Uint64 max_size;
    Uint64 file_size;
    const char * filename_pattern;
  };

  class LogfileGroup : public Object {
  public:
    LogfileGroup();
    LogfileGroup(const LogfileGroup&);
    virtual ~LogfileGroup();

    void setName(const char * name);
    const char* getName() const;

    void setUndoBufferSize(Uint32 sz);
    Uint32 getUndoBufferSize() const;
    
    void setAutoGrowSpecification(const AutoGrowSpecification&);
    const AutoGrowSpecification& getAutoGrowSpecification() const;

    Uint64 getUndoFreeWords() const;

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

  private:
    friend class NdbDictionaryImpl;
    friend class NdbLogfileGroupImpl;
    class NdbLogfileGroupImpl & m_impl;
    LogfileGroup(NdbLogfileGroupImpl&);
  };

  class Tablespace : public Object {
  public:
    Tablespace();
    Tablespace(const Tablespace&);
    virtual ~Tablespace();

    void setName(const char * name);
    const char* getName() const;

    void setExtentSize(Uint32 sz);
    Uint32 getExtentSize() const;

    void setAutoGrowSpecification(const AutoGrowSpecification&);
    const AutoGrowSpecification& getAutoGrowSpecification() const;

    void setDefaultLogfileGroup(const char * name);
    void setDefaultLogfileGroup(const class LogfileGroup&);

    const char * getDefaultLogfileGroup() const;
    Uint32 getDefaultLogfileGroupId() const;
    
    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

  private:
    friend class NdbTablespaceImpl;
    class NdbTablespaceImpl & m_impl;
    Tablespace(NdbTablespaceImpl&);
  };

  class Datafile : public Object {
  public:
    Datafile();
    Datafile(const Datafile&);
    virtual ~Datafile();

    void setPath(const char * name);
    const char* getPath() const;
  
    void setSize(Uint64);
    Uint64 getSize() const;
    Uint64 getFree() const;
    
    int setTablespace(const char * name);
    int setTablespace(const class Tablespace &);
    const char * getTablespace() const;
    void getTablespaceId(ObjectId * dst) const;

    void setNode(Uint32 nodeId);
    Uint32 getNode() const;

    Uint32 getFileNo() const;

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

  private:
    friend class NdbDatafileImpl;
    class NdbDatafileImpl & m_impl;
    Datafile(NdbDatafileImpl&);
  };

  class Undofile : public Object {
  public:
    Undofile();
    Undofile(const Undofile&);
    virtual ~Undofile();

    void setPath(const char * path);
    const char* getPath() const;
  
    void setSize(Uint64);
    Uint64 getSize() const;

    void setLogfileGroup(const char * name);
    void setLogfileGroup(const class LogfileGroup &);
    const char * getLogfileGroup() const;
    void getLogfileGroupId(ObjectId * dst) const;

    void setNode(Uint32 nodeId);
    Uint32 getNode() const;

    Uint32 getFileNo() const;

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

  private:
    friend class NdbUndofileImpl;
    class NdbUndofileImpl & m_impl;
    Undofile(NdbUndofileImpl&);
  };

  class HashMap : public Object {
  public:
    HashMap();
    HashMap(const HashMap&);
    virtual ~HashMap();

    void setName(const char *);
    const char * getName() const;

    void setMap(const Uint32* values, Uint32 len);
    Uint32 getMapLen() const;
    int getMapValues(Uint32* dst, Uint32 len) const;

    bool equal(const HashMap&) const;

    virtual Object::Status getObjectStatus() const;

    virtual int getObjectVersion() const;

    virtual int getObjectId() const;

  private:
    friend class NdbHashMapImpl;
    class NdbHashMapImpl & m_impl;
    HashMap(NdbHashMapImpl&);
  };

  class Dictionary {
  public:
    struct List {
      struct Element {
        unsigned id;            
        Object::Type type;      
        Object::State state;    
        Object::Store store;    
        Uint32 temp;            
        char * database;        
        char * schema;          
        char * name;            
        Element() :
          id(0),
          type(Object::TypeUndefined),
          state(Object::StateUndefined),
          store(Object::StoreUndefined),
          temp(NDB_TEMP_TAB_PERMANENT),
          database(0),
          schema(0),
          name(0) {
        }
      };
      unsigned count;           
      Element * elements;       
      List() : count(0), elements(0) {}
      ~List() {
        if (elements != 0) {
          for (unsigned i = 0; i < count; i++) {
            delete[] elements[i].database;
            delete[] elements[i].schema;
            delete[] elements[i].name;
            elements[i].name = 0;
          }
          delete[] elements;
          count = 0;
          elements = 0;
        }
      }
    };

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    int listObjects(List & list, Object::Type type = Object::TypeUndefined);
#endif
    int listObjects(List & list,
                    Object::Type type = Object::TypeUndefined) const;
    int listObjects(List & list,
                    Object::Type type,
                    bool fullyQualified) const;

    const struct NdbError & getNdbError() const;

    int getWarningFlags() const;

    const Table * getTable(const char * name) const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

    const Table * getBlobTable(const Table *, const char * col_name);
    const Table * getBlobTable(const Table *, Uint32 col_no);

    /*
     * Save a table definition in dictionary cache
     * @param table Object to put into cache
     */
    void putTable(const Table * table);
#endif

    const Index * getIndex(const char * indexName,
                           const char * tableName) const;

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    int listIndexes(List & list, const char * tableName);
#endif
    int listIndexes(List & list, const char * tableName) const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

    int listIndexes(List & list, const Table &table) const;
#endif

    int createEvent(const Event &event);

    int dropEvent(const char * eventName, int force= 0);
    
    const Event * getEvent(const char * eventName);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
    int listEvents(List & list);
#endif
    int listEvents(List & list) const;

    int createTable(const Table &table);

    int createTable(const Table &table, ObjectId * objid);

    int
    optimizeTable(const Table &t, OptimizeTableHandle &h);

    int
    optimizeIndex(const Index &ind, OptimizeIndexHandle &h);

    int dropTable(Table & table);

    int dropTable(const char * name);
    
    bool supportedAlterTable(const Table & f, const Table & t);

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

    int alterTable(const Table & f, const Table & t);

    void invalidateTable(const char * name);
#endif

    void removeCachedTable(const char * table);
    void removeCachedIndex(const char * index, const char * table);

    
    int createIndex(const Index &index, bool offline = false);
    int createIndex(const Index &index, const Table &table, bool offline = false);

    int dropIndex(const char * indexName,
                  const char * tableName);

    /*
     * Force update of ordered index stats.  Scans an assigned fragment
     * in the kernel and updates result in stats tables.  This one-time
     * update is independent of IndexStatAuto settings.  Common use case
     * is mysql "analyze table".
     */
    int updateIndexStat(const Index&, const Table&);

    /*
     * Force update of ordered index stats where index is given by id.
     */
    int updateIndexStat(Uint32 indexId, Uint32 indexVersion, Uint32 tableId);

    /*
     * Delete ordered index stats.  If IndexStatAutoUpdate is set, also
     * stops automatic updates, until another forced update is done.
     */
    int deleteIndexStat(const Index&, const Table&);

    /*
     * Delete ordered index stats where index is given by id.
     */
    int deleteIndexStat(Uint32 indexId, Uint32 indexVersion, Uint32 tableId);
    
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    void removeCachedTable(const Table *table);
    void removeCachedIndex(const Index *index);
    void invalidateTable(const Table *table);
    void invalidateIndex(const char * indexName,
                         const char * tableName);
    void invalidateIndex(const Index *index);
    int forceGCPWait();
    int forceGCPWait(int type);

    int getRestartGCI(Uint32 * gci);
#endif

    /*
     * The four "create" operations can return warning flags defined
     * below.  See getWarningFlags().
     */
    enum {
      WarnUndobufferRoundUp = 0x1,  // rounded up to kernel page size
      WarnUndofileRoundDown = 0x2,  // rounded down to kernel page size
      WarnExtentRoundUp = 0x4,      // rounded up to kernel page size
      WarnDatafileRoundDown = 0x8,  // rounded down to kernel page size
      WarnDatafileRoundUp = 0x10    // rounded up to extent size
    };

    int createLogfileGroup(const LogfileGroup &, ObjectId* = 0);
    int dropLogfileGroup(const LogfileGroup&);
    LogfileGroup getLogfileGroup(const char * name);

    int createTablespace(const Tablespace &, ObjectId* = 0);
    int dropTablespace(const Tablespace&);
    Tablespace getTablespace(const char * name);
    Tablespace getTablespace(Uint32 tablespaceId);

    int createDatafile(const Datafile &, bool overwrite_existing = false, ObjectId* = 0);
    int dropDatafile(const Datafile&);
    Datafile getDatafile(Uint32 node, const char * path);
    
    int createUndofile(const Undofile &, bool overwrite_existing = false, ObjectId * = 0);
    int dropUndofile(const Undofile&);
    Undofile getUndofile(Uint32 node, const char * path);
    

    int createHashMap(const HashMap&, ObjectId* = 0);

    int getHashMap(HashMap& dst, const char* name);

    int getHashMap(HashMap& dst, const Table* table);

    int getDefaultHashMap(HashMap& dst, Uint32 fragments);


    int initDefaultHashMap(HashMap& dst, Uint32 fragments);

    int prepareHashMap(const Table& oldTable, Table& newTable);

    int beginSchemaTrans();

    int endSchemaTrans(Uint32 flags = 0);

    enum SchemaTransFlag {
      // abort transaction
      SchemaTransAbort = 1,
      // do not wait for reply, status is reported in cluster log
      SchemaTransBackground = 2
    };

    bool hasSchemaTrans() const;

  protected:
    Dictionary(Ndb & ndb);
    ~Dictionary();
    
  private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    friend class NdbDictionaryImpl;
    friend class UtilTransactions;
    friend class NdbBlob;
#endif
    class NdbDictionaryImpl & m_impl;
    Dictionary(NdbDictionaryImpl&);
    const Table * getIndexTable(const char * indexName, 
                                const char * tableName) const;
  public:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    const Table * getTable(const char * name, void **data) const;
    void set_local_table_data_size(unsigned sz);

    const Index * getIndexGlobal(const char * indexName,
                                 const Table &ndbtab) const;
    const Index * getIndexGlobal(const char * indexName,
                                 const char * tableName) const;
    const Table * getTableGlobal(const char * tableName) const;
    int alterTableGlobal(const Table &f, const Table &t);
    int dropTableGlobal(const Table &ndbtab);
    int dropIndexGlobal(const Index &index);
    int removeIndexGlobal(const Index &ndbidx, int invalidate) const;
    int removeTableGlobal(const Table &ndbtab, int invalidate) const;
    void invalidateDbGlobal(const char * dbname);
#endif

    /*
      Create an NdbRecord for use in table operations.
    */
    NdbRecord *createRecord(const Table *table,
                            const RecordSpecification *recSpec,
                            Uint32 length,
                            Uint32 elemSize,
                            Uint32 flags= 0);

    /*
      Create an NdbRecord for use in index operations.
    */
    NdbRecord *createRecord(const Index *index,
                            const Table *table,
                            const RecordSpecification *recSpec,
                            Uint32 length,
                            Uint32 elemSize,
                            Uint32 flags= 0);
    /*
      Create an NdbRecord for use in index operations.
      This variant assumes that the index is for a table in 
      the current database and schema
    */
    NdbRecord *createRecord(const Index *index,
                            const RecordSpecification *recSpec,
                            Uint32 length,
                            Uint32 elemSize,
                            Uint32 flags= 0);

    /*
      Free an NdbRecord object created earlier with
      createRecord
    */
    void releaseRecord(NdbRecord *rec);
  }; // class Dictionary

  class NdbDataPrintFormat
  {
  public:
    NdbDataPrintFormat();
    virtual ~NdbDataPrintFormat();
    const char *lines_terminated_by;
    const char *fields_terminated_by;
    const char *start_array_enclosure;
    const char *end_array_enclosure;
    const char *fields_enclosed_by;
    const char *fields_optionally_enclosed_by;
    const char *hex_prefix;
    const char *null_string;
    int hex_format;
  };

  static 
  class NdbOut& printFormattedValue(class NdbOut& out, 
                                    const NdbDataPrintFormat& format,
                                    const NdbDictionary::Column* c,
                                    const void* val);
  

}; // class NdbDictionary

class NdbOut& operator <<(class NdbOut& out, const NdbDictionary::Column& col);

#endif