Removed AttrType.hpp and moved the "internal" datatypes to their corresponding class.

Moved NdbSchemaCon and NdbSchemaOp out of the public NdbApi, it can however still be used by old test programs.
Added print oof indexes to desc.


ndb/BinDist.sh:
  Removed AttrType.hpp from BinDist.sh
ndb/include/ndbapi/Ndb.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
ndb/include/ndbapi/NdbApi.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
ndb/include/ndbapi/NdbConnection.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
  Moved internal types to the class where they are used
ndb/include/ndbapi/NdbIndexOperation.hpp:
  Use limit from ndbapi_limit.h
ndb/include/ndbapi/NdbOperation.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
  Remove faulty comment about how many attributes a key is allowed to consist of
  Removed unused member variables
ndb/include/ndbapi/NdbRecAttr.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
ndb/include/ndbapi/NdbSchemaCon.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
ndb/include/ndbapi/NdbSchemaOp.hpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
  Moved all "old" datatypes here, so if a test program is still using old type, include NdbSchemaCon.hpp
ndb/include/ndbapi/ndbapi_limits.h:
  Corrected limitations, added some from AttrTyp.hpp
ndb/src/Makefile:
  Remove newtonapi from Makefile
ndb/src/kernel/blocks/backup/restore/Restore.hpp:
  Removed AttrType
  Include NdbSchemaCon since restore uses old types
ndb/src/kernel/blocks/backup/restore/main.cpp:
  Include NdbOut
ndb/src/mgmsrv/MgmtSrvr.cpp:
  Remov AttrType.hpp
ndb/src/ndbapi/ClusterMgr.cpp:
  Remov AttrType.hpp
ndb/src/ndbapi/Ndb.cpp:
  Removed NdbSchemaCon and NdbSchemaOp includes from public NdbApi
  Removed AttrType.hpp
  Moved internal types to the class where they are used
ndb/src/ndbapi/NdbApiSignal.cpp:
  Removed AttrType.hpp
ndb/src/ndbapi/NdbApiSignal.hpp:
  Removed AttrType.hpp
ndb/src/ndbapi/NdbConnection.cpp:
  Moved internal type s to the class where they belong
ndb/src/ndbapi/NdbDictionaryImpl.cpp:
  RemovedAttrType.hpp
  Use limits from ndbapi_limits.h
ndb/src/ndbapi/NdbEventOperationImpl.cpp:
  Removed AttrType.hpp
  Moved printRecAttr to end since it depends on old types and need to include "NdbSchemaCon", function will be rewritten and moved to NdbRecAttr. It's also useful from other places where an attribute has been read into an NdbRecAttr.
ndb/src/ndbapi/NdbIndexOperation.cpp:
  Use limitations from ndbapi_limits.h
  Moved internal tyeps to the class where they belongs
ndb/src/ndbapi/NdbOperation.cpp:
  Use limits from ndbapi_limits.h
ndb/src/ndbapi/NdbOperationDefine.cpp:
  Remove AttrType.hpp
ndb/src/ndbapi/NdbOperationExec.cpp:
  Moved internal tyeps to the class where they belongs
ndb/src/ndbapi/NdbOperationInt.cpp:
  RemovedAttrType.hpp
  Use limits from ndbapi_limits.h
ndb/src/ndbapi/NdbOperationScan.cpp:
  RemovedAttrType.hpp
  Use limits from ndbapi_limits.h
ndb/src/ndbapi/NdbOperationSearch.cpp:
  Removed AttrType.hpp
  Use limits from ndbapi_limits.h
ndb/src/ndbapi/NdbResultSet.cpp:
  Moved the "internal" types to corresponding class
ndb/src/ndbapi/NdbSchemaCon.cpp:
  Updated not to be included in public NdbApi
ndb/src/ndbapi/NdbSchemaOp.cpp:
  Updated not to be included in public NdbApi
ndb/src/ndbapi/NdbUtil.hpp:
  Removed AttrType.hpp
ndb/src/ndbapi/Ndbif.cpp:
  Removed AttrType.hpp
  Removed NdbSchemaCon and NdbSchemaOp from public NdbApi
  Moved "interal" types to their corresponding class
ndb/src/ndbapi/Ndbinit.cpp:
  Removed NdbSchemaCon and NdbSchemaOp from public NdbApi
ndb/src/ndbapi/Ndblist.cpp:
  Removed NdbSchemaCon and NdbSchemaOp from public NdbApi
  Moved "internal" types to their corresponding class
ndb/src/ndbapi/TransporterFacade.cpp:
  Removed AttrType.hpp
ndb/src/ndbapi/TransporterFacade.hpp:
  Removed AttrType.hpp
  Moved internal definition of how many Ndb objects to create to here
ndb/test/include/NDBT_Table.hpp:
  Removed old NdbSchema*
  Added function to print information about an index
ndb/test/ndbapi/acid/acid.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/flexAsynch/flexAsynch.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/flexScan/flexScan.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/interpreterInTup/interpreterInTup.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/lmc-bench/src/user/userInterface.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/ronja/initronja/initronja.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/telco/msa.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp:
  This test program uses old NdbScheaCon.hpp
ndb/test/ndbapi/testNdbApi/testNdbApi.cpp:
  Remove AttrType.hpp
  Define max number of Ndb objects test should "try" to create.
ndb/test/ndbapi/testRestartGci/testRestartGci.cpp:
  Moved "internal" datatypes to corresponding class, in this case Ndb class
ndb/test/src/NDBT_ResultRow.cpp:
  This test program uses old NdbScheaCon.hpp
  But should soon use "printer" from NdbRecAttr
ndb/test/src/NDBT_Table.cpp:
  Print table info more SQL like
ndb/test/src/UtilTransactions.cpp:
  When AttrType.hpp, this hidden bug was discovered. Using wrong enum types in switch.
ndb/tools/desc/desc.cpp:
  Alos print info about indexes for a table

52 files changed, 694 insertions, 506 deletions

diff --git a/ndb/BinDist.sh b/ndb/BinDist.sh
index 2f9620549f4..3574b0d64ce 100644
--- a/ndb/BinDist.sh
+++ b/ndb/BinDist.sh
@@ -50,7 +50,6 @@ include/mgmapi/mgmapi.h
 include/mgmapi/mgmapi_debug.h
 include/ndbapi/
 include/ndbapi/ndbapi_limits.h
-include/ndbapi/AttrType.hpp
 include/ndbapi/Ndb.hpp
 include/ndbapi/NdbApi.hpp
 include/ndbapi/NdbConnection.hpp
diff --git a/ndb/include/ndbapi/Ndb.hpp b/ndb/include/ndbapi/Ndb.hpp
index fd6e827ceb4..3acfcd194e8 100644
--- a/ndb/include/ndbapi/Ndb.hpp
+++ b/ndb/include/ndbapi/Ndb.hpp
@@ -860,7 +860,6 @@
 
 #include <ndb_types.h>
 #include <ndbapi_limits.h>
-#include <AttrType.hpp>
 #include <NdbError.hpp>
 #include <NdbDictionary.hpp>
 
@@ -870,8 +869,6 @@ class NdbEventOperationImpl;
 class NdbScanOperation;
 class NdbIndexOperation;
 class NdbConnection;
-class NdbSchemaOp;
-class NdbSchemaCon;
 class NdbApiSignal;
 class NdbRecAttr;
 class NdbLabel;
@@ -961,8 +958,6 @@ class Ndb
   friend class NdbOperation;
   friend class NdbEventOperationImpl;
   friend class NdbConnection;
-  friend class NdbSchemaOp;
-  friend class NdbSchemaCon;
   friend class Table;
   friend class NdbApiSignal;
   friend class NdbScanReceiver;
@@ -1064,8 +1059,6 @@ public:
    *         A value larger than 1024 will be downgraded to 1024. 
    *         This means that one Ndb object can handle at most 1024 parallel
    *         transactions. 
-   *         There is a maximum of 128 simultaneous
-   *         Ndb object within one application process.
    * @return 0 if successful, -1 otherwise.
    *
    * @note   The internal implementation multiplies this value 
@@ -1245,22 +1238,6 @@ public:
    */
   void closeTransaction(NdbConnection* aConnection);
   
-#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
-  /**
-   * To create a table it is necessary to obtain a schema transaction 
-   * object.  
-   * All schema transactions need to closed when they are
-   * completed.
-   * 
-   * @return NdbSchemaCon
-   */
-  NdbSchemaCon*	startSchemaTransaction();
-
-  /**
-   *  Close schema transaction when finished.
-   */
-  void closeSchemaTransaction(NdbSchemaCon* aSchemaCon);
-#endif
 
   /** @} *********************************************************************/
 
@@ -1391,6 +1368,20 @@ public:
   /** @} *********************************************************************/
 
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
+
+  /**
+   * Different types of tampering with the NDB Cluster.
+   * <b>Only for debugging purposes only.</b>
+   */
+  enum TamperType	{ 
+    LockGlbChp = 1,               ///< Lock GCP
+    UnlockGlbChp,                 ///< Unlock GCP
+    CrashNode,                    ///< Crash an NDB node
+    ReadRestartGCI,               ///< Request the restart GCI id from NDB Cluster
+    InsertError                   ///< Execute an error in NDB Cluster 
+                                  ///< (may crash system)
+  };
+
   /**
    * For testing purposes it is possible to tamper with the NDB Cluster
    * (i.e. send a special signal to DBDIH, the NDB distribution handler).
@@ -1398,14 +1389,7 @@ public:
    * In a release versions of NDB Cluster,
    * this call always return -1 and does nothing.
    * 
-   * @param aAction Action to be taken
-   *                - 1:     Lock global checkpointing
-   *	                     (Can only be sent to master DIH, 
-   *                         Parameter aNode ignored).
-   *	            - 2:     UnLock global checkpointing    
-   *	                     (Can only be sent to master DIH, 
-   *                         Parameter aNode ignored).
-   *                - 3:     Crash node.
+   * @param aAction Action to be taken according to TamperType above
    *
    * @param aNode  Which node the action will be taken
    *              -1:   Master DIH.
@@ -1616,9 +1600,6 @@ private:
 
   NdbScanOperation*	theScanOpIdleList;	// First scan operation in the idle list. 
   NdbIndexOperation*	theIndexOpIdleList;	// First index operation in the idle list. 
-  NdbSchemaCon*		theSchemaConIdleList;  // First schemaCon in idle list.
-
-  NdbSchemaCon* 	theSchemaConToNdbList; // Connected schemaCon object.
   NdbConnection*	theTransactionList;
   NdbConnection**       theConnectionArray;
   NdbRecAttr*		theRecAttrIdleList;  
@@ -1649,7 +1630,14 @@ private:
   NdbError              theError;
 
   Int32        	        theNdbBlockNumber;
-  InitType		theInitState;
+
+  enum InitType {
+    NotConstructed,
+    NotInitialised,
+    StartingInit,
+    Initialised,
+    InitConfigError
+  } theInitState;
 
   // Ensure good distribution of connects
   Uint32		theCurrentConnectIndex;
diff --git a/ndb/include/ndbapi/NdbApi.hpp b/ndb/include/ndbapi/NdbApi.hpp
index e5efc9756ce..b9b52708789 100644
--- a/ndb/include/ndbapi/NdbApi.hpp
+++ b/ndb/include/ndbapi/NdbApi.hpp
@@ -17,14 +17,12 @@
 #ifndef NdbApi_H
 #define NdbApi_H
 
+#include "ndbapi_limits.h"
 #include "Ndb.hpp"
-#include "AttrType.hpp"
 #include "NdbConnection.hpp"
 #include "NdbOperation.hpp"
 #include "NdbScanOperation.hpp"
 #include "NdbIndexOperation.hpp"
-#include "NdbSchemaCon.hpp"
-#include "NdbSchemaOp.hpp"
 #include "NdbRecAttr.hpp"
 #include "NdbResultSet.hpp"
 #include "NdbDictionary.hpp"
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp
index c775dd5e33d..89786f63cc5 100644
--- a/ndb/include/ndbapi/NdbConnection.hpp
+++ b/ndb/include/ndbapi/NdbConnection.hpp
@@ -18,7 +18,6 @@
 #define NdbConnection_H
 
 #include <ndb_types.h>
-#include <AttrType.hpp>
 #include <NdbError.hpp>
 
 class NdbConnection;
@@ -41,6 +40,35 @@ class NdbScanReceiver;
 typedef void (* NdbAsynchCallback)(int, NdbConnection*, void*);
 
 /**
+ * Commit type of transaction
+ */
+enum AbortOption {      
+#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
+  CommitIfFailFree = 0,         
+  CommitAsMuchAsPossible = 2,   ///< Commit transaction with as many 
+  TryCommit = 0,                ///< <i>Missing explanation</i>
+#endif
+  AbortOnError = 0,             ///< Abort transaction on failed operation
+  IgnoreError = 2               ///< Transaction continues on failed operation
+};
+  
+typedef AbortOption CommitType;
+
+
+/**
+ * Execution type of transaction
+ */
+enum ExecType { 
+  NoExecTypeDef = -1,           ///< Erroneous type (Used for debugging only)
+  Prepare,                      ///< <i>Missing explanation</i>
+  NoCommit,                     ///< Execute the transaction as far as it has
+                                ///< been defined, but do not yet commit it
+  Commit,                       ///< Execute and try to commit the transaction
+  Rollback                      ///< Rollback transaction
+};
+
+
+/**
  * @class NdbConnection
  * @brief Represents a transaction.
  *
@@ -419,6 +447,14 @@ public:
    * @return  The commit status of the transaction, i.e. one of
    *          { NotStarted, Started, TimeOut, Committed, Aborted, NeedAbort } 
    */
+  enum CommitStatusType { 
+    NotStarted,                   ///< Transaction not yet started
+    Started,                      ///< <i>Missing explanation</i>
+    Committed,                    ///< Transaction has been committed
+    Aborted,                      ///< Transaction has been aborted
+    NeedAbort                     ///< <i>Missing explanation</i>
+  };
+
   CommitStatusType commitStatus();
 
   /** @} *********************************************************************/
@@ -515,8 +551,17 @@ private:
   Uint32        getBuddyConPtr();                 // Gets Buddy Con Ptr
   NdbConnection* next();			  // Returns the next pointer
   void		next(NdbConnection*);		  // Sets the next pointer
-  ConStatusType Status();			  // Read the status information
-  void		Status(ConStatusType);	          // Set the status information
+
+  enum ConStatusType { 
+    NotConnected,
+    Connecting,
+    Connected,
+    DisConnecting,
+    ConnectFailure
+  };
+  ConStatusType Status();                 // Read the status information
+  void		Status(ConStatusType);	  // Set the status information
+
   Uint32        get_send_size();                  // Get size to send
   void          set_send_size(Uint32);            // Set size to send;
   
@@ -595,6 +640,18 @@ private:
   Uint32 theId;
 
   // Keeps track of what the send method should do.
+  enum SendStatusType { 
+    NotInit,  
+    InitState,  
+    sendOperations,  
+    sendCompleted, 
+    sendCOMMITstate, 
+    sendABORT, 
+    sendABORTfail, 
+    sendTC_ROLLBACK,  
+    sendTC_COMMIT, 
+    sendTC_OP       
+  };
   SendStatusType theSendStatus; 
   NdbAsynchCallback  theCallbackFunction;    // Pointer to the callback function
   void*              theCallbackObject;      // The callback object pointer
@@ -628,12 +685,18 @@ private:
   Uint64	theTransactionId;			// theTransactionId of the transaction
   Uint32	theGlobalCheckpointId;			// The gloabl checkpoint identity of the transaction
   ConStatusType	theStatus;				// The status of the connection		
-
-  CompletionStatus theCompletionStatus;			// The Completion status of the transaction
+  enum CompletionStatus { 
+    NotCompleted,
+    CompletedSuccess,
+    CompletedFailure,
+    DefinitionFailure
+  } theCompletionStatus;	  // The Completion status of the transaction
   CommitStatusType theCommitStatus;			// The commit status of the transaction
   Uint32	theMagicNumber;				// Magic Number to verify correct object
 
   Uint32	thePriority;				// Transaction Priority
+
+  enum ReturnType {  ReturnSuccess,  ReturnFailure };
   ReturnType    theReturnStatus;			// Did we have any read/update/delete failing
 							// to find the tuple.
   bool theTransactionIsStarted; 
@@ -641,7 +704,12 @@ private:
   bool theSimpleState;
   Uint8 m_abortOption;           // Type of commit
 
-  ListState     theListState;
+  enum ListState {  
+    NotInList, 
+    InPreparedList, 
+    InSendList, 
+    InCompletedList 
+  } theListState;
 
   Uint32 theDBnode;       // The database node we are connected to  
   Uint32 theNodeSequence; // The sequence no of the db node
@@ -830,7 +898,7 @@ Parameters:     aStatus:  The status.
 Remark:         Sets Connect status. 
 ******************************************************************************/
 inline
-ConStatusType			
+NdbConnection::ConStatusType			
 NdbConnection::Status()
 {
   return theStatus;
@@ -849,6 +917,7 @@ NdbConnection::Status( ConStatusType aStatus )
   theStatus = aStatus;
 }
 
+
 /******************************************************************************
  void    	setGCI();
 
diff --git a/ndb/include/ndbapi/NdbIndexOperation.hpp b/ndb/include/ndbapi/NdbIndexOperation.hpp
index 3b8e5f7a888..baf31dca0ee 100644
--- a/ndb/include/ndbapi/NdbIndexOperation.hpp
+++ b/ndb/include/ndbapi/NdbIndexOperation.hpp
@@ -184,7 +184,7 @@ private:
 
   // Private attributes
   NdbIndexImpl* m_theIndex;
-  Uint32 m_theIndexDefined[MAXNROFTUPLEKEY][3];
+  Uint32 m_theIndexDefined[NDB_MAX_ATTRIBUTES_IN_INDEX][3];
   Uint32 m_theIndexLen;	  	 // Length of the index in words
   Uint32 m_theNoOfIndexDefined;  // The number of index attributes
 };
diff --git a/ndb/include/ndbapi/NdbOperation.hpp b/ndb/include/ndbapi/NdbOperation.hpp
index 3c515fe84ef..e772a30f571 100644
--- a/ndb/include/ndbapi/NdbOperation.hpp
+++ b/ndb/include/ndbapi/NdbOperation.hpp
@@ -18,10 +18,9 @@
 #define NdbOperation_H
 
 #include <ndb_types.h>
-
-#include <AttrType.hpp>
-#include <NdbError.hpp>
-#include <NdbReceiver.hpp>
+#include "ndbapi_limits.h"
+#include "NdbError.hpp"
+#include "NdbReceiver.hpp"
 
 class Ndb;
 class NdbApiSignal;
@@ -835,6 +834,22 @@ public:
 
   /** @} *********************************************************************/
 
+  /**
+   * Type of operation
+   */
+  enum OperationType { 
+    ReadRequest = 0,              ///< Read operation
+    UpdateRequest = 1,            ///< Update Operation
+    InsertRequest = 2,            ///< Insert Operation
+    DeleteRequest = 3,            ///< Delete Operation
+    WriteRequest = 4,             ///< Write Operation
+    ReadExclusive = 5,            ///< Read exclusive
+    OpenScanRequest,              ///< Scan Operation
+    OpenRangeScanRequest,         ///< Range scan operation
+    NotDefined2,                  ///< Internal for debugging
+    NotDefined                    ///< Internal for debugging
+  };
+
 protected:
 /******************************************************************************
  * These are the methods used to create and delete the NdbOperation objects.
@@ -865,11 +880,27 @@ protected:
 
   NdbOperation*	    next();	        // Get next pointer		       
 
+  enum OperationStatus{ 
+    Init,                       
+    OperationDefined,
+    TupleKeyDefined,
+    GetValue,
+    SetValue,
+    ExecInterpretedValue,
+    SetValueInterpreted,
+    FinalGetValue,
+    SubroutineExec,
+    SubroutineEnd,
+    SetBound,
+    WaitResponse,
+    WaitCommitResponse,
+    Finished,
+    ReceiveFinished
+  };
+
   OperationStatus   Status();	         	// Read the status information
   
   void		    Status(OperationStatus);    // Set the status information
-  
-  OperationType	    RequestType();
 
   void		    NdbCon(NdbConnection*);	// Set reference to connection
   						// object.
@@ -879,8 +910,6 @@ protected:
 					      	// the operations object.      
   void		    setStartIndicator();
 
-  void		    setCommitIndicator(CommitType aCommitType);
-
 /******************************************************************************
  * The methods below is the execution part of the NdbOperation
  * class. This is where the NDB signals are sent and received. The
@@ -1013,18 +1042,13 @@ protected:
   Uint32	    theCurrRecAI_Len;	 // The currently received length   
   Uint32	    theAI_ElementLen;	 // How many words long is this element 
   Uint32*	    theCurrElemPtr;   	 // The current pointer to the element  
-  //Uint32	    theTableId;		 // Table id.     
-  //Uint32	    theAccessTableId;	 // The id of table for initial access, 
-                                         // changed by NdbIndexOperation
-  //Uint32	    theSchemaVersion;	 // The schema version on the table.  
   class NdbTableImpl* m_currentTable;      // The current table
   class NdbTableImpl* m_accessTable;
 
   // Set to TRUE when a tuple key attribute has been defined. 
-  // A tuple key is allowed to consist of 64 attributes.
-  Uint32	    theTupleKeyDefined[MAXNROFTUPLEKEY][3];
+  Uint32	    theTupleKeyDefined[NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY][3];
 
-  Uint32	    theTotalNrOfKeyWordInSignal;     // The total number of	
+  Uint32	    theTotalNrOfKeyWordInSignal;     // The total number of
   						     // keyword in signal.
 
   Uint32	    theTupKeyLen;	   // Length of the tuple key in words
@@ -1094,16 +1118,6 @@ NdbOperation::setStartIndicator()
   theStartIndicator = 1;
 }
 
-#if 0
-inline
-void
-NdbOperation::setCommitIndicator(CommitType aTypeOfCommit)
-{
-  theCommitIndicator = 1;
-  theCommitType = (Uint8)aTypeOfCommit;
-}
-#endif
-
 inline
 int
 NdbOperation::getNdbErrorLine()
@@ -1145,7 +1159,7 @@ Parameters:     aStatus:  The status.
 Remark:         Sets Operation status. 
 ******************************************************************************/
 inline
-OperationStatus			
+NdbOperation::OperationStatus			
 NdbOperation::Status()
 {
   return theStatus;
@@ -1178,18 +1192,6 @@ NdbOperation::NdbCon(NdbConnection* aNdbCon)
   theNdbCon = aNdbCon;
 }
 
-/******************************************************************************
-OperationType		RequestType();
-
-Remark:        Return the request typ of the operation..
-******************************************************************************/
-inline
-OperationType
-NdbOperation::RequestType()
-{
-  return theOperationType;
-}
-
 inline
 int
 NdbOperation::equal(const char* anAttrName, Int32 aPar)
diff --git a/ndb/include/ndbapi/NdbRecAttr.hpp b/ndb/include/ndbapi/NdbRecAttr.hpp
index 7eeff88671d..0960c035abe 100644
--- a/ndb/include/ndbapi/NdbRecAttr.hpp
+++ b/ndb/include/ndbapi/NdbRecAttr.hpp
@@ -18,7 +18,6 @@
 #define NdbRecAttr_H
 
 #include <NdbDictionary.hpp>
-#include "AttrType.hpp"
 
 class NdbOperation;
 class AttrInfo;
@@ -85,13 +84,11 @@ public:
    * @{
    */
   const NdbDictionary::Column * getColumn() const;
-  
+
   /**
-   * Get attribute type.
-   * 
-   * @return Type of attribute: { Signed, UnSigned, Float, String }
+   * Get type of column
+   * @return Data type of the column
    */
-  AttrType attrType() const ;           
   NdbDictionary::Column::Type getType() const;
   
   /**
@@ -317,33 +314,6 @@ NdbRecAttr::attrSize() const {
 }
 
 inline
-AttrType
-NdbRecAttr::attrType() const {
-  switch(getType()){
-  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::Decimal:
-  case NdbDictionary::Column::Double:
-    return Float;
-  case NdbDictionary::Column::Char:
-  case NdbDictionary::Column::Varchar:
-  case NdbDictionary::Column::Binary:
-  case NdbDictionary::Column::Varbinary:
-    return String;
-  case NdbDictionary::Column::Datetime:
-  case NdbDictionary::Column::Timespec:
-  case NdbDictionary::Column::Undefined:
-  default:
-    return NoAttrTypeDef;
-  }
-}
-
-inline
 Uint32
 NdbRecAttr::arraySize() const 
 {
diff --git a/ndb/include/ndbapi/NdbSchemaCon.hpp b/ndb/include/ndbapi/NdbSchemaCon.hpp
index 9d6b49df8f9..313daf0094b 100644
--- a/ndb/include/ndbapi/NdbSchemaCon.hpp
+++ b/ndb/include/ndbapi/NdbSchemaCon.hpp
@@ -16,15 +16,16 @@
 
 #ifndef NdbSchemaCon_H
 #define NdbSchemaCon_H
+
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
 
 #include <ndb_types.h>
-#include "AttrType.hpp"
 #include "NdbError.hpp"
+#include <NdbSchemaOp.hpp>
 
 class NdbSchemaOp;
-class NdbApiSignal;
 class Ndb;
+class NdbApiSignal;
 
 /**
  * @class NdbSchemaCon
@@ -44,6 +45,7 @@ class Ndb;
  * into the database. 
  *
  * @note   Currently only one table can be added per transaction.
+ * @note Depricated, use NdbDictionary
  */
 class NdbSchemaCon
 {
@@ -51,6 +53,18 @@ friend class Ndb;
 friend class NdbSchemaOp;
   
 public:
+
+  static 
+  NdbSchemaCon* startSchemaTrans(Ndb* pNdb){
+    return  new NdbSchemaCon(pNdb);
+  }
+  
+  static 
+  void closeSchemaTrans(NdbSchemaCon* pSchCon){
+    delete pSchCon;
+  }
+  
+
   /**
    * Execute a schema transaction.
    * 
@@ -75,6 +89,7 @@ public:
   const NdbError & getNdbError() const;
 
 private:
+
 /******************************************************************************
  *	These are the create and delete methods of this class.
  *****************************************************************************/
@@ -85,8 +100,6 @@ private:
 /******************************************************************************
  *	These are the private methods of this class.
  *****************************************************************************/
-  void init();             // Initialise connection object for new
-				   // transaction.
 
   void release();	         // Release all schemaop in schemaCon
 
@@ -105,7 +118,6 @@ private:
   int receiveDROP_INDX_REF(NdbApiSignal*);
 
 
-
 /*****************************************************************************
  *	These are the private variables of this class.
  *****************************************************************************/
@@ -126,6 +138,9 @@ NdbSchemaCon::checkMagicNumber()
     return -1;
   return 0;
 }//NdbSchemaCon::checkMagicNumber()
+
+
+
 #endif
 #endif
 
diff --git a/ndb/include/ndbapi/NdbSchemaOp.hpp b/ndb/include/ndbapi/NdbSchemaOp.hpp
index c3a3827a6b4..43f76c8c253 100644
--- a/ndb/include/ndbapi/NdbSchemaOp.hpp
+++ b/ndb/include/ndbapi/NdbSchemaOp.hpp
@@ -16,14 +16,126 @@
 
 #ifndef NdbSchemaOp_H
 #define NdbSchemaOp_H
+
+#include <NdbDictionary.hpp>
+
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
 
-#include "NdbDictionary.hpp"
-#include "AttrType.hpp"
-#include "NdbSchemaCon.hpp"
+  /**
+   * Type of attribute
+   *
+   * NOTE! AttrType is deprecated, use NdbDictionary::Column::Type instead!
+   */
+  enum AttrType { 
+    Signed,           ///< Attributes of this type can be read with:
+                      ///< NdbRecAttr::int64_value, 
+                      ///< NdbRecAttr::int32_value,
+                      ///< NdbRecAttr::short_value, 
+                      ///< NdbRecAttr::char_value
+    UnSigned,         ///< Attributes of this type can be read with:
+                      ///< NdbRecAttr::u_64_value, 
+                      ///< NdbRecAttr::u_32_value,
+                      ///< NdbRecAttr::u_short_value, 
+                      ///< NdbRecAttr::u_char_value
+    Float,            ///< Attributes of this type can be read with:
+                      ///< NdbRecAttr::float_value and 
+                      ///< NdbRecAttr::double_value
+    String,           ///< Attributes of this type can be read with:
+                      ///< NdbRecAttr::aRef, 
+                      ///< NdbRecAttr::getAttributeObject
+    NoAttrTypeDef     ///< Used for debugging only
+  };
+
+
+  /**
+   * @deprecated
+   */
+  enum NullAttributeType { 
+    NoNullTypeDefined = -1,
+    NotNullAttribute, 
+    NullAttribute,
+    AttributeDefined 
+  };
+  /**
+   * Indicates whether the attribute is part of a primary key or not
+   */
+  enum KeyType { 
+    Undefined = -1,               ///< Used for debugging only
+    NoKey,                        ///< Attribute is not part of primary key 
+                                  ///< or tuple identity
+    TupleKey,                     ///< Attribute is part of primary key
+    TupleId                       ///< Attribute is part of tuple identity 
+                                  ///< (This type of attribute is created 
+                                  ///< internally, and should not be 
+                                  ///< manually created.)
+  };
+  /**
+   * Indicate whether the attribute should be stored on disk or not
+   */
+  enum StorageMode { 
+    MMBased = 0,                  ///< Main memory 
+    DiskBased = 1,                ///< Disk (Not yet supported.)
+    NoStorageTypeDef              ///< Used for debugging only
+  };
+  
+  /**
+   * Where attribute is stored.
+   *
+   * This is used to indicate whether a primary key
+   * should only be stored in the index storage and not in the data storage
+   * or if it should be stored in both places.
+   * The first alternative makes the attribute take less space, 
+   * but makes it impossible to scan using attribute.
+   *
+   * @note  Use NormalStorageAttribute for most cases.
+   *        (IndexStorageAttribute should only be used on primary key 
+   *        attributes and only if you do not want to scan using the attribute.)
+   */
+  enum StorageAttributeType { 
+    NoStorageAttributeTypeDefined = -1,  ///< <i>Missing explanation</i>
+    IndexStorageAttribute,               ///< Attribute is only stored in 
+                                         ///< index storage (ACC)
+    NormalStorageAttribute               ///< Attribute values are stored 
+                                         ///< both in the index (ACC) and 
+                                         ///< in the data storage (TUP)
+  };
+  
+  
+  /**
+   *  Type of fragmentation used for a table
+   */
+  enum FragmentType { 
+    Default = 0,                  ///<  (All is default!)
+    Single = 1,                   ///< Only one fragment
+    All = 2,                      ///< Default value.  One fragment per node group
+    DistributionGroup = 3,        ///< Distribution Group used for fragmentation.
+                                  ///< One fragment per node group
+    DistributionKey = 4,          ///< Distribution Key used for fragmentation.
+                                  ///< One fragment per node group.
+    AllLarge = 5,                 ///< Sixten fragments per node group.
+    DGroupLarge = 6,              ///< Distribution Group used for fragmentation.
+                                  ///< Sixten fragments per node group
+    DKeyLarge = 7                 ///< Distribution Key used for fragmentation.
+                                  ///< Sixten fragments per node group
+  };
+  
+  /**
+   *  Type of table or index.
+   */
+  enum TableType {
+    UndefTableType = 0,
+    SystemTable = 1,              ///< Internal.Table cannot be updated by user
+    UserTable = 2,                  ///< Normal application table
+    UniqueHashIndex = 3,          ///< Unique un-ordered hash index
+    HashIndex = 4,                ///< Non-unique un-ordered hash index
+    UniqueOrderedIndex = 5,       ///< Unique ordered index
+    OrderedIndex = 6              ///< Non-unique ordered index
+  };
+
 
-class NdbApiSignal;
+class NdbSchemaCon;
 class Ndb;
+  
 
 /** 
  * @class NdbSchemaOp
@@ -41,8 +153,10 @@ class NdbSchemaOp
 {
   friend class Ndb;
   friend class NdbSchemaCon;
-  
+
 public:
+
+  
   /**
    * Create a new table in the database.
    * 
@@ -184,7 +298,6 @@ public:
 				int aMemoryType = 1,
 				bool aStoredTable = true);
 
-#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   /** 
    * This is the old function declaration, don't use.
    *
@@ -211,7 +324,6 @@ public:
                        aMemoryType, 
                        (aStoredTable == 1 ? true : false));
   }
-#endif
 
   /**
    * Add a new attribute to a database table.
@@ -367,7 +479,6 @@ public:
                       bool aAutoIncrement = false,
                       const char* aDefaultValue = 0);
 
-#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   /**
    * @deprecated do not use!
    */
@@ -394,19 +505,8 @@ public:
 			   aDistributionGroup,
 			   aDistributionGroupNoOfBits);
   }
-#endif
-  
-  /**
-   * Get the last error which occurred during the transaction.
-   *
-   * If an error occured (NdbSchemaCon::execute returned -1 or 
-   * NdbSchemaCon::getNdbSchemaOp returned NULL), then this method
-   * retrieves the error object containing information about 
-   * the error.
-   *
-   * @return Error object containing information about last error.
-   */				
-  const NdbError & getNdbError() const; 
+
+  const NdbError & getNdbError() const;
 
 protected:
 
@@ -440,17 +540,48 @@ protected:
   Ndb*			theNdb;		// Point back to the Ndb object.      
   NdbSchemaCon* 	theSchemaCon;	// Point back to the connection object.
   
+
   class NdbDictionary::Table * m_currentTable;
 };
 
-inline
-const NdbError &
-NdbSchemaOp::getNdbError() const
-{
-  return theSchemaCon->getNdbError();
-}
 
+/**
+ * Get old attribute type from new type
+ * 
+ * NOTE! attrType is deprecated, use getType instead!
+ *
+ * @return Type of attribute: { Signed, UnSigned, Float,a String }
+ */
+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::Decimal:
+  case NdbDictionary::Column::Double:
+    return Float;
+  case NdbDictionary::Column::Char:
+  case NdbDictionary::Column::Varchar:
+  case NdbDictionary::Column::Binary:
+  case NdbDictionary::Column::Varbinary:
+    return String;
+  case NdbDictionary::Column::Datetime:
+  case NdbDictionary::Column::Timespec:
+  case NdbDictionary::Column::Undefined:
+  default:
+    return NoAttrTypeDef;
+  }
+}
 #endif
+
 #endif
 
 
diff --git a/ndb/include/ndbapi/ndbapi_limits.h b/ndb/include/ndbapi/ndbapi_limits.h
index 428c5407cbd..1cf2d9b342d 100644
--- a/ndb/include/ndbapi/ndbapi_limits.h
+++ b/ndb/include/ndbapi/ndbapi_limits.h
@@ -18,29 +18,16 @@
 #define NDBAPI_LIMITS_H
 
 #define NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY 32
-#define NDB_MAX_TABLES 1600
+#define NDB_MAX_ATTRIBUTES_IN_INDEX NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY
 #define NDB_MAX_DATABASE_NAME_SIZE 128
 #define NDB_MAX_SCHEMA_NAME_SIZE 128
 #define NDB_MAX_TAB_NAME_SIZE 128
-#define NDB_MAX_ATTR_NAME_SIZE 32
-#define NDB_MAX_ATTR_DEFAULT_VALUE_SIZE 128
 #define NDB_MAX_ATTRIBUTES_IN_TABLE 91
-#define NDB_MAX_ATTRIBUTES_IN_INDEX NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY
+
 #define NDB_MAX_TUPLE_SIZE_IN_WORDS 1023
-#define NDB_MAX_FIXED_KEY_LENGTH_IN_WORDS 8
 #define NDB_MAX_KEYSIZE_IN_WORDS 1023
 #define NDB_MAX_KEY_SIZE NDB_MAX_KEYSIZE_IN_WORDS*sizeof(Uint32)
-#define NDB_MAX_TUPLE_SIZE 8191
-#define NDB_MAX_TRANSACTIONS 1024
-#define NDB_MAX_PARALLEL_SCANS 12
+#define NDB_MAX_TUPLE_SIZE NDB_MAX_TUPLE_SIZE_IN_WORDS*sizeof(uint32)
 #define NDB_MAX_ACTIVE_EVENTS 100
 
-#ifndef MIN
-#define MIN(x,y) (((x)<(y))?(x):(y))
-#endif
- 
-#ifndef MAX
-#define MAX(x,y) (((x)>(y))?(x):(y))
-#endif
-
 #endif
diff --git a/ndb/src/Makefile b/ndb/src/Makefile
index 4f71eb46056..72333aae890 100644
--- a/ndb/src/Makefile
+++ b/ndb/src/Makefile
@@ -10,7 +10,6 @@ DIRS := \
 	rep \
         mgmclient \
         cw \
-        newtonapi \
         ndbbaseclient
 ifneq ($(NDB_ODBC),N)
         DIRS += ndbclient
diff --git a/ndb/src/kernel/blocks/backup/restore/Restore.hpp b/ndb/src/kernel/blocks/backup/restore/Restore.hpp
index 0c075e18933..cf5ad56e1da 100644
--- a/ndb/src/kernel/blocks/backup/restore/Restore.hpp
+++ b/ndb/src/kernel/blocks/backup/restore/Restore.hpp
@@ -20,9 +20,7 @@
 #include <ndb_global.h>
 #include <BackupFormat.hpp>
 #include <NdbApi.hpp>
-#include <AttrType.hpp>
-
-#include <NdbOut.hpp>
+#include <NdbSchemaCon.hpp>
 #include "myVector.hpp"
 
 #include <ndb_version.h>
diff --git a/ndb/src/kernel/blocks/backup/restore/main.cpp b/ndb/src/kernel/blocks/backup/restore/main.cpp
index 4c15785d5c2..ceb0c282e1d 100644
--- a/ndb/src/kernel/blocks/backup/restore/main.cpp
+++ b/ndb/src/kernel/blocks/backup/restore/main.cpp
@@ -23,6 +23,9 @@
 #ifdef USE_MYSQL
 #include <mysql.h>
 #endif
+
+#include <NdbOut.hpp>
+
 NdbOut& operator<<(NdbOut& ndbout, const TupleS& tuple);
 NdbOut& operator<<(NdbOut& ndbout, const LogEntry& logEntry);
 NdbOut& operator<<(NdbOut& ndbout, const RestoreMetaData &);
@@ -606,7 +609,7 @@ operator<<(NdbOut& ndbout, const AttributeS& attr){
 	break;
       } // switch size
       break;
-    case (String):
+    case String:
       if (desc.size == 8){ 
 	NdbDictionary::Column::Type type = desc.m_table->m_dictTable->getColumn(desc.attrId)->getType();
 	if(type == NdbDictionary::Column::Varchar){
@@ -622,7 +625,7 @@ operator<<(NdbOut& ndbout, const AttributeS& attr){
       }
       j = desc.arraySize;
       break;
-    case (Float):
+    case Float:
       // Not yet supported to print float
       ndbout << "float";
       break;
diff --git a/ndb/src/mgmsrv/MgmtSrvr.cpp b/ndb/src/mgmsrv/MgmtSrvr.cpp
index 7c2d94c6b7f..34ef9dbb08e 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.cpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.cpp
@@ -21,7 +21,6 @@
 #include "MgmtErrorReporter.hpp"
 
 #include <NdbOut.hpp>
-#include <AttrType.hpp>
 #include <NdbApiSignal.hpp>
 #include <kernel_types.h>
 #include <RefConvert.hpp>
diff --git a/ndb/src/ndbapi/ClusterMgr.cpp b/ndb/src/ndbapi/ClusterMgr.cpp
index 1b536b6d741..57967e5534f 100644
--- a/ndb/src/ndbapi/ClusterMgr.cpp
+++ b/ndb/src/ndbapi/ClusterMgr.cpp
@@ -21,7 +21,6 @@
 #include "TransporterFacade.hpp"
 #include "ClusterMgr.hpp"
 #include <IPCConfig.hpp>
-#include "AttrType.hpp"
 #include "NdbApiSignal.hpp"
 #include "API.hpp"
 #include <NdbSleep.h>
diff --git a/ndb/src/ndbapi/Ndb.cpp b/ndb/src/ndbapi/Ndb.cpp
index 448a29ca485..0304db67a39 100644
--- a/ndb/src/ndbapi/Ndb.cpp
+++ b/ndb/src/ndbapi/Ndb.cpp
@@ -26,8 +26,6 @@ Name:          Ndb.cpp
 
 #include "NdbApiSignal.hpp"
 #include "NdbImpl.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp" 
 #include <NdbOperation.hpp>
 #include <NdbConnection.hpp>
 #include <NdbEventOperation.hpp>
@@ -155,7 +153,7 @@ Ndb::NDB_connect(Uint32 tNode)
 // Set connection pointer as NdbConnection object
 //************************************************
   tSignal->setData(theMyRef, 2);	// Set my block reference
-  tNdbCon->Status(Connecting);		// Set status to connecting
+  tNdbCon->Status(NdbConnection::Connecting); // Set status to connecting
   Uint32 nodeSequence;
   { // send and receive signal
     tp->lock_mutex();
@@ -178,7 +176,7 @@ Ndb::NDB_connect(Uint32 tNode)
     }//if
   }
   
-  if ((tReturnCode == 0) && (tNdbCon->Status() == Connected)) {
+  if ((tReturnCode == 0) && (tNdbCon->Status() == NdbConnection::Connected)) {
     //************************************************
     // Send and receive was successful
     //************************************************
@@ -434,7 +432,7 @@ Ndb::startTransactionLocal(Uint32 aPriority, Uint32 nodeId)
     theFirstTransId = tFirstTransId + 1;
   }//if
 #ifdef VM_TRACE
-  if (tConnection->theListState != NotInList) {
+  if (tConnection->theListState != NdbConnection::NotInList) {
     printState("startTransactionLocal %x", tConnection);
     abort();
   }
@@ -589,7 +587,7 @@ Ndb::NdbTamper(TamperType aAction, int aNode)
   tSignal.setData (tAction, 1);
   tSignal.setData(tNdbConn->ptr2int(),2);
   tSignal.setData(theMyRef,3);		// Set return block reference
-  tNdbConn->Status(Connecting);		// Set status to connecting	
+  tNdbConn->Status(NdbConnection::Connecting); // Set status to connecting
   TransporterFacade *tp = TransporterFacade::instance();
   if (tAction == 3) {
     tp->lock_mutex();
@@ -622,7 +620,7 @@ Ndb::NdbTamper(TamperType aAction, int aNode)
       }//if
       ret_code = sendRecSignal(tNode, WAIT_NDB_TAMPER, &tSignal, 0);
       if (ret_code == 0) {  
-        if (tNdbConn->Status() != Connected) {
+        if (tNdbConn->Status() != NdbConnection::Connected) {
           theRestartGCI = 0;
         }//if
         releaseNdbCon(tNdbConn);
@@ -637,6 +635,7 @@ Ndb::NdbTamper(TamperType aAction, int aNode)
   return 0;
 #endif
 }
+#if 0
 /****************************************************************************
 NdbSchemaCon* startSchemaTransaction();
 
@@ -678,7 +677,7 @@ Ndb::closeSchemaTransaction(NdbSchemaCon* aSchemaCon)
   theSchemaConToNdbList = NULL;
   return;
 }//Ndb::closeSchemaTransaction()
-
+#endif
 
 /*****************************************************************************
 void RestartGCI(int aRestartGCI);
diff --git a/ndb/src/ndbapi/NdbApiSignal.cpp b/ndb/src/ndbapi/NdbApiSignal.cpp
index a9cd5b1d53a..a44937cd398 100644
--- a/ndb/src/ndbapi/NdbApiSignal.cpp
+++ b/ndb/src/ndbapi/NdbApiSignal.cpp
@@ -29,7 +29,6 @@ Adjust:  971114  UABMNST   First version.
 ******************************************************************************/
 #include "API.hpp"
 #include "NdbApiSignal.hpp"
-#include <AttrType.hpp>
 
 /**
  * The following include includes
diff --git a/ndb/src/ndbapi/NdbApiSignal.hpp b/ndb/src/ndbapi/NdbApiSignal.hpp
index 76cefe0e882..9d5bc0847be 100644
--- a/ndb/src/ndbapi/NdbApiSignal.hpp
+++ b/ndb/src/ndbapi/NdbApiSignal.hpp
@@ -31,7 +31,6 @@
 #define NdbApiSignal_H
 
 #include <kernel_types.h>
-#include "AttrType.hpp" 
 #include "TransporterFacade.hpp"
 #include <TransporterDefinitions.hpp>
 #include "Ndb.hpp"
diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index 4ec098c3c60..fbfd0e99238 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -1706,7 +1706,7 @@ NdbConnection::getTransactionId()
   return theTransactionId;
 }//NdbConnection::getTransactionId()
 
-CommitStatusType
+NdbConnection::CommitStatusType
 NdbConnection::commitStatus()
 {
   return theCommitStatus;
diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
index 02e3ee23f9c..1a7147c5b21 100644
--- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp
+++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
@@ -17,7 +17,6 @@
 #include "NdbDictionaryImpl.hpp"
 #include "API.hpp"
 #include <NdbOut.hpp>
-#include <AttrType.hpp>
 #include "NdbApiSignal.hpp"
 #include "TransporterFacade.hpp"
 #include <signaldata/GetTabInfo.hpp>
@@ -1257,7 +1256,7 @@ NdbDictInterface::createOrAlterTable(Ndb & ndb,
 				     NdbTableImpl & impl,
 				     bool alter)
 {
-  if((unsigned)impl.getNoOfPrimaryKeys() > MAXNROFTUPLEKEY){
+  if((unsigned)impl.getNoOfPrimaryKeys() > NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY){
     m_error.code = 4317;
     return -1;
   }
diff --git a/ndb/src/ndbapi/NdbEventOperationImpl.cpp b/ndb/src/ndbapi/NdbEventOperationImpl.cpp
index acc726e28c5..7b4afc72ef7 100644
--- a/ndb/src/ndbapi/NdbEventOperationImpl.cpp
+++ b/ndb/src/ndbapi/NdbEventOperationImpl.cpp
@@ -21,7 +21,6 @@
 #include "NdbDictionaryImpl.hpp"
 #include "API.hpp"
 #include <NdbOut.hpp>
-#include <AttrType.hpp>
 #include "NdbApiSignal.hpp"
 #include "TransporterFacade.hpp"
 #include <signaldata/CreateEvnt.hpp>
@@ -489,52 +488,7 @@ NdbEventOperationImpl::getEventType()
   }
 }
 
-void
-NdbEventOperationImpl::printRecAttr(NdbRecAttr *p)
-{
-  int size  = p->attrSize();
-  int aSize = p->arraySize();
 
-  switch(p->attrType()){
-  case UnSigned:
-    switch(size) {
-    case 8: ndbout << p->u_64_value(); break;
-    case 4: ndbout << p->u_32_value(); break;
-    case 2: ndbout << p->u_short_value(); break;
-    case 1: ndbout << (unsigned) p->u_char_value(); break;
-    default: ndbout << "Unknown size" << endl;
-    }
-    break;
-	  
-  case Signed:
-    switch(size) {
-    case 8: ndbout << p->int64_value(); break;
-    case 4: ndbout << p->int32_value(); break;
-    case 2: ndbout << p->short_value(); break;
-    case 1: ndbout << (int) p->char_value(); break;
-    default: ndbout << "Unknown size" << endl;
-    }
-    break;
-    
-  case String:
-    {
-      char* buf = new char[aSize+1];
-      memcpy(buf, p->aRef(), aSize);
-      buf[aSize] = 0;
-      ndbout << buf;
-      delete [] buf;
-    }
-    break;
-    
-  case Float:
-    ndbout << p->float_value();
-    break;
-    
-  default:
-    ndbout << "Unknown";
-    break;
-  }
-}
 
 void
 NdbEventOperationImpl::print()
@@ -1294,3 +1248,60 @@ NdbGlobalEventBuffer::real_wait(NdbGlobalEventBufferHandle *h,
     n += hasData(h->m_bufferIds[i]);
   return n;
 }
+
+/**
+ * TODO Change this function to use the real datatypes 
+ *  from NdbDictionary  alternatively make a 
+ * "printer" in NdbRecAttr that can be used from all programs
+ */
+
+// and remove this include
+#include "NdbSchemaOp.hpp"
+void
+NdbEventOperationImpl::printRecAttr(NdbRecAttr *p)
+{
+  int size  = p->attrSize();
+  int aSize = p->arraySize();
+
+
+  switch(convertColumnTypeToAttrType(p->getType())){
+  case UnSigned:
+    switch(size) {
+    case 8: ndbout << p->u_64_value(); break;
+    case 4: ndbout << p->u_32_value(); break;
+    case 2: ndbout << p->u_short_value(); break;
+    case 1: ndbout << (unsigned) p->u_char_value(); break;
+    default: ndbout << "Unknown size" << endl;
+    }
+    break;
+	  
+  case Signed:
+    switch(size) {
+    case 8: ndbout << p->int64_value(); break;
+    case 4: ndbout << p->int32_value(); break;
+    case 2: ndbout << p->short_value(); break;
+    case 1: ndbout << (int) p->char_value(); break;
+    default: ndbout << "Unknown size" << endl;
+    }
+    break;
+    
+  case String:
+    {
+      char* buf = new char[aSize+1];
+      memcpy(buf, p->aRef(), aSize);
+      buf[aSize] = 0;
+      ndbout << buf;
+      delete [] buf;
+    }
+    break;
+    
+  case Float:
+    ndbout << p->float_value();
+    break;
+    
+  default:
+    ndbout << "Unknown";
+    break;
+  }
+
+}
diff --git a/ndb/src/ndbapi/NdbIndexOperation.cpp b/ndb/src/ndbapi/NdbIndexOperation.cpp
index ee5491d72a8..02d94f39f2d 100644
--- a/ndb/src/ndbapi/NdbIndexOperation.cpp
+++ b/ndb/src/ndbapi/NdbIndexOperation.cpp
@@ -87,7 +87,7 @@ NdbIndexOperation::indxInit(NdbIndexImpl * anIndex,
   m_accessTable = anIndex->m_table;
   m_theIndexLen = 0;
   m_theNoOfIndexDefined = 0;
-  for (Uint32 i=0; i<MAXNROFTUPLEKEY; i++)
+  for (Uint32 i=0; i<NDB_MAX_ATTRIBUTES_IN_INDEX; i++)
     for (int j=0; j<3; j++)
       m_theIndexDefined[i][j] = false;  
   
@@ -221,7 +221,7 @@ int NdbIndexOperation::equal_impl(const NdbColumnImpl* tAttrInfo,
 	    goto equal_error2;
 	  }//if
 	}//if
-      } while (i < MAXNROFTUPLEKEY);
+      } while (i < NDB_MAX_ATTRIBUTES_IN_INDEX);
       goto equal_error2;
     } else {
       goto equal_error1;
@@ -695,7 +695,7 @@ NdbIndexOperation::receiveTCINDXREF( NdbApiSignal* aSignal)
 
   theStatus = Finished;
   
-  theNdbCon->theReturnStatus = ReturnFailure;
+  theNdbCon->theReturnStatus = NdbConnection::ReturnFailure;
   //--------------------------------------------------------------------------//
   // If the transaction this operation belongs to consists only of simple reads
   // we set the error code on the transaction object. 
diff --git a/ndb/src/ndbapi/NdbOperation.cpp b/ndb/src/ndbapi/NdbOperation.cpp
index ccbfa767542..8bc9111d060 100644
--- a/ndb/src/ndbapi/NdbOperation.cpp
+++ b/ndb/src/ndbapi/NdbOperation.cpp
@@ -31,7 +31,7 @@
 #include "NdbApiSignal.hpp"
 #include "NdbRecAttr.hpp"
 #include "NdbUtil.hpp"
-
+#include "ndbapi_limits.h"
 #include <signaldata/TcKeyReq.hpp>
 #include "NdbDictionaryImpl.hpp"
 
@@ -163,7 +163,7 @@ NdbOperation::init(NdbTableImpl* tab, NdbConnection* myConnection){
   m_currentTable = m_accessTable = tab;
   
   theNdbCon = myConnection;
-  for (Uint32 i=0; i<MAXNROFTUPLEKEY; i++)
+  for (Uint32 i=0; i<NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY; i++)
     for (int j=0; j<3; j++)
       theTupleKeyDefined[i][j] = false;  
 
diff --git a/ndb/src/ndbapi/NdbOperationDefine.cpp b/ndb/src/ndbapi/NdbOperationDefine.cpp
index 18f8b79d12e..20134068075 100644
--- a/ndb/src/ndbapi/NdbOperationDefine.cpp
+++ b/ndb/src/ndbapi/NdbOperationDefine.cpp
@@ -31,7 +31,6 @@
 #include "NdbConnection.hpp"
 #include "Ndb.hpp"
 #include "NdbRecAttr.hpp"
-#include "AttrType.hpp"
 #include "NdbUtil.hpp"
 #include "NdbOut.hpp"
 #include "NdbImpl.hpp"
diff --git a/ndb/src/ndbapi/NdbOperationExec.cpp b/ndb/src/ndbapi/NdbOperationExec.cpp
index b2a6f99880c..d00c527550d 100644
--- a/ndb/src/ndbapi/NdbOperationExec.cpp
+++ b/ndb/src/ndbapi/NdbOperationExec.cpp
@@ -757,7 +757,7 @@ NdbOperation::receiveTCKEYREF( NdbApiSignal* aSignal)
 
   theStatus = Finished;
   
-  theNdbCon->theReturnStatus = ReturnFailure;
+  theNdbCon->theReturnStatus = NdbConnection::ReturnFailure;
   //-------------------------------------------------------------------------//
   // If the transaction this operation belongs to consists only of simple reads
   // we set the error code on the transaction object. 
diff --git a/ndb/src/ndbapi/NdbOperationInt.cpp b/ndb/src/ndbapi/NdbOperationInt.cpp
index be23a1c274c..e61fc5b05d7 100644
--- a/ndb/src/ndbapi/NdbOperationInt.cpp
+++ b/ndb/src/ndbapi/NdbOperationInt.cpp
@@ -31,7 +31,6 @@ Adjust:  991029  UABRONM   First version.
 #include "NdbConnection.hpp"
 #include "Ndb.hpp"
 #include "NdbRecAttr.hpp"
-#include "AttrType.hpp"
 #include "NdbUtil.hpp"
 #include "Interpreter.hpp"
 
@@ -69,7 +68,7 @@ NdbOperation::incCheck(const NdbColumnImpl* tNdbColumnImpl)
     }
     return tNdbColumnImpl->m_attrId;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
@@ -121,7 +120,7 @@ NdbOperation::write_attrCheck(const NdbColumnImpl* tNdbColumnImpl)
     }
     return tNdbColumnImpl->m_attrId;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
@@ -169,7 +168,7 @@ NdbOperation::read_attrCheck(const NdbColumnImpl* tNdbColumnImpl)
     }
     return tNdbColumnImpl->m_attrId;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
@@ -209,7 +208,7 @@ NdbOperation::initial_interpreterCheck()
     }
     return 0;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
@@ -235,7 +234,7 @@ NdbOperation::labelCheck()
     }
     return 0;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
@@ -255,7 +254,7 @@ NdbOperation::intermediate_interpreterCheck()
     }
     return 0;
   } else {
-    if (theNdbCon->theCommitStatus == Started)
+    if (theNdbCon->theCommitStatus == NdbConnection::Started)
       setErrorCodeAbort(4200);
   }
   return -1;
diff --git a/ndb/src/ndbapi/NdbOperationScan.cpp b/ndb/src/ndbapi/NdbOperationScan.cpp
index df4f2421ec0..0c377d3fd98 100644
--- a/ndb/src/ndbapi/NdbOperationScan.cpp
+++ b/ndb/src/ndbapi/NdbOperationScan.cpp
@@ -31,7 +31,7 @@ NdbOperation::openScanRead(Uint32 aParallelism)
 {
   aParallelism = checkParallelism(aParallelism);
 
-  if ((theNdbCon->theCommitStatus != Started) &&
+  if ((theNdbCon->theCommitStatus != NdbConnection::Started) &&
       (theStatus != Init) &&
       (aParallelism == 0)) {
     setErrorCode(4200);
@@ -48,7 +48,7 @@ NdbOperation::openScanExclusive(Uint32 aParallelism)
 {
   aParallelism = checkParallelism(aParallelism);
   
-  if ((theNdbCon->theCommitStatus != Started) &&
+  if ((theNdbCon->theCommitStatus != NdbConnection::Started) &&
       (theStatus != Init) &&
       (aParallelism == 0)) {
     setErrorCode(4200);
@@ -65,7 +65,7 @@ NdbOperation::openScanReadHoldLock(Uint32 aParallelism)
 {
   aParallelism = checkParallelism(aParallelism);
 
-  if ((theNdbCon->theCommitStatus != Started) &&
+  if ((theNdbCon->theCommitStatus != NdbConnection::Started) &&
       (theStatus != Init) &&
       (aParallelism == 0)) {
     setErrorCode(4200);
@@ -82,7 +82,7 @@ NdbOperation::openScanReadCommitted(Uint32 aParallelism)
 {
   aParallelism = checkParallelism(aParallelism);
 
-  if ((theNdbCon->theCommitStatus != Started) &&
+  if ((theNdbCon->theCommitStatus != NdbConnection::Started) &&
       (theStatus != Init) &&
       (aParallelism == 0)) {
     setErrorCode(4200);
diff --git a/ndb/src/ndbapi/NdbOperationSearch.cpp b/ndb/src/ndbapi/NdbOperationSearch.cpp
index e1d5e823077..8b9b89dcf07 100644
--- a/ndb/src/ndbapi/NdbOperationSearch.cpp
+++ b/ndb/src/ndbapi/NdbOperationSearch.cpp
@@ -35,7 +35,6 @@ Adjust:  971022  UABMNST   First version.
 #include <Ndb.hpp>
 #include "NdbImpl.hpp"
 #include <NdbOut.hpp>
-#include "AttrType.hpp"
 
 #include <AttributeHeader.hpp>
 #include <signaldata/TcKeyReq.hpp>
@@ -102,7 +101,7 @@ NdbOperation::equal_impl(const NdbColumnImpl* tAttrInfo,
 	    goto equal_error2;
 	  }//if
 	}//if
-      } while (i < MAXNROFTUPLEKEY);
+      } while (i < NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY);
       goto equal_error2;
     } else {
       goto equal_error1;
diff --git a/ndb/src/ndbapi/NdbResultSet.cpp b/ndb/src/ndbapi/NdbResultSet.cpp
index 8397d5eef91..65ed43f60d8 100644
--- a/ndb/src/ndbapi/NdbResultSet.cpp
+++ b/ndb/src/ndbapi/NdbResultSet.cpp
@@ -61,7 +61,8 @@ NdbResultSet::updateTuple(){
   }
   
   NdbScanOperation * op = (NdbScanOperation*)(m_operation);
-  return op->takeOverScanOp(UpdateRequest, op->m_transConnection);
+  return op->takeOverScanOp(NdbOperation::UpdateRequest, 
+			    op->m_transConnection);
 }
 
 NdbOperation* 
@@ -71,7 +72,8 @@ NdbResultSet::updateTuple(NdbConnection* takeOverTrans){
     return 0;
   }
   
-  return m_operation->takeOverScanOp(UpdateRequest, takeOverTrans);
+  return m_operation->takeOverScanOp(NdbOperation::UpdateRequest, 
+				     takeOverTrans);
 }
 
 int
@@ -82,7 +84,8 @@ NdbResultSet::deleteTuple(){
   }
   
   NdbScanOperation * op = (NdbScanOperation*)(m_operation);
-  void * res = op->takeOverScanOp(DeleteRequest, op->m_transConnection);
+  void * res = op->takeOverScanOp(NdbOperation::DeleteRequest, 
+				  op->m_transConnection);
   if(res == 0)
     return -1;
   return 0;
@@ -95,7 +98,8 @@ NdbResultSet::deleteTuple(NdbConnection * takeOverTrans){
     return 0;
   }
   
-  void * res = m_operation->takeOverScanOp(DeleteRequest, takeOverTrans);
+  void * res = m_operation->takeOverScanOp(NdbOperation::DeleteRequest, 
+					   takeOverTrans);
   if(res == 0)
     return -1;
   return 0;
diff --git a/ndb/src/ndbapi/NdbSchemaCon.cpp b/ndb/src/ndbapi/NdbSchemaCon.cpp
index fbf30c70d12..88e90f9957f 100644
--- a/ndb/src/ndbapi/NdbSchemaCon.cpp
+++ b/ndb/src/ndbapi/NdbSchemaCon.cpp
@@ -14,28 +14,31 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+
+
 /*********************************************************************
-Name:          NdbSchemaCon.C
+Name:          NdbSchemaCon.cpp
 Include:
 Link:
 Author:        UABMNST Mona Natterkvist UAB/B/SD
                EMIKRON Mikael Ronstrom                         
 Date:          020826
-Version:       2.0
-Description:   Interface between application and NDB
+Version:       3.0
+Description:   Old Interface between application and NDB
 Documentation:
 Adjust:  980126  UABMNST   First version.
          020826  EMIKRON   New version adapted to new DICT version
-************************************************************************************************/
+         040524  Magnus Svensson - Adapted to not be included in public NdbApi
+                                   unless the user wants to use it.
+
+  NOTE: This file is only used as a compatibility layer for old test programs,
+        New programs should use NdbDictionary.hpp
+*********************************************************************/
+
 #include "NdbSchemaCon.hpp"
 #include "NdbSchemaOp.hpp"
 #include "NdbApiSignal.hpp"
-#include "TransporterFacade.hpp"
-#include <RefConvert.hpp>
-#include <signaldata/CreateIndx.hpp>
-#include <signaldata/DropIndx.hpp>
-#include <signaldata/CreateTable.hpp>
-#include <NdbOut.hpp>
+
 
 /*********************************************************************
 NdbSchemaCon(Ndb* aNdb);
diff --git a/ndb/src/ndbapi/NdbSchemaOp.cpp b/ndb/src/ndbapi/NdbSchemaOp.cpp
index 9e495229661..aa2d0be311f 100644
--- a/ndb/src/ndbapi/NdbSchemaOp.cpp
+++ b/ndb/src/ndbapi/NdbSchemaOp.cpp
@@ -16,24 +16,31 @@
 
 
 /*****************************************************************************
-Name:          NdbSchemaOp.C
+Name:          NdbSchemaOp.cpp
 Include:
 Link:
 Author:        UABMNST Mona Natterkvist UAB/B/SD
                EMIKRON Mikael Ronstrom                         
-Date:          020826
-Version:       2.0
+Date:          040524
+Version:       3.0
 Description:   Interface between application and NDB
 Documentation: Handles createTable and createAttribute calls
 
 Adjust:  980125  UABMNST   First version.
          020826  EMIKRON   New version for new DICT
+         040524  Magnus Svensson - Adapted to not be included in public NdbApi
+                                   unless the user wants to use it.
+
+  NOTE: This file is only used as a compatibility layer for old test programs,
+        New programs should use NdbDictionary.hpp
 *****************************************************************************/
 #include <assert.h>
 #include "NdbSchemaOp.hpp"
 #include "NdbSchemaCon.hpp"
 #include "API.hpp"
 
+
+
 /*****************************************************************************
 NdbSchemaOp(Ndb* aNdb, Table* aTable);
 
@@ -203,3 +210,11 @@ NdbSchemaOp::init(NdbSchemaCon* aSchemaCon)
   theSchemaCon = aSchemaCon;
   return 0;
 }//NdbSchemaOp::init()
+
+
+const NdbError &
+NdbSchemaOp::getNdbError() const
+{
+   return theSchemaCon->getNdbError();
+}
+
diff --git a/ndb/src/ndbapi/NdbUtil.hpp b/ndb/src/ndbapi/NdbUtil.hpp
index 6a82af85987..80fc15ddd8c 100644
--- a/ndb/src/ndbapi/NdbUtil.hpp
+++ b/ndb/src/ndbapi/NdbUtil.hpp
@@ -30,7 +30,6 @@ Comment:
 #define NdbUtil_H
 
 #include <ndb_global.h>
-#include "AttrType.hpp"
 
 class NdbApiSignal;
 class NdbOperation;
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index 696dfe68e40..2d722e12129 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -16,10 +16,9 @@
 
 
 #include "NdbApiSignal.hpp"
-#include "AttrType.hpp"
 #include "NdbImpl.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp" 
+//#include "NdbSchemaOp.hpp"
+//#include "NdbSchemaCon.hpp" 
 #include "NdbOperation.hpp"
 #include "NdbIndexOperation.hpp"
 #include "NdbScanReceiver.hpp"
@@ -42,13 +41,12 @@
 
 
 /******************************************************************************
- * int init( int aNrOfCon, int aNrOfOp );
+ * int init( int aMaxNoOfTransactions );
  *
  * Return Value:   Return 0 : init was successful.
  *                Return -1: In all other case.  
- * Parameters:	aNrOfCon : Number of connections offered to the application.
- *		aNrOfOp : Number of operations offered to the application.
- * Remark:		Create pointers and idle list Synchronous.
+ * Parameters:	aMaxNoOfTransactions : Max number of simultaneous transations
+ * Remark:	Create pointers and idle list Synchronous.
  ****************************************************************************/ 
 int
 Ndb::init(int aMaxNoOfTransactions)
@@ -254,8 +252,9 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
   for (int i = tNoSentTransactions - 1; i >= 0; i--) {
     NdbConnection* localCon = theSentTransactionsArray[i];
     if (localCon->getConnectedNodeId() == aNodeId ) {
-      const SendStatusType sendStatus = localCon->theSendStatus;
-      if (sendStatus == sendTC_OP || sendStatus == sendTC_COMMIT) {
+      const NdbConnection::SendStatusType sendStatus = localCon->theSendStatus;
+      if (sendStatus == NdbConnection::sendTC_OP || 
+	  sendStatus == NdbConnection::sendTC_COMMIT) {
         /*
         A transaction was interrupted in the prepare phase by a node
         failure. Since the transaction was not found in the phase
@@ -263,13 +262,13 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
         we report a normal node failure abort.
         */
 	localCon->setOperationErrorCodeAbort(4010);
-        localCon->theCompletionStatus = CompletedFailure;
-      } else if (sendStatus == sendTC_ROLLBACK) {
+        localCon->theCompletionStatus = NdbConnection::CompletedFailure;
+      } else if (sendStatus == NdbConnection::sendTC_ROLLBACK) {
         /*
         We aimed for abort and abort we got even if it was by a node
         failure. We will thus report it as a success.
         */
-        localCon->theCompletionStatus = CompletedSuccess;
+        localCon->theCompletionStatus = NdbConnection::CompletedSuccess;
       } else {
 #ifdef VM_TRACE
         printState("abortTransactionsAfterNodeFailure %x", this);
@@ -281,7 +280,7 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
       intact since the node was failing and they were aborted. Thus we
       set commit state to Aborted and set state to release on close.
       */
-      localCon->theCommitStatus = Aborted;
+      localCon->theCommitStatus = NdbConnection::Aborted;
       localCon->theReleaseOnClose = true;
       completedTransaction(localCon);
     }//if
@@ -328,7 +327,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 
       tCon = void2con(tFirstDataPtr);
       if ((tCon->checkMagicNumber() == 0) &&
-          (tCon->theSendStatus == sendTC_OP)) {
+          (tCon->theSendStatus == NdbConnection::sendTC_OP)) {
         tReturnCode = tCon->receiveTCKEYCONF(keyConf, aSignal->getLength());
         if (tReturnCode != -1) {
           completedTransaction(tCon);
@@ -356,7 +355,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       if (tOp->checkMagicNumber() == 0) {
 	tCon = tOp->theNdbCon;
 	if (tCon != NULL) {
-	  if (tCon->theSendStatus == sendTC_OP) {
+	  if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
 	    tReturnCode = tOp->receiveREAD_CONF(tDataPtr, 
 						aSignal->getLength());
 	    if (tReturnCode != -1) {
@@ -381,7 +380,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 	if (tOp->checkMagicNumber() == 0) {
 	  tCon = tOp->theNdbCon;
 	  if (tCon != NULL) {
-	    if (tCon->theSendStatus == sendTC_OP) {
+	    if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
 	      tReturnCode = tOp->receiveTRANSID_AI(tDataPtr, 
 						   aSignal->getLength());
 	      if (tReturnCode != -1) {
@@ -398,7 +397,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 	if (tOp->checkMagicNumber() == 0) {
 	  tCon = tOp->theNdbCon;
 	  if (tCon != NULL) {
-	    if (tCon->theSendStatus == sendTC_OP) {
+	    if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
 	      tReturnCode = tOp->receiveTRANSID_AI(tDataPtr, 
 						   aSignal->getLength());
 	      if (tReturnCode != -1) {
@@ -442,8 +441,8 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       if (tOp->checkMagicNumber() == 0) {
 	tCon = tOp->theNdbCon;
 	if (tCon != NULL) {
-	  if ((tCon->theSendStatus == sendTC_OP) ||
-	      (tCon->theSendStatus == sendTC_COMMIT)) {
+	  if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
+	      (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
 	    tReturnCode = tCon->receiveTCKEY_FAILCONF(failConf);
 	    if (tReturnCode != -1) {
 	      completedTransaction(tCon);
@@ -469,8 +468,8 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       if (tOp->checkMagicNumber() == 0) {
         tCon = tOp->theNdbCon;
         if (tCon != NULL) {
-          if ((tCon->theSendStatus == sendTC_OP) ||
-              (tCon->theSendStatus == sendTC_ROLLBACK)) {
+          if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
+              (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
             tReturnCode = tCon->receiveTCKEY_FAILREF(aSignal);
             if (tReturnCode != -1) {
               completedTransaction(tCon);
@@ -490,7 +489,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       if (tOp->checkMagicNumber() == 0) {
 	tCon = tOp->theNdbCon;
 	if (tCon != NULL) {
-	  if (tCon->theSendStatus == sendTC_OP) {
+	  if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
 	    tReturnCode = tOp->receiveTCKEYREF(aSignal);
 	    if (tReturnCode != -1) {
 	      completedTransaction(tCon);
@@ -512,7 +511,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       
       tCon = void2con(tFirstDataPtr);
       if ((tCon->checkMagicNumber() == 0) &&
-	  (tCon->theSendStatus == sendTC_COMMIT)) {
+	  (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
 	tReturnCode = tCon->receiveTC_COMMITCONF(commitConf);
 	if (tReturnCode != -1) {
 	  completedTransaction(tCon);
@@ -537,7 +536,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 
       tCon = void2con(tFirstDataPtr);
       if ((tCon->checkMagicNumber() == 0) &&
-	  (tCon->theSendStatus == sendTC_COMMIT)) {
+	  (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
 	tReturnCode = tCon->receiveTC_COMMITREF(aSignal);
 	if (tReturnCode != -1) {
 	  completedTransaction(tCon);
@@ -553,7 +552,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 
       tCon = void2con(tFirstDataPtr);
       if ((tCon->checkMagicNumber() == 0) &&
-	  (tCon->theSendStatus == sendTC_ROLLBACK)) {
+	  (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
 	tReturnCode = tCon->receiveTCROLLBACKCONF(aSignal);
 	if (tReturnCode != -1) {
 	  completedTransaction(tCon);
@@ -568,7 +567,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 
       tCon = void2con(tFirstDataPtr);
       if ((tCon->checkMagicNumber() == 0) &&
-	  (tCon->theSendStatus == sendTC_ROLLBACK)) {
+	  (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
 	tReturnCode = tCon->receiveTCROLLBACKREF(aSignal);
 	if (tReturnCode != -1) {
 	  completedTransaction(tCon);
@@ -789,7 +788,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
     const BlockReference aTCRef = aSignal->theSendersBlockRef;
     tCon = void2con(tFirstDataPtr);
     if ((tCon->checkMagicNumber() == 0) &&
-	(tCon->theSendStatus == sendTC_OP)) {
+	(tCon->theSendStatus == NdbConnection::sendTC_OP)) {
       tReturnCode = tCon->receiveTCINDXCONF(indxConf, aSignal->getLength());
       if (tReturnCode != -1) { 
 	completedTransaction(tCon);
@@ -812,7 +811,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
     if (tIndexOp->checkMagicNumber() == 0) {
       tCon = tIndexOp->theNdbCon;
       if (tCon != NULL) {
-	if (tCon->theSendStatus == sendTC_OP) {
+	if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
 	  tReturnCode = tIndexOp->receiveTCINDXREF(aSignal);
 	  if (tReturnCode != -1) {
 	    completedTransaction(tCon);
@@ -866,7 +865,8 @@ Ndb::completedTransaction(NdbConnection* aCon)
   Uint32 tTransArrayIndex = aCon->theTransArrayIndex;
   Uint32 tNoSentTransactions = theNoOfSentTransactions;
   Uint32 tNoCompletedTransactions = theNoOfCompletedTransactions;
-  if ((tNoSentTransactions > 0) && (aCon->theListState == InSendList) &&
+  if ((tNoSentTransactions > 0) && 
+      (aCon->theListState == NdbConnection::InSendList) &&
       (tTransArrayIndex < tNoSentTransactions)) {
     NdbConnection* tMoveCon = theSentTransactionsArray[tNoSentTransactions - 1];
 
@@ -880,7 +880,7 @@ Ndb::completedTransaction(NdbConnection* aCon)
     theNoOfCompletedTransactions = tNoCompletedTransactions + 1;
 
     theNoOfSentTransactions = tNoSentTransactions - 1;
-    aCon->theListState = InCompletedList;
+    aCon->theListState = NdbConnection::InCompletedList;
     aCon->handleExecuteCompletion();
     if ((theMinNoOfEventsToWakeUp != 0) &&
         (theNoOfCompletedTransactions >= theMinNoOfEventsToWakeUp)) {
@@ -915,7 +915,7 @@ Ndb::reportCallback(NdbConnection** aCopyArray, Uint32 aNoOfCompletedTrans)
       NdbAsynchCallback aCallback = aCopyArray[i]->theCallbackFunction;
       int tResult = 0;
       if (aCallback != NULL) {
-        if (aCopyArray[i]->theReturnStatus == ReturnFailure) {
+        if (aCopyArray[i]->theReturnStatus == NdbConnection::ReturnFailure) {
           tResult = -1;
         }//if
         (*aCallback)(tResult, aCopyArray[i], anyObject);
@@ -939,13 +939,13 @@ Ndb::pollCompleted(NdbConnection** aCopyArray)
   if (tNoCompletedTransactions > 0) {
     for (i = 0; i < tNoCompletedTransactions; i++) {
       aCopyArray[i] = theCompletedTransactionsArray[i];
-      if (aCopyArray[i]->theListState != InCompletedList) {
+      if (aCopyArray[i]->theListState != NdbConnection::InCompletedList) {
         ndbout << "pollCompleted error ";
         ndbout << aCopyArray[i]->theListState << endl;
 	abort();
       }//if
       theCompletedTransactionsArray[i] = NULL;
-      aCopyArray[i]->theListState = NotInList;
+      aCopyArray[i]->theListState = NdbConnection::NotInList;
     }//for
   }//if
   theNoOfCompletedTransactions = 0;
@@ -967,8 +967,8 @@ Ndb::check_send_timeout()
         a_con->printState();
 #endif
         a_con->setOperationErrorCodeAbort(4012);
-        a_con->theCommitStatus = Aborted;
-        a_con->theCompletionStatus = CompletedFailure;
+        a_con->theCommitStatus = NdbConnection::Aborted;
+        a_con->theCompletionStatus = NdbConnection::CompletedFailure;
         a_con->handleExecuteCompletion();
         remove_sent_list(i);
         insert_completed_list(a_con);
@@ -997,7 +997,7 @@ Ndb::insert_completed_list(NdbConnection* a_con)
   Uint32 no_of_comp = theNoOfCompletedTransactions;
   theCompletedTransactionsArray[no_of_comp] = a_con;
   theNoOfCompletedTransactions = no_of_comp + 1;
-  a_con->theListState = InCompletedList;
+  a_con->theListState = NdbConnection::InCompletedList;
   a_con->theTransArrayIndex = no_of_comp;
   return no_of_comp;
 }
@@ -1008,7 +1008,7 @@ Ndb::insert_sent_list(NdbConnection* a_con)
   Uint32 no_of_sent = theNoOfSentTransactions;
   theSentTransactionsArray[no_of_sent] = a_con;
   theNoOfSentTransactions = no_of_sent + 1;
-  a_con->theListState = InSendList;
+  a_con->theListState = NdbConnection::InSendList;
   a_con->theTransArrayIndex = no_of_sent;
   return no_of_sent;
 }
@@ -1046,10 +1046,10 @@ Ndb::sendPrepTrans(int forceSend)
     if ((tp->getNodeSequence(node_id) == a_con->theNodeSequence) &&
          tp->get_node_alive(node_id) ||
          (tp->get_node_stopping(node_id) && 
-         ((a_con->theSendStatus == sendABORT) ||
-          (a_con->theSendStatus == sendABORTfail) ||
-          (a_con->theSendStatus == sendCOMMITstate) ||
-          (a_con->theSendStatus == sendCompleted)))) {
+         ((a_con->theSendStatus == NdbConnection::sendABORT) ||
+          (a_con->theSendStatus == NdbConnection::sendABORTfail) ||
+          (a_con->theSendStatus == NdbConnection::sendCOMMITstate) ||
+          (a_con->theSendStatus == NdbConnection::sendCompleted)))) {
       /*
       We will send if
       1) Node is alive and sequences are correct OR
@@ -1081,13 +1081,13 @@ Ndb::sendPrepTrans(int forceSend)
         again and will thus set the state to Aborted to avoid a more or
         less eternal loop of tries.
         */
-        if (a_con->theSendStatus == sendOperations) {
+        if (a_con->theSendStatus == NdbConnection::sendOperations) {
           a_con->setOperationErrorCodeAbort(4021);
-          a_con->theCommitStatus = NeedAbort;
+          a_con->theCommitStatus = NdbConnection::NeedAbort;
           TRACE_DEBUG("Send buffer full and sendOperations");
         } else {
           a_con->setOperationErrorCodeAbort(4026);
-          a_con->theCommitStatus = Aborted;
+          a_con->theCommitStatus = NdbConnection::Aborted;
           TRACE_DEBUG("Send buffer full, set state to Aborted");
         }//if
       }//if
@@ -1104,7 +1104,7 @@ Ndb::sendPrepTrans(int forceSend)
         */
         TRACE_DEBUG("Abort a transaction when stopping a node");
         a_con->setOperationErrorCodeAbort(4023);
-        a_con->theCommitStatus = NeedAbort;
+        a_con->theCommitStatus = NdbConnection::NeedAbort;
       } else {
         /*
         The node is hard dead and we cannot continue. We will also release
@@ -1114,10 +1114,10 @@ Ndb::sendPrepTrans(int forceSend)
         a_con->setOperationErrorCodeAbort(4025);
         a_con->theReleaseOnClose = true;
         a_con->theTransactionIsStarted = false;
-        a_con->theCommitStatus = Aborted;
+        a_con->theCommitStatus = NdbConnection::Aborted;
       }//if
     }//if
-    a_con->theCompletionStatus = CompletedFailure;
+    a_con->theCompletionStatus = NdbConnection::CompletedFailure;
     a_con->handleExecuteCompletion();
     insert_completed_list(a_con);
   }//for
diff --git a/ndb/src/ndbapi/Ndbinit.cpp b/ndb/src/ndbapi/Ndbinit.cpp
index be7acc48d7a..042faa431a0 100644
--- a/ndb/src/ndbapi/Ndbinit.cpp
+++ b/ndb/src/ndbapi/Ndbinit.cpp
@@ -17,8 +17,8 @@
 
 #include "NdbApiSignal.hpp"
 #include "NdbImpl.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp" 
+//#include "NdbSchemaOp.hpp"
+//#include "NdbSchemaCon.hpp" 
 #include "NdbOperation.hpp"
 #include "NdbConnection.hpp"
 #include "NdbRecAttr.hpp"
@@ -72,8 +72,8 @@ Ndb::Ndb( const char* aDataBase , const char* aDataBaseSchema) :
   theOpIdleList(NULL),
   theScanOpIdleList(NULL),
   theIndexOpIdleList(NULL),
-  theSchemaConIdleList(NULL),
-  theSchemaConToNdbList(NULL),
+//  theSchemaConIdleList(NULL),
+//  theSchemaConToNdbList(NULL),
   theTransactionList(NULL),
   theConnectionArray(NULL),
   theRecAttrIdleList(NULL),
@@ -207,8 +207,8 @@ Ndb::~Ndb()
 
   NdbMutex_Unlock(&createNdbMutex);
   
-  if (theSchemaConToNdbList != NULL)
-    closeSchemaTransaction(theSchemaConToNdbList);
+//  if (theSchemaConToNdbList != NULL)
+//    closeSchemaTransaction(theSchemaConToNdbList);
   while ( theConIdleList != NULL )
     freeNdbCon();
   while ( theSignalIdleList != NULL )
diff --git a/ndb/src/ndbapi/Ndblist.cpp b/ndb/src/ndbapi/Ndblist.cpp
index 3839cc3291b..0d9c0f60985 100644
--- a/ndb/src/ndbapi/Ndblist.cpp
+++ b/ndb/src/ndbapi/Ndblist.cpp
@@ -16,8 +16,8 @@
 
 #include <NdbOut.hpp>
 #include "Ndb.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp" 
+//#include "NdbSchemaOp.hpp"
+//#include "NdbSchemaCon.hpp" 
 #include "NdbOperation.hpp"
 #include "NdbScanOperation.hpp"
 #include "NdbIndexOperation.hpp"
@@ -104,7 +104,7 @@ Ndb::createConIdleList(int aNrOfCon)
       tNdbCon->next(theConIdleList);
       theConIdleList = tNdbCon;
     }
-    tNdbCon->Status(NotConnected);
+    tNdbCon->Status(NdbConnection::NotConnected);
   }
   theNoOfAllocatedTransactions = aNrOfCon;
   return aNrOfCon; 
@@ -770,7 +770,7 @@ Ndb::releaseConnectToNdb(NdbConnection* a_con)
   tSignal.setData((tConPtr = a_con->getTC_ConnectPtr()), 1);
   tSignal.setData(theMyRef, 2);
   tSignal.setData(a_con->ptr2int(), 3); 
-  a_con->Status(DisConnecting);
+  a_con->Status(NdbConnection::DisConnecting);
   a_con->theMagicNumber = 0x37412619;
   int ret_code = sendRecSignal(node_id,
                                WAIT_TC_RELEASE,
diff --git a/ndb/src/ndbapi/TransporterFacade.cpp b/ndb/src/ndbapi/TransporterFacade.cpp
index f4a3ae3e87d..7806e482f1f 100644
--- a/ndb/src/ndbapi/TransporterFacade.cpp
+++ b/ndb/src/ndbapi/TransporterFacade.cpp
@@ -16,7 +16,6 @@
 
 #include <ndb_global.h>
 #include <ndb_limits.h>
-#include <AttrType.hpp>
 #include "TransporterFacade.hpp"
 #include "ClusterMgr.hpp"
 #include <IPCConfig.hpp>
diff --git a/ndb/src/ndbapi/TransporterFacade.hpp b/ndb/src/ndbapi/TransporterFacade.hpp
index d9d2dbbcf0f..1fe72debe1c 100644
--- a/ndb/src/ndbapi/TransporterFacade.hpp
+++ b/ndb/src/ndbapi/TransporterFacade.hpp
@@ -17,7 +17,6 @@
 #ifndef TransporterFacade_H
 #define TransporterFacade_H
 
-#include <AttrType.hpp>
 #include <kernel_types.h>
 #include <ndb_limits.h>
 #include <NdbThread.h>
@@ -43,6 +42,10 @@ extern "C" {
   void atexit_stop_instance();
 }
 
+/**
+ * Max number of Ndb objects in different threads.  
+ * (Ndb objects should not be shared by different threads.)
+ */
 class TransporterFacade
 {
 public:
@@ -156,6 +159,8 @@ private:
   /**
    * Block number handling
    */
+  static const unsigned MAX_NO_THREADS = 4711;
+
   struct ThreadData {
     static const Uint32 ACTIVE = (1 << 16) | 1;
     static const Uint32 INACTIVE = (1 << 16);
diff --git a/ndb/test/include/NDBT_Table.hpp b/ndb/test/include/NDBT_Table.hpp
index 950c1f15ff7..eee76773106 100644
--- a/ndb/test/include/NDBT_Table.hpp
+++ b/ndb/test/include/NDBT_Table.hpp
@@ -25,66 +25,6 @@
 class NDBT_Attribute : public NdbDictionary::Column {
   friend class NdbOut& operator <<(class NdbOut&, const NDBT_Attribute &);
 public:
-  NDBT_Attribute(const char* anAttrName,
-		 AttrType type,
-		 int sz = 4,
-		 KeyType key = NoKey,
-		 bool nullable = false,
-		 StorageAttributeType indexOnly = NormalStorageAttribute,
-		 StorageMode _sm = MMBased) :
-    NdbDictionary::Column(anAttrName)
-  {
-    assert(anAttrName != 0);
-    
-    setNullable(nullable);
-    setIndexOnlyStorage(indexOnly == IndexStorageAttribute);
-    setPrimaryKey(key != NoKey);
-    setTupleKey(key == TupleId);
-    setLength(1);
-    switch(type){
-    case ::Signed:
-      if(sz == 8)
-	setType(NdbDictionary::Column::Bigint);
-      else if (sz == 4)
-	setType(NdbDictionary::Column::Int);
-      else {
-	setType(NdbDictionary::Column::Int);
-	setLength(sz);
-      }
-      break;
-      
-    case ::UnSigned:
-      if(sz == 8)
-	setType(NdbDictionary::Column::Bigunsigned);
-      else if (sz == 4)
-	setType(NdbDictionary::Column::Unsigned);
-      else {
-	setType(NdbDictionary::Column::Unsigned);
-	setLength(sz);
-      }
-      break;
-      
-    case ::Float:
-      if(sz == 8)
-	setType(NdbDictionary::Column::Double);
-      else if (sz == 4)
-	setType(NdbDictionary::Column::Float);
-      else{
-	setType(NdbDictionary::Column::Float);
-	setLength(sz);
-      }
-      break;
-      
-    case ::String:
-      setType(NdbDictionary::Column::Char);
-      setLength(sz);
-      break;
-      
-    case ::NoAttrTypeDef:
-      break;
-    }
-  }
-
   NDBT_Attribute(const char* _name,
 		 Column::Type _type,
 		 int _length = 1,
@@ -132,4 +72,13 @@ NDBT_Table::discoverTableFromDb(Ndb* ndb, const char * name){
   return ndb->getDictionary()->getTable(name);
 }
 
+
+/**
+ * Print meta information about index
+ * (information on how it is strored, what the attributes look like etc.)
+ */
+class NdbOut& operator <<(class NdbOut&, const NdbDictionary::Index &);
+
+
+
 #endif
diff --git a/ndb/test/ndbapi/acid/acid.cpp b/ndb/test/ndbapi/acid/acid.cpp
index 49961531a1c..157b3c7b3ef 100644
--- a/ndb/test/ndbapi/acid/acid.cpp
+++ b/ndb/test/ndbapi/acid/acid.cpp
@@ -15,6 +15,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #include <NdbApi.hpp>
+#include <NdbSchemaCon.hpp>
 #include <NdbMutex.h>
 #include <NdbOut.hpp>
 #include <NdbSleep.h>
@@ -230,7 +231,6 @@ extern "C" void* NdbThreadFuncInsert(void* pArg)
     VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum));
     int iExec = pNdbConnection->execute(Commit);
     int iError = pNdbConnection->getNdbError().code;
-    CommitStatusType cs = pNdbConnection->commitStatus();
 
     if(iExec<0 && iError!=0 && iError!=266 && iError!=630) {
       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
@@ -285,7 +285,6 @@ extern "C" void* NdbThreadFuncUpdate(void* pArg)
     VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum));
     int iExec = pNdbConnection->execute(Commit);
     int iError = pNdbConnection->getNdbError().code;
-    CommitStatusType cs = pNdbConnection->commitStatus();
 
     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
@@ -333,7 +332,6 @@ extern "C" void* NdbThreadFuncDelete(void* pArg)
     }
     int iExec = pNdbConnection->execute(Commit);
     int iError = pNdbConnection->getNdbError().code;
-    CommitStatusType cs = pNdbConnection->commitStatus();
 
     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
@@ -389,7 +387,7 @@ extern "C" void* NdbThreadFuncRead(void* pArg)
     }
     int iExec = pNdbConnection->execute(Commit);
     int iError = pNdbConnection->getNdbError().code;
-    CommitStatusType cs = pNdbConnection->commitStatus();
+    
     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
     }
@@ -465,8 +463,7 @@ NDB_COMMAND(acid, "acid", "acid", "acid", 65535)
   VerifyMethodInt(pNdb, init());
   VerifyMethodInt(pNdb, waitUntilReady());
 
-  NdbSchemaCon* pNdbSchemaCon = NULL ;
-  VerifyMethodPtr(pNdbSchemaCon, pNdb, startSchemaTransaction());
+  NdbSchemaCon* pNdbSchemaCon= NdbSchemaCon::startSchemaTrans(pNdb);
   if(!pNdbSchemaCon){
     ndbout <<"startSchemaTransaction failed, exiting now" << endl ;
     delete pNdb ;
@@ -497,9 +494,9 @@ NDB_COMMAND(acid, "acid", "acid", "acid", 65535)
   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szWarehouseSum, NoKey, 32, 1, UnSigned, MMBased, false));
   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szWarehouseCount, NoKey, 32, 1, UnSigned, MMBased, false));
   VerifyMethodInt(pNdbSchemaCon, execute());
-  VerifyMethodVoid(pNdb, closeSchemaTransaction(pNdbSchemaCon));
+  NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
 
-  VerifyMethodPtr(pNdbSchemaCon, pNdb, startSchemaTransaction());
+  pNdbSchemaCon= NdbSchemaCon::startSchemaTrans(pNdb);
   VerifyMethodPtr(pNdbSchemaOp, pNdbSchemaCon, getNdbSchemaOp());
 #if defined NDB_OSE || defined NDB_SOFTOSE
   VerifyMethodInt(pNdbSchemaOp, createTable(
@@ -526,7 +523,7 @@ NDB_COMMAND(acid, "acid", "acid", "acid", 65535)
   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictSum, NoKey, 32, 1, UnSigned, MMBased, false));
   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictCount, NoKey, 32, 1, UnSigned, MMBased, false));
   VerifyMethodInt(pNdbSchemaCon, execute());
-  VerifyMethodVoid(pNdb, closeSchemaTransaction(pNdbSchemaCon));
+  NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
   g_pNdbMutex = NdbMutex_Create();
   NdbMutex_Lock(g_pNdbMutex);
 
diff --git a/ndb/test/ndbapi/flexAsynch/flexAsynch.cpp b/ndb/test/ndbapi/flexAsynch/flexAsynch.cpp
index 0822f3ee999..396ac06c87a 100644
--- a/ndb/test/ndbapi/flexAsynch/flexAsynch.cpp
+++ b/ndb/test/ndbapi/flexAsynch/flexAsynch.cpp
@@ -15,7 +15,9 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 
+
 #include "NdbApi.hpp"
+#include <NdbSchemaCon.hpp>
 #include <NdbMain.h>
 #include <md5_hash.hpp>
 
@@ -738,7 +740,7 @@ createTables(Ndb* pMyNdb){
   if (theTableCreateFlag == 0) {
     for(int i=0; i < 1 ;i++) {
       ndbout << "Creating " << tableName[i] << "..." << endl;
-      MySchemaTransaction = pMyNdb->startSchemaTransaction();
+      MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
       
       if(MySchemaTransaction == NULL && 
          (!error_handler(MySchemaTransaction->getNdbError())))
@@ -748,7 +750,8 @@ createTables(Ndb* pMyNdb){
       if(MySchemaOp == NULL &&
          (!error_handler(MySchemaTransaction->getNdbError())))
         return -1;
-      
+
+
       check = MySchemaOp->createTable( tableName[i]
                                        ,8                       // Table Size
                                        ,TupleKey                // Key Type
@@ -793,7 +796,7 @@ createTables(Ndb* pMyNdb){
           (!error_handler(MySchemaTransaction->getNdbError())))
         return -1;
       
-      pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+      NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
     }
   }
   
diff --git a/ndb/test/ndbapi/flexScan/flexScan.cpp b/ndb/test/ndbapi/flexScan/flexScan.cpp
index 19fb6dc5ab0..5b5b4dde730 100644
--- a/ndb/test/ndbapi/flexScan/flexScan.cpp
+++ b/ndb/test/ndbapi/flexScan/flexScan.cpp
@@ -62,6 +62,7 @@
 #include <NdbMain.h>
 #include <NdbTest.hpp>
 #include <NDBT_Error.hpp>
+#include <NdbSchemaCon.hpp>
 
 #define PKSIZE 1
 #define FOREVER 1
@@ -151,7 +152,6 @@ static void UpdateArray(int *attrValue)
   int attrCount = 0;
   int opCount = 0;
   int sizeCount = 0;
-  int Index = 0;
   int* pValue = attrValue;
 
   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
@@ -179,7 +179,6 @@ static void Compare(int* attrValue, int* readValue)
   int attrCount = 0;
   int OpCount = 0;
   int first = 0;
-  int sizeCount = 0;
 
   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
     for (attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
@@ -592,19 +591,14 @@ flexScanThread(void* ThreadData)
   ThreadNdb* pThreadData = (ThreadNdb*)ThreadData;
   unsigned int thread_no = pThreadData->ThreadNo;
   unsigned int thread_base = (thread_no * 2000000) + (tNodeId * 26000);
-  int NrOfScannedRecords = 0;
   int tThreadResult = 0;
   Ndb*			MyNdb = NULL;
-  NdbConnection		*MyTransaction = NULL;
-  NdbOperation*		MyOperation[MAXTABLES];
   int                   check = 0;
   StartType	      	tType = stLast;
   int*                  pkValue = NULL;
   int*			attrValue = NULL;
   int*			readValue = NULL;
   int                   AllocSize = 0;
-  NdbRecAttr*           tTmp = NULL;
-  OperationType opType;
   
   AllocSize = tNoOfTables * (tNoOfAttributes-1) * tNoOfOperations * 
     tAttributeSize * sizeof(int);
@@ -770,15 +764,15 @@ static int createTables(Ndb* pMyNdb)
     do {
       i++;
       ndbout << endl << "Creating " << tableName[i - 1] << "..." << endl;
-      
-      MySchemaTransaction = pMyNdb->startSchemaTransaction();
+
+      MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);      
       if( MySchemaTransaction == NULL ) {
 	return (-1);
       } // if
 
       MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
       if( MySchemaOp == NULL ) {
-	pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+	NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
 	return (-1);
       } // if
 
@@ -800,14 +794,14 @@ static int createTables(Ndb* pMyNdb)
 				      ,40);		// Nr of Pages
 #endif		     
       if (check == -1) {
-	pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+	NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
 	return -1;
       } // if
       
       check = MySchemaOp->createAttribute( (char*)attrName[0], TupleKey, 32, PKSIZE,
 					   UnSigned, MMBased, NotNullAttribute );
       if (check == -1) {
-	pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+	NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
 	return -1;
       } // if
       
@@ -815,7 +809,7 @@ static int createTables(Ndb* pMyNdb)
 	check = MySchemaOp->createAttribute( (char*)attrName[j], NoKey, 32, tAttributeSize,
 					     UnSigned, MMBased, NotNullAttribute );
 	if (check == -1) {
-	  pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+	  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
 	  return -1;
 	} // if
       } // for
@@ -825,7 +819,7 @@ static int createTables(Ndb* pMyNdb)
 	ndbout << "Probably, " << tableName[i - 1] << " already exist" << endl;
       } // if
       
-      pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+      NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
     } while (tNoOfTables > i);
   }
 
@@ -1058,7 +1052,6 @@ static int insertRows(Ndb* pNdb, // NDB object
   int attrCount = 0;
   NdbConnection* MyTransaction = NULL;
   NdbOperation* MyOperations[MAXTABLES] = {NULL};
-  int Index = 0;
   int opCount = 0;
   
   for (opCount = 0; opCount < tNoOfOperations; opCount++) {
@@ -1099,7 +1092,7 @@ static int insertRows(Ndb* pNdb, // NDB object
 	} // if
 	
 	for (attrCount = 0; attrCount < tNoOfAttributes - 1; attrCount++) {
-	  Index = tableCount * (tNoOfAttributes - 1) * tNoOfOperations * tAttributeSize +
+	  int Index = tableCount * (tNoOfAttributes - 1) * tNoOfOperations * tAttributeSize +
 	    attrCount * tNoOfOperations * tAttributeSize + opCount * tAttributeSize;
 	  check = MyOperations[tableCount]->
 	    setValue((char*)attrName[attrCount + 1],
diff --git a/ndb/test/ndbapi/interpreterInTup/interpreterInTup.cpp b/ndb/test/ndbapi/interpreterInTup/interpreterInTup.cpp
index a2352edf707..47960cd5d12 100644
--- a/ndb/test/ndbapi/interpreterInTup/interpreterInTup.cpp
+++ b/ndb/test/ndbapi/interpreterInTup/interpreterInTup.cpp
@@ -58,6 +58,7 @@
 #include <NdbThread.h>
 #include <NdbMutex.h>
 #include <NdbApi.hpp>
+#include <NdbSchemaCon.hpp>
 #include <NDBT.hpp>
 
 #define MAXATTR 3
@@ -93,8 +94,8 @@ TTYPE t_addReg(int, NdbOperation*);
 TTYPE t_subReg(int, NdbOperation*);
 TTYPE t_subroutineWithBranchLabel(int, NdbOperation*);
 
-char        tableName[MAXTABLES][MAXSTRLEN+1] = {0};
-char        attrName[MAXATTR][MAXSTRLEN+1] = {0};
+char        tableName[MAXSTRLEN+1];
+char        attrName[MAXATTR][MAXSTRLEN+1];
 int         attrValue[NUMBEROFRECORDS] = {0};
 int         pkValue[NUMBEROFRECORDS] = {0};
 const int   tAttributeSize = 1 ;
@@ -105,11 +106,9 @@ int         bTestPassed = 0;
 
 int main(int argc, const char** argv) {
 
-  int tTableId = 0;
   int operationType = 0;
-  int tupTest = 0 ;
-  int scanTest = 0 ;
-  bool loop = 0 ;
+  int tupTest = 0;
+  int scanTest = 0;
 
   Ndb* pNdb = new Ndb("TEST_DB");
   pNdb->init();
@@ -140,7 +139,7 @@ int main(int argc, const char** argv) {
   setAttrNames() ;
   setTableNames() ;
   
-  const void * p = NDBT_Table::discoverTableFromDb(pNdb, tableName[0]);
+  const void * p = NDBT_Table::discoverTableFromDb(pNdb, tableName);
   if (p != 0){
     create_table(pNdb);
   }
@@ -252,18 +251,17 @@ void  create_table(Ndb* pMyNdb) {
    ***************************************************************/
 
   int               check = -1 ;
-  NdbSchemaCon      *MySchemaTransaction = NULL ;
   NdbSchemaOp       *MySchemaOp = NULL ;
 
-  ndbout << endl << "Creating " << tableName[0] << " ... " << endl;
+  ndbout << endl << "Creating " << tableName << " ... " << endl;
 
-   MySchemaTransaction = pMyNdb->startSchemaTransaction();
+   NdbSchemaCon* MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
    if(!MySchemaTransaction) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
    
    MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
    if( !MySchemaOp ) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
    // Create table
-   check = MySchemaOp->createTable( tableName[0],
+   check = MySchemaOp->createTable( tableName,
                                      8,         // Table size
                                      TupleKey,  // Key Type
                                      40         // Nr of Pages
@@ -305,7 +303,8 @@ void  create_table(Ndb* pMyNdb) {
        ndbout << tableName[0] << " created" << endl;
    }
 
-   pMyNdb->closeSchemaTransaction(MySchemaTransaction);
+
+   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
 
    return;
 
@@ -333,7 +332,7 @@ void write_rows (Ndb* pMyNdb) {
           error_handler(pMyNdb->getNdbError(), NO_FAIL);
       }//if
 
-      MyOperation = MyTransaction->getNdbOperation(tableName[0]);
+      MyOperation = MyTransaction->getNdbOperation(tableName);
       if (!MyOperation) {
         error_handler(pMyNdb->getNdbError(), NO_FAIL);
       }//if
@@ -366,9 +365,6 @@ void verify_deleted(Ndb* pMyNdb) {
 
   int               check = -1 ;
   int               loop_count_ops = nRecords;
-  NdbRecAttr*       tTmp;
-  int               readValue[MAXATTR];
-  NdbConnection*    pMyTransaction = NULL ;
   NdbOperation*     pMyOperation = NULL ;
 
   ndbout << "Verifying deleted records..."<< flush;
@@ -378,7 +374,7 @@ void verify_deleted(Ndb* pMyNdb) {
       NdbConnection*  pMyTransaction = pMyNdb->startTransaction();
       if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
       
-      pMyOperation = pMyTransaction->getNdbOperation(tableName[0]);
+      pMyOperation = pMyTransaction->getNdbOperation(tableName);
       if (!pMyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL);
       
       check = pMyOperation->readTuple();
@@ -421,7 +417,7 @@ void read_and_verify_rows(Ndb* pMyNdb, bool pre) {
       pMyTransaction = pMyNdb->startTransaction();
       if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
 
-      MyOp = pMyTransaction->getNdbOperation(tableName[0]);
+      MyOp = pMyTransaction->getNdbOperation(tableName);
       if (!MyOp) error_handler( pMyTransaction->getNdbError(), NO_FAIL);
 
 
@@ -1232,14 +1228,13 @@ void scan_rows(Ndb* pMyNdb, int opType, int tupleType, int scanType) {
   int           readValue = 0 ;
   int           readValue2 = 0 ;
   int           scanCount = 0 ;
-  NdbRecAttr*   tTmp = NULL ;
   TTYPE         fail = NO_FAIL ;
 
   for (int count=0 ; count < loop_count_ops ; count++)    {
   NdbConnection* MyTransaction = pMyNdb->startTransaction();
   if (!MyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
 
-  NdbOperation*  MyOperation = MyTransaction->getNdbOperation(tableName[0]);
+  NdbOperation*  MyOperation = MyTransaction->getNdbOperation(tableName);
   if (!MyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL);
 
   if (opType == 1)
@@ -1306,7 +1301,7 @@ void scan_rows(Ndb* pMyNdb, int opType, int tupleType, int scanType) {
   }else{
     // Sends the SCAN_NEXTREQ signal(s) and reads the answer in TRANS_ID signals.
     // SCAN_TABCONF or SCAN_TABREF is the confirmation.
-    while (eOf = MyTransaction->nextScanResult() == 0) {
+    while ((eOf = MyTransaction->nextScanResult()) == 0) {
       ndbout << readValue <<"; ";
       // Here we call takeOverScanOp for update of the tuple.
     }
@@ -1348,7 +1343,7 @@ void  update_rows(Ndb* pMyNdb, int tupleType, int opType) {
       return;
     }//if
 
-    MyOperation = MyTransaction->getNdbOperation(tableName[0]);
+    MyOperation = MyTransaction->getNdbOperation(tableName);
     if (MyOperation == NULL) {
       error_handler(pMyNdb->getNdbError(), NO_FAIL);
       return;
@@ -1442,7 +1437,7 @@ void delete_rows(Ndb* pMyNdb, int tupleTest, int opType) {
     MyTransaction = pMyNdb->startTransaction();
     if (!MyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL) ;
     
-    MyOperation = MyTransaction->getNdbOperation(tableName[0]);
+    MyOperation = MyTransaction->getNdbOperation(tableName);
     if (!MyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL) ;
 
     check = MyOperation->interpretedDeleteTuple();
@@ -1517,8 +1512,6 @@ inline void setAttrNames(){
 
 
 inline void setTableNames(){
-  for (int i = 0; i < MAXTABLES; i++){
-      snprintf(tableName[i], MAXSTRLEN, "TAB%d", i);
-    }
+  snprintf(tableName, MAXSTRLEN, "TAB1");
 }
 
diff --git a/ndb/test/ndbapi/lmc-bench/src/user/userInterface.cpp b/ndb/test/ndbapi/lmc-bench/src/user/userInterface.cpp
index 67c4e037215..fe3c17acbf5 100644
--- a/ndb/test/ndbapi/lmc-bench/src/user/userInterface.cpp
+++ b/ndb/test/ndbapi/lmc-bench/src/user/userInterface.cpp
@@ -32,6 +32,7 @@
 #include <NdbSleep.h>
 #include "ndb_schema.hpp"
 #include <NDBT.hpp>
+#include <NdbSchemaCon.hpp>
 
 /***************************************************************
 * L O C A L   C O N S T A N T S                                *
@@ -141,13 +142,11 @@ extern int useIndexTables;
 
 
 int
-create_table_server(Ndb * pNDB){
-  
+create_table_server(Ndb * pNdb){
   int check;
-   
-  NdbSchemaCon * MySchemaTransaction = pNDB->startSchemaTransaction();
+  NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if( MySchemaTransaction == NULL )
-    error_handler("startSchemaTransaction", pNDB->getNdbError(), 0);
+    error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
   
   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
   if( MySchemaOp == NULL ) 
@@ -246,17 +245,17 @@ create_table_server(Ndb * pNDB){
     error_handler("schemaTransaction->execute()", 
 		  MySchemaTransaction->getNdbError(), 0);
   }    
-  pNDB->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   return 0;
 }
 
 int
-create_table_group(Ndb * pNDB){
+create_table_group(Ndb * pNdb){
   int check;
 
-  NdbSchemaCon * MySchemaTransaction = pNDB->startSchemaTransaction();
+  NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if( MySchemaTransaction == NULL )
-    error_handler("startSchemaTransaction", pNDB->getNdbError(), 0);
+    error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
   
   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
   if( MySchemaOp == NULL ) 
@@ -340,16 +339,16 @@ create_table_group(Ndb * pNDB){
     error_handler("schemaTransaction->execute()", 
 		  MySchemaTransaction->getNdbError(), 0);
   }    
-  pNDB->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   return 0;
 }
 
 int
-create_table_subscriber(Ndb * pNDB){
+create_table_subscriber(Ndb * pNdb){
   int check;
-  NdbSchemaCon * MySchemaTransaction = pNDB->startSchemaTransaction();
+  NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if( MySchemaTransaction == NULL )
-    error_handler("startSchemaTransaction", pNDB->getNdbError(), 0);
+    error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
   
   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
   if( MySchemaOp == NULL ) 
@@ -459,16 +458,16 @@ create_table_subscriber(Ndb * pNDB){
     error_handler("schemaTransaction->execute()", 
 		  MySchemaTransaction->getNdbError(), 0);
   }    
-  pNDB->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   return 0;
 }
 
 int
-create_table_session(Ndb * pNDB){
+create_table_session(Ndb * pNdb){
   int check;
-  NdbSchemaCon * MySchemaTransaction = pNDB->startSchemaTransaction();
+  NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if( MySchemaTransaction == NULL )
-    error_handler("startSchemaTransaction", pNDB->getNdbError(), 0);
+    error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
   
   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
   if( MySchemaOp == NULL ) 
@@ -533,29 +532,29 @@ create_table_session(Ndb * pNDB){
     error_handler("schemaTransaction->execute()", 
 		  MySchemaTransaction->getNdbError(), 0);
   }    
-  pNDB->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   return 0;
 }
 
 void 
-create_table(const char * name, int (* function)(Ndb * pNDB), Ndb* pNDB){
+create_table(const char * name, int (* function)(Ndb * pNdb), Ndb* pNdb){
   printf("creating table %s...", name);
-  if(pNDB->getDictionary()->getTable(name) != 0){
+  if(pNdb->getDictionary()->getTable(name) != 0){
     printf(" it already exists\n");
     return;
   } else {
     printf("\n");
   }
-  function(pNDB);
+  function(pNdb);
   printf("creating table %s... done\n", name);
 }
 
-static int dbCreate(Ndb * pNDB)
+static int dbCreate(Ndb * pNdb)
 {
-  create_table(SUBSCRIBER_TABLE, create_table_subscriber, pNDB);
-  create_table(GROUP_TABLE     , create_table_group, pNDB);
-  create_table(SESSION_TABLE   , create_table_session, pNDB);
-  create_table(SERVER_TABLE    , create_table_server, pNDB);
+  create_table(SUBSCRIBER_TABLE, create_table_subscriber, pNdb);
+  create_table(GROUP_TABLE     , create_table_group, pNdb);
+  create_table(SESSION_TABLE   , create_table_session, pNdb);
+  create_table(SERVER_TABLE    , create_table_server, pNdb);
   return 0;
 }
 
@@ -570,23 +569,23 @@ userDbConnect(uint32 createDb, char *dbName)
 {
   NdbMutex_Lock(startupMutex);
 
-  Ndb * pNDB = new Ndb("");
+  Ndb * pNdb = new Ndb("");
   
   //printf("Initializing...\n");
-  pNDB->init();
+  pNdb->init();
   
   //printf("Waiting...");
-  while(pNDB->waitUntilReady() != 0){
+  while(pNdb->waitUntilReady() != 0){
     //printf("...");
   }
   //  printf("done\n");
   
   if( createDb )
-    dbCreate(pNDB);
+    dbCreate(pNdb);
   
 
   UserHandle * uh = new UserHandle;
-  uh->pNDB       = pNDB;
+  uh->pNDB       = pNdb;
   uh->pCurrTrans = 0;
 
   NdbMutex_Unlock(startupMutex);
diff --git a/ndb/test/ndbapi/ronja/initronja/initronja.cpp b/ndb/test/ndbapi/ronja/initronja/initronja.cpp
index f3f4d9628e2..b3215104822 100644
--- a/ndb/test/ndbapi/ronja/initronja/initronja.cpp
+++ b/ndb/test/ndbapi/ronja/initronja/initronja.cpp
@@ -21,6 +21,7 @@
  * *************************************************** */
 
 #include "NdbApi.hpp"
+#include "NdbSchemaCon.hpp"
 #include <NdbOut.hpp>
 #include <NdbMain.h>
 #include <NdbTest.hpp>
@@ -90,7 +91,7 @@ NDB_COMMAND(initronja, "initronja", "initronja", "initronja", 65535){
   
   ndbout << endl << "Creating the table SHORT_REC" << "..." << endl;
 
-  MySchemaTransaction = pNdb->startSchemaTransaction();
+  MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if(!MySchemaTransaction) goto error_handler;
   MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
   if(!MySchemaOp) goto error_handler;
@@ -148,11 +149,11 @@ NDB_COMMAND(initronja, "initronja", "initronja", "initronja", 65535){
 	  ndbout << "SHORT_REC created " << endl;
   }// if
 
-  pNdb->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   
   ndbout << endl << "Creating the table LONG_REC..." << endl;
 
-  MySchemaTransaction = pNdb->startSchemaTransaction();
+  MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
   if(!MySchemaTransaction) goto error_handler;
    
   MySchemaOp = MySchemaTransaction->getNdbSchemaOp();	
@@ -212,7 +213,7 @@ NDB_COMMAND(initronja, "initronja", "initronja", "initronja", 65535){
 	  ndbout << "LONG_REC created" << endl;
   }// if
   
-  pNdb->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   
 
   check = InsertRecords(pNdb, tNoOfRecords);
@@ -234,7 +235,7 @@ NDB_COMMAND(initronja, "initronja", "initronja", "initronja", 65535){
 error_handler:
   ndbout << "SchemaTransaction returned error:" ;
   ndbout << MySchemaTransaction->getNdbError() << endl;
-  pNdb->closeSchemaTransaction(MySchemaTransaction);
+  NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
   delete pNdb ;
   NDBT_ProgramExit(NDBT_FAILED) ;
   exit(-1);
diff --git a/ndb/test/ndbapi/telco/msa.cpp b/ndb/test/ndbapi/telco/msa.cpp
index 39ddaac2019..7a734f9cb79 100644
--- a/ndb/test/ndbapi/telco/msa.cpp
+++ b/ndb/test/ndbapi/telco/msa.cpp
@@ -17,6 +17,7 @@
 #include <ndb_global.h>
 
 #include <NdbApi.hpp>
+#include <NdbSchemaCon.hpp>
 #include <NdbCondition.h>
 #include <NdbMutex.h>
 #include <NdbSleep.h>
@@ -849,7 +850,7 @@ int CreateCallContextTable(Ndb* pNdb, const char* szTableName, bool bStored)
     NdbError err;
     memset(&err, 0, sizeof(err));
 
-    NdbSchemaCon* pNdbSchemaCon = pNdb->startSchemaTransaction();
+    NdbSchemaCon* pNdbSchemaCon = NdbSchemaCon::startSchemaTrans(pNdb);
     if(pNdbSchemaCon)
     {
         NdbSchemaOp* pNdbSchemaOp = pNdbSchemaCon->getNdbSchemaOp();
@@ -874,7 +875,8 @@ int CreateCallContextTable(Ndb* pNdb, const char* szTableName, bool bStored)
         } 
         else 
             err = pNdbSchemaCon->getNdbError();
-        pNdb->closeSchemaTransaction(pNdbSchemaCon);
+
+        NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
     }
     else 
         err = pNdb->getNdbError();
diff --git a/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp b/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
index b8e0fef6cef..75773040113 100644
--- a/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
+++ b/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
@@ -34,7 +34,7 @@
 #include <NdbOut.hpp>
 #include <NdbApi.hpp>
 #include <NdbTest.hpp>
-
+#include <NdbSchemaCon.hpp>
 // limits
 static int const MaxAttr = 64;
 static int const MaxOper = 1000;
@@ -99,7 +99,7 @@ ndberror(char const* fmt, ...)
     if (tcon)
 	ndbout << "tcon: " << tcon->getNdbError() << endl;
     if (top)
-	ndbout << "top : " << top->getNdbError() << endl;
+	ndbout << "top: " << top->getNdbError() << endl;
     if (con)
 	ndbout << "con : " << con->getNdbError() << endl;
     if (op)
@@ -258,7 +258,7 @@ testcase(int flag)
     if (ndb->waitUntilReady(30) < 0)
 	return ndberror("waitUntilReady");
 
-    if ((tcon = ndb->startSchemaTransaction()) == 0)
+    if ((tcon = NdbSchemaCon::startSchemaTrans(ndb)) == 0)
 	return ndberror("startSchemaTransaction");
     if ((top = tcon->getNdbSchemaOp()) == 0)
 	return ndberror("getNdbSchemaOp");
diff --git a/ndb/test/ndbapi/testNdbApi/testNdbApi.cpp b/ndb/test/ndbapi/testNdbApi/testNdbApi.cpp
index c0e262f590f..2e08ebbed4e 100644
--- a/ndb/test/ndbapi/testNdbApi/testNdbApi.cpp
+++ b/ndb/test/ndbapi/testNdbApi/testNdbApi.cpp
@@ -23,8 +23,8 @@
 #include <Vector.hpp>
 #include <random.h>
 #include <NdbTick.h>
-#include <AttrType.hpp>
 
+#define MAX_NDB_OBJECTS 32678
 
 #define CHECK(b) if (!(b)) { \
   ndbout << "ERR: "<< step->getName() \
@@ -79,7 +79,7 @@ int runTestMaxNdb(NDBT_Context* ctx, NDBT_Step* step){
     
     ndbout << i << " ndb objects created" << endl;
     
-    if (l > 0 && i != oldi && init != MAX_NO_THREADS){
+    if (l > 0 && i != oldi && init != MAX_NDB_OBJECTS){
       ndbout << l << ": not as manyNdb objects created" << endl
 	     << i << " != " << oldi << endl;
       result =  NDBT_FAILED;
diff --git a/ndb/test/ndbapi/testRestartGci/testRestartGci.cpp b/ndb/test/ndbapi/testRestartGci/testRestartGci.cpp
index 1e36368ba62..e3dd1f8e2ce 100644
--- a/ndb/test/ndbapi/testRestartGci/testRestartGci.cpp
+++ b/ndb/test/ndbapi/testRestartGci/testRestartGci.cpp
@@ -121,7 +121,7 @@ int runVerifyInserts(NDBT_Context* ctx, NDBT_Step* step){
   HugoOperations hugoOps(*ctx->getTab());
   NdbRestarter restarter;
 
-  int restartGCI = pNdb->NdbTamper(ReadRestartGCI, 0);    
+  int restartGCI = pNdb->NdbTamper(Ndb::ReadRestartGCI, 0);    
 
   ndbout << "restartGCI = " << restartGCI << endl;
   int count = 0;
diff --git a/ndb/test/src/NDBT_ResultRow.cpp b/ndb/test/src/NDBT_ResultRow.cpp
index ba46be203e1..c16b8968097 100644
--- a/ndb/test/src/NDBT_ResultRow.cpp
+++ b/ndb/test/src/NDBT_ResultRow.cpp
@@ -17,6 +17,7 @@
 #include <ndb_global.h>
 #include "NDBT_ResultRow.hpp"
 #include <NdbOut.hpp>
+#include <NdbSchemaCon.hpp>
 
 NDBT_ResultRow::NDBT_ResultRow(const NdbDictionary::Table& tab,
 			       char attrib_delimiter)
@@ -109,6 +110,12 @@ BaseString NDBT_ResultRow::c_str() {
   return str;
 }
 
+
+/**
+ * TODO This could chare the sanme printer function as in 
+ * NdbEventOperationImpl.cpp, using new types of course :)
+ */
+
 NdbOut & 
 operator << (NdbOut& ndbout, const NDBT_ResultRow & res) {
   for(int i = 0; i<res.cols; i++){
@@ -117,7 +124,7 @@ operator << (NdbOut& ndbout, const NDBT_ResultRow & res) {
     else{
       const int  size = res.data[i]->attrSize();
       const int aSize = res.data[i]->arraySize();
-      switch(res.data[i]->attrType()){
+      switch(convertColumnTypeToAttrType(res.data[i]->getType())){
       case UnSigned:
 	switch(size){
 	case 8:
@@ -174,7 +181,8 @@ operator << (NdbOut& ndbout, const NDBT_ResultRow & res) {
 	break;
 	
       default:
-	ndbout << "Unknown(" << res.data[i]->attrType() << ")";
+	ndbout << "Unknown(" << 
+	  convertColumnTypeToAttrType(res.data[i]->getType()) << ")";
 	break;
       }
     }
diff --git a/ndb/test/src/NDBT_Table.cpp b/ndb/test/src/NDBT_Table.cpp
index c520b01c990..48c8567e10e 100644
--- a/ndb/test/src/NDBT_Table.cpp
+++ b/ndb/test/src/NDBT_Table.cpp
@@ -26,7 +26,7 @@ operator <<(class NdbOut& ndbout, const NDBT_Attribute & attr){
   bool key = attr.getPrimaryKey();
   bool null = attr.getNullable();
 
-  ndbout << attr.getName() << "\t";
+  ndbout << attr.getName() << " ";
   char tmp[100];
   if(attr.getLength() != 1)
     snprintf(tmp, 100," [%d]", attr.getLength());
@@ -103,16 +103,16 @@ operator <<(class NdbOut& ndbout, const NDBT_Attribute & attr){
     ndbout << "Unknown(" << type << ")";
   }
   
-  ndbout << "\t";
+  ndbout << " ";
   if(null){
     ndbout << "NULL";
   } else {
     ndbout << "NOT NULL";
   }
-  ndbout << "\t";
+  ndbout << " ";
   
   if(key)
-    ndbout << "\tprimary key";
+    ndbout << "PRIMARY KEY";
   
   return ndbout;
 }
@@ -130,6 +130,9 @@ operator <<(class NdbOut& ndbout, const NDBT_Table & tab)
   ndbout << "Temporary table: " <<  (tab.getStoredTable() ? "no" : "yes") << endl;
   ndbout << "Number of attributes: " <<  tab.getNoOfColumns() << endl;
   ndbout << "Number of primary keys: " <<  tab.getNoOfPrimaryKeys() << endl;
+  ndbout << "Length of frm data: " << tab.getFrmLength() << endl;
+
+
   //<< ((tab.getTupleKey() == TupleId) ? " tupleid" : "") <<endl;
   ndbout << "TableStatus: ";
   switch(tab.getObjectStatus()){
@@ -154,3 +157,32 @@ operator <<(class NdbOut& ndbout, const NDBT_Table & tab)
   
   return ndbout;
 }
+
+class NdbOut& operator <<(class NdbOut&, const NdbDictionary::Index & idx)
+{
+  ndbout << idx.getName();
+  ndbout << "(";
+  for (unsigned i=0; i < idx.getNoOfColumns(); i++)
+  {
+    const NdbDictionary::Column *col = idx.getColumn(i);
+    ndbout << col->getName();
+    if (i < idx.getNoOfColumns()-1)
+      ndbout << ", ";
+  }
+  ndbout << ")";
+  
+  ndbout << " - ";
+  switch (idx.getType()) {
+  case NdbDictionary::Object::UniqueHashIndex:
+    ndbout << "UniqueHashIndex";
+    break;
+  case NdbDictionary::Object::OrderedIndex:
+    ndbout << "OrderedIndex";
+    break;
+  default:
+    ndbout << "Type " << idx.getType();
+    break;
+  }
+  return ndbout;
+}
+
diff --git a/ndb/test/src/UtilTransactions.cpp b/ndb/test/src/UtilTransactions.cpp
index 2e6ff360123..3ef31a2f535 100644
--- a/ndb/test/src/UtilTransactions.cpp
+++ b/ndb/test/src/UtilTransactions.cpp
@@ -980,8 +980,8 @@ UtilTransactions::verifyIndex(Ndb* pNdb,
   }
 
   switch (pIndex->getType()){
-  case UniqueHashIndex:
-  case OrderedIndex:
+  case NdbDictionary::Index::UniqueHashIndex:
+  case NdbDictionary::Index::OrderedIndex:
     return verifyUniqueIndex(pNdb, indexName, parallelism, transactional);
     break;
   default:
diff --git a/ndb/tools/desc/desc.cpp b/ndb/tools/desc/desc.cpp
index 7481190614c..a5ff11edca9 100644
--- a/ndb/tools/desc/desc.cpp
+++ b/ndb/tools/desc/desc.cpp
@@ -19,19 +19,19 @@
 #include <NdbApi.hpp>
 
 
+
+
 int main(int argc, const char** argv){
   const char* _tabname = NULL;
   const char* _dbname = "TEST_DB";
-  int _frm = 0;
   int _unqualified = 0;
   int _help = 0;
   
   struct getargs args[] = {
-    { "unqualified", 'u', arg_integer, &_unqualified, "unqualified", 
+    { "unqualified", 'u', arg_flag, &_unqualified, "unqualified", 
       "Use unqualified table names"}, 
     { "database", 'd', arg_string, &_dbname, "dbname", 
       "Name of database table is in"},
-    { "frm-data", 'f', arg_flag, &_frm, "Show frm data for table", "" } ,
     { "usage", '?', arg_flag, &_help, "Print help", "" }
   };
   int num_args = sizeof(args) / sizeof(args[0]);
@@ -62,15 +62,40 @@ int main(int argc, const char** argv){
   NdbDictionary::Dictionary * dict = pMyNdb->getDictionary();
   for (int i = optind; i < argc; i++) {
     NDBT_Table* pTab = (NDBT_Table*)dict->getTable(argv[i]);
-    if (pTab != 0) {
+    if (pTab != 0){
       ndbout << (* pTab) << endl;
-      if (_frm){
-	ndbout << "getFrmLength: "<< endl
-	       << pTab->getFrmLength() << endl;
-	  }
-    } else {
-      ndbout << argv[i] << ": " << dict->getNdbError() << endl;
+
+      NdbDictionary::Dictionary::List list;
+      if (dict->listIndexes(list, argv[i]) != 0){
+	ndbout << argv[i] << ": " << dict->getNdbError() << endl;
+	return NDBT_ProgramExit(NDBT_FAILED);
+      }
+        
+      ndbout << "-- Indexes -- " << endl;
+      ndbout << "PRIMARY KEY(";
+      for (unsigned j= 0; j < pTab->getNoOfPrimaryKeys(); j++)
+      {
+	const NdbDictionary::Column * col = pTab->getColumn(j);
+	ndbout << col->getName();
+	if (j < pTab->getNoOfPrimaryKeys()-1)
+	  ndbout << ", ";       
+      }
+      ndbout << ") - UniqueHashIndex" << endl;
+	
+      for (unsigned j= 0; j < list.count; j++) {
+	NdbDictionary::Dictionary::List::Element& elt = list.elements[j];
+	const NdbDictionary::Index *pIdx = dict->getIndex(elt.name, argv[i]);
+	if (!pIdx){
+	  ndbout << argv[i] << ": " << dict->getNdbError() << endl;
+	  return NDBT_ProgramExit(NDBT_FAILED);
+	}
+	  
+	ndbout << (*pIdx) << endl;
+      }
+      ndbout << endl;
     }
+    else
+      ndbout << argv[i] << ": " << dict->getNdbError() << endl;
   }
   
   delete pMyNdb;