NdbSchemaOp.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 NdbSchemaOp_H
#define NdbSchemaOp_H

#include <NdbDictionary.hpp>

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  enum AttrType { 
    Signed,           




    UnSigned,         




    Float,            


    String,           


    NoAttrTypeDef     
  };


  enum NullAttributeType { 
    NoNullTypeDefined = -1,
    NotNullAttribute, 
    NullAttribute,
    AttributeDefined 
  };
  enum KeyType { 
    Undefined = -1,               
    NoKey,                        

    TupleKey,                     
    TupleId                       



  };
  enum StorageMode { 
    MMBased = NDB_STORAGETYPE_MEMORY,
    DiskBased = NDB_STORAGETYPE_DISK
  };
  
  enum FragmentType { 
    Default = 0,                  
    Single = 1,                   
    All = 2,                      
    DistributionGroup = 3,        

    DistributionKey = 4,          

    AllLarge = 5,                 
    DGroupLarge = 6,              

    DKeyLarge = 7                 

  };
  
  enum TableType {
    UndefTableType = 0,
    SystemTable = 1,              
    UserTable = 2,                  
    UniqueHashIndex = 3,          
    HashIndex = 4,                
    UniqueOrderedIndex = 5,       
    OrderedIndex = 6              
  };


class NdbSchemaCon;
class Ndb;
  

class NdbSchemaOp 
{
  friend class Ndb;
  friend class NdbSchemaCon;

public:

  
  int           createTable(    const char* aTableName, 
                                Uint32 aTableSize = 8, 
                                KeyType aTupleKey = TupleKey,
                                int aNrOfPages = 2, 
                                FragmentType aFragmentType = All, 
                                int aKValue = 6,
                                int aMinLoadFactor = 78,
                                int aMaxLoadFactor = 80,
                                int aMemoryType = 1,
                                bool aStoredTable = true);

#ifndef NDB_WIN32
  inline int    createTable(    const char* aTableName, 
                                Uint32 aTableSize, 
                                KeyType aTupleKey,
                                int aNrOfPages, 
                                FragmentType aFragmentType, 
                                int aKValue,
                                int aMinLoadFactor,
                                int aMaxLoadFactor,
                                int aMemoryType,
                                int aStoredTable){
    return createTable(aTableName, 
                       aTableSize, 
                       aTupleKey,                        
                       aNrOfPages, 
                       aFragmentType, 
                       aKValue, 
                       aMinLoadFactor, 
                       aMaxLoadFactor, 
                       aMemoryType, 
                       (aStoredTable == 1 ? true : false));
  }
#endif

  int createAttribute(const char* aAttrName,
                      KeyType aTupleKey = NoKey,
                      int aAttrSize = 32,
                      int aArraySize = 1,
                      AttrType aAttrType = UnSigned,
                      StorageMode aStorageMode = MMBased,
                      bool nullable = false,
                      int aStType= 0, // obsolete
                      int aDistributionKey = 0,
                      int aDistributionGroup = 0,
                      int aDistributionGroupNoOfBits = 16,
                      bool aAutoIncrement = false,
                      const char* aDefaultValue = 0);

  int createAttribute(const char* aAttrName,
                      KeyType aTupleKey,
                      int aAttrSize,
                      int aArraySize,
                      AttrType aAttrType,
                      StorageMode aStorageMode,
                      NullAttributeType aNullAttr,
                      int aStType, // obsolete
                      int aDistributionKey = 0,
                      int aDistributionGroup = 0,
                      int aDistributionGroupNoOfBits = 16){
    return createAttribute(aAttrName,
                           aTupleKey,
                           aAttrSize,
                           aArraySize,
                           aAttrType,
                           aStorageMode,
                           aNullAttr == NullAttribute,
                           aStType,
                           aDistributionKey,
                           aDistributionGroup,
                           aDistributionGroupNoOfBits);
  }

  const NdbError & getNdbError() const;

protected:

/*****************************************************************************
 *   These are the methods used to create and delete the NdbOperation objects.
 ****************************************************************************/
                        NdbSchemaOp(Ndb* aNdb);

                        ~NdbSchemaOp();     

/******************************************************************************
 *      These methods are service routines used by the other NDBAPI classes.
 *****************************************************************************/

  void                  release();      // Release all memory connected
                                              // to the operations object.          

/****************************************************************************
 *      The methods below is the execution part of the NdbSchemaOp class. 
 *****************************************************************************/

  int sendRec();        
  int sendSignals(Uint32 aNodeId, bool HaveMutex);

  int init(NdbSchemaCon* aSchemaCon);

  /**************************************************************************
   * These are the private variables that are defined in the operation 
   * objects.
   **************************************************************************/
  Ndb*                  theNdb;         // Point back to the Ndb object.      
  NdbSchemaCon*         theSchemaCon;   // Point back to the connection object.
  

  class NdbDictionary::Table * m_currentTable;
};


inline 
AttrType 
convertColumnTypeToAttrType(NdbDictionary::Column::Type _type)
{      
  
  switch(_type){
  case NdbDictionary::Column::Bigint:
  case NdbDictionary::Column::Int:
    return Signed;
  case NdbDictionary::Column::Bigunsigned:
  case NdbDictionary::Column::Unsigned:
    return UnSigned;
  case NdbDictionary::Column::Float:
  case NdbDictionary::Column::Olddecimal:
  case NdbDictionary::Column::Olddecimalunsigned:
  case NdbDictionary::Column::Decimal:
  case NdbDictionary::Column::Decimalunsigned:
  case NdbDictionary::Column::Double:
    return Float;
  case NdbDictionary::Column::Char:
  case NdbDictionary::Column::Varchar:
  case NdbDictionary::Column::Binary:
  case NdbDictionary::Column::Varbinary:
    return String;
  default:
    return NoAttrTypeDef;
  }
}
#endif

#endif