NdbTransaction.hpp

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

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

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

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

#ifndef NdbTransaction_H
#define NdbTransaction_H

#include <ndb_types.h>
#include "NdbError.hpp"
#include "NdbDictionary.hpp"
#include "Ndb.hpp"
#include "NdbOperation.hpp"
#include "NdbIndexScanOperation.hpp"

class NdbTransaction;
class NdbScanOperation;
class NdbIndexScanOperation;
class NdbIndexOperation;
class NdbApiSignal;
class Ndb;
class NdbBlob;
class NdbInterpretedCode;
class NdbQueryImpl;
class NdbQueryDef;
class NdbQuery;
class NdbQueryParamValue;
class NdbLockHandle;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
// to be documented later
typedef void (* NdbAsynchCallback)(int, NdbTransaction*, void*);
#endif

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
enum AbortOption {
  DefaultAbortOption = NdbOperation::DefaultAbortOption,
  CommitIfFailFree = NdbOperation::AbortOnError,         
  TryCommit = NdbOperation::AbortOnError,
  AbortOnError= NdbOperation::AbortOnError,
  CommitAsMuchAsPossible = NdbOperation::AO_IgnoreError,
  AO_IgnoreError= NdbOperation::AO_IgnoreError
};
enum ExecType { 
  NoExecTypeDef = -1,
  Prepare,
  NoCommit,
  Commit,
  Rollback
};
#endif

/* FUTURE IMPLEMENTATION:
 * Later a prepare mode will be added when Ndb supports Prepare-To-Commit
 * The NdbTransaction can deliver the Transaction Id of the transaction.
 * After committing a transaction it is also possible to retrieve the 
 * global transaction checkpoint which the transaction was put in.
 *
 * FUTURE IMPLEMENTATION:
 * There are three methods for acquiring the NdbOperation. 
 * -# The first method is the normal where a table name is
 *    provided. In this case the primary key must be supplied through
 *    the use of the NdbOperation::equal methods on the NdbOperation object.
 * -# The second method provides the tuple identity of the tuple to be
 *    read.  The tuple identity contains a table identifier and will
 *    thus be possible to use to ensure the attribute names provided
 *    are correct.  If an object-oriented layer is put on top of NDB
 *    Cluster it is essential that all tables derived from a base
 *    class has the same attributes with the same type and the same
 *    name. Thus the application can use the tuple identity and need
 *    not known the table of the tuple.  As long as the table is
 *    derived from the known base class everything is ok.
 *    It is not possible to provide any primary key since it is 
 *    already supplied with the call to NdbTransaction::getNdbOperation. 
 * -# The third method is used when a scanned tuple is to be transferred to 
 *    another transaction. In this case it is not possible to define the 
 *    primary key since it came along from the scanned tuple.
 *
 */

class NdbRecord;

class NdbTransaction
{
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
  friend class Ndb;
  friend class NdbOperation;
  friend class NdbScanOperation;
  friend class NdbIndexOperation;
  friend class NdbIndexScanOperation;
  friend class NdbBlob;
  friend class ha_ndbcluster;
  friend class NdbQueryImpl;
  friend class NdbQueryOperationImpl;
#endif

public:
#ifdef NDBAPI_50_COMPAT
  enum AbortOption {
    DefaultAbortOption = NdbOperation::DefaultAbortOption,
    CommitIfFailFree = NdbOperation::AbortOnError,         
    TryCommit = NdbOperation::AbortOnError,
    AbortOnError= NdbOperation::AbortOnError,
    CommitAsMuchAsPossible = NdbOperation::AO_IgnoreError,
    AO_IgnoreError= NdbOperation::AO_IgnoreError
  };
#endif


  enum ExecType {
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    NoExecTypeDef=
    ::NoExecTypeDef,            
    Prepare= ::Prepare,         
#endif
    NoCommit=                   

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    ::NoCommit
#endif
    ,Commit=                    
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    ::Commit
#endif
    ,Rollback                   
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    = ::Rollback
#endif
  };

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  Ndb * getNdb() { 
    return theNdb; 
  }
#endif

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  NdbOperation* getNdbOperation(const char* aTableName);
#endif

  NdbOperation* getNdbOperation(const NdbDictionary::Table * aTable);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  NdbScanOperation* getNdbScanOperation(const char* aTableName);
#endif

  NdbScanOperation* getNdbScanOperation(const NdbDictionary::Table * aTable);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  NdbIndexScanOperation* getNdbIndexScanOperation(const char* anIndexName,
                                                  const char* aTableName);
  NdbIndexScanOperation* getNdbIndexScanOperation
  (const NdbDictionary::Index *anIndex, const NdbDictionary::Table *aTable);
#endif
  
  NdbIndexScanOperation* getNdbIndexScanOperation
  (const NdbDictionary::Index *anIndex);
  
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  NdbIndexOperation* getNdbIndexOperation(const char*  anIndexName,
                                          const char*  aTableName);
  NdbIndexOperation* getNdbIndexOperation(const NdbDictionary::Index *anIndex,
                                          const NdbDictionary::Table *aTable);
#endif

  NdbIndexOperation* getNdbIndexOperation(const NdbDictionary::Index *anIndex);

#ifndef NDBAPI_50_COMPAT
  int execute(ExecType execType,
              NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
              int force = 0 );
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
  int execute(::ExecType execType,
              ::AbortOption abortOption = ::DefaultAbortOption,
              int force = 0 ) {
    return execute ((ExecType)execType,
                    (NdbOperation::AbortOption)abortOption,
                    force); }
#endif
#else

  int execute(ExecType execType, NdbOperation::AbortOption, int force);
  
  int execute(NdbTransaction::ExecType execType,
              NdbTransaction::AbortOption abortOption = AbortOnError,
              int force = 0) 
    {
      int ret = execute ((ExecType)execType,
                         (NdbOperation::AbortOption)abortOption,
                         force); 
      if (ret || (abortOption != AO_IgnoreError && theError.code))
        return -1;
      return 0;
    }
#endif

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
  // to be documented later
#ifndef NDBAPI_50_COMPAT
  void executeAsynchPrepare(ExecType          execType,
                            NdbAsynchCallback callback,
                            void*             anyObject,
                            NdbOperation::AbortOption = NdbOperation::DefaultAbortOption);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
  void executeAsynchPrepare(::ExecType       execType,
                            NdbAsynchCallback callback,
                            void*             anyObject,
                            ::AbortOption ao = ::DefaultAbortOption) {
    executeAsynchPrepare((ExecType)execType, callback, anyObject,
                         (NdbOperation::AbortOption)ao); }
#endif
#else

  void executeAsynchPrepare(ExecType          execType,
                            NdbAsynchCallback callback,
                            void*             anyObject,
                            NdbOperation::AbortOption);

  void executeAsynchPrepare(NdbTransaction::ExecType execType,
                            NdbAsynchCallback callback,
                            void *anyObject,
                            NdbTransaction::AbortOption abortOption = NdbTransaction::AbortOnError)
    {
      executeAsynchPrepare((ExecType)execType, callback, anyObject,
                           (NdbOperation::AbortOption)abortOption);
    }
#endif

#ifndef NDBAPI_50_COMPAT
  void executeAsynch(ExecType            aTypeOfExec,
                     NdbAsynchCallback   aCallback,
                     void*               anyObject,
                     NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
                     int forceSend= 0);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
  void executeAsynch(::ExecType         aTypeOfExec,
                     NdbAsynchCallback   aCallback,
                     void*               anyObject,
                     ::AbortOption abortOption= ::DefaultAbortOption,
                     int forceSend= 0)
  { executeAsynch((ExecType)aTypeOfExec, aCallback, anyObject,
                  (NdbOperation::AbortOption)abortOption, forceSend); }
#endif
#else

  void executeAsynch(ExecType            aTypeOfExec,
                     NdbAsynchCallback   aCallback,
                     void*               anyObject,
                     NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
                     int forceSend= 0);
  void executeAsynch(NdbTransaction::ExecType aTypeOfExec,
                     NdbAsynchCallback aCallback,
                     void* anyObject,
                     NdbTransaction::AbortOption abortOption = AbortOnError)
    {
      executeAsynch((ExecType)aTypeOfExec, aCallback, anyObject,
                    (NdbOperation::AbortOption)abortOption, 0);
    }
#endif
#endif

  int refresh();

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

#endif
  void close();

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  int restart();
#endif

  int getGCI(Uint64 * gciptr);

  int getGCI();
                        
  Uint64        getTransactionId();

  enum CommitStatusType { 
    NotStarted,                   
    Started,                      
    Committed,                    
    Aborted,                      
    NeedAbort                     
  };

  CommitStatusType commitStatus();

  const NdbError & getNdbError() const;

  NdbOperation* getNdbErrorOperation();

  const NdbOperation* getNdbErrorOperation() const;

  int getNdbErrorLine();

  const NdbOperation * getNextCompletedOperation(const NdbOperation * op)const;

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
  const NdbOperation* getFirstDefinedOperation()const{return theFirstOpInList;}
  const NdbOperation* getLastDefinedOperation()const{return theLastOpInList;}

  int executePendingBlobOps(Uint8 flags = 0xFF);

  Uint32 getConnectedNodeId(); // Get Connected node id
#endif

  /*
   * NdbRecord primary key and unique key operations.
   *
   * If the key_rec passed in is for a table, the operation will be a primary
   * key operation. If it is for an index, it will be a unique key operation
   * using that index.
   *
   * The key_row passed in defines the primary or unique key of the affected
   * tuple, and must remain valid until execute() is called. The key_rec must
   * include all columns of the key.
   *
   * The mask, if != NULL, defines a subset of attributes to read, update, or
   * insert. Only if (mask[attrId >> 3] & (1<<(attrId & 7))) is set is the
   * column affected. The mask is copied by the methods, so need not remain
   * valid after the call returns.
   *
   * For unique index operations, the attr_rec must refer to the underlying
   * table of the index.
   *
   * OperationOptions can be used to give finer-grained control of operation
   * definition.  An OperationOptions structure is passed with flags
   * indicating which operation definition options are present.  Not all
   * operation types support all operation options.  See the definition of
   * the OperationOptions structure for more information on individual options.
   *
   *   Operation type        Supported OperationOptions flags
   *   --------------        --------------------------------
   *   readTuple             OO_ABORTOPTION, OO_GETVALUE,
   *                         OO_PARTITION_ID, OO_INTERPRETED
   *   insertTuple           OO_ABORTOPTION, OO_SETVALUE, 
   *                         OO_PARTITION_ID, OO_ANYVALUE
   *   updateTuple           OO_ABORTOPTION, OO_SETVALUE,
   *                         OO_PARTITION_ID, OO_INTERPRETED,
   *                         OO_ANYVALUE
   *   writeTuple            OO_ABORTOPTION, OO_SETVALUE,
   *                         OO_PARTITION_ID, OO_ANYVALUE
   *   deleteTuple           OO_ABORTOPTION, OO_GETVALUE,
   *                         OO_PARTITION_ID, OO_INTERPRETED,
   *                         OO_ANYVALUE
   *
   * The sizeOfOptions optional parameter is used to allow this interface
   * to be backwards compatible with previous definitions of the OperationOptions
   * structure.  If an unusual size is detected by the interface implementation, 
   * it can use this to determine how to interpret the passed OperationOptions 
   * structure.  To enable this functionality, the caller should pass 
   * sizeof(NdbOperation::OperationOptions) for this argument.
   */
  const NdbOperation *readTuple(const NdbRecord *key_rec, const char *key_row,
                                const NdbRecord *result_rec, char *result_row,
                                NdbOperation::LockMode lock_mode= NdbOperation::LM_Read,
                                const unsigned char *result_mask= 0,
                                const NdbOperation::OperationOptions *opts = 0,
                                Uint32 sizeOfOptions = 0);
  const NdbOperation *insertTuple(const NdbRecord *key_rec, const char *key_row,
                                  const NdbRecord *attr_rec, const char *attr_row,
                                  const unsigned char *mask= 0,
                                  const NdbOperation::OperationOptions *opts = 0,
                                  Uint32 sizeOfOptions = 0);
  const NdbOperation *insertTuple(const NdbRecord *combined_rec, const char *combined_row,
                                  const unsigned char *mask = 0,
                                  const NdbOperation::OperationOptions *opts = 0,
                                  Uint32 sizeOfOptions = 0);
  const NdbOperation *updateTuple(const NdbRecord *key_rec, const char *key_row,
                                  const NdbRecord *attr_rec, const char *attr_row,
                                  const unsigned char *mask= 0,
                                  const NdbOperation::OperationOptions *opts = 0,
                                  Uint32 sizeOfOptions = 0);
  const NdbOperation *writeTuple(const NdbRecord *key_rec, const char *key_row,
                                 const NdbRecord *attr_rec, const char *attr_row,
                                 const unsigned char *mask= 0,
                                 const NdbOperation::OperationOptions *opts = 0,
                                 Uint32 sizeOfOptions = 0);
  const NdbOperation *deleteTuple(const NdbRecord *key_rec, const char *key_row,
                                  const NdbRecord *result_rec, char *result_row = 0,
                                  const unsigned char *result_mask = 0,
                                  const NdbOperation::OperationOptions *opts = 0,
                                  Uint32 sizeOfOptions = 0);

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
  const NdbOperation *refreshTuple(const NdbRecord *key_rec, const char *key_row,
                                   const NdbOperation::OperationOptions *opts = 0,
                                   Uint32 sizeOfOptions = 0);
#endif

  NdbScanOperation *
  scanTable(const NdbRecord *result_record,
            NdbOperation::LockMode lock_mode= NdbOperation::LM_Read,
            const unsigned char *result_mask= 0,
            const NdbScanOperation::ScanOptions *options = 0,
            Uint32 sizeOfOptions = 0);

  NdbIndexScanOperation *
  scanIndex(const NdbRecord *key_record,
            const NdbRecord *result_record,
            NdbOperation::LockMode lock_mode = NdbOperation::LM_Read,
            const unsigned char *result_mask = 0,
            const NdbIndexScanOperation::IndexBound *bound = 0,
            const NdbScanOperation::ScanOptions *options = 0,
            Uint32 sizeOfOptions = 0);

  NdbQuery*
  createQuery(const NdbQueryDef* query,
              const NdbQueryParamValue paramValue[]= 0,
              NdbOperation::LockMode lock_mode= NdbOperation::LM_Read);

  /* LockHandle methods */
  /*
   * Shared or Exclusive locks taken by read operations in a transaction
   * are normally held until the transaction commits or aborts.
   * Shared or Exclusive *read* locks can be released before transaction
   * commit or abort time by requesting a LockHandle when defining the
   * read operation.  Any time after the read operation has been executed,
   * the LockHandle can be used to create a new Unlock operation.  When
   * the Unlock operation is executed, the row lock placed by the read
   * operation will be released.
   * 
   * The steps are :
   *  1) Define the primary key read operation in the normal way
   *     with lockmode LM_Read or LM_Exclusive
   *
   *  2) Call NdbOperation::getLockHandle() during operation definition
   *     (Or set the OO_LOCKHANDLE operation option when calling
   *      NdbTransaction::readTuple() for NdbRecord)
   *  
   *  3) Call NdbTransaction::execute()
   *                         (Row will be locked from here as normal)
   *  
   *  4) Use the read data, make zero or more calls to 
   *     NdbTransaction::execute() etc.
   *  
   *  5) Call NdbTransaction::unlock(NdbLockHandle*), passing in the
   *     const LockHandle* from 2) to create an Unlock operation.
   *  
   *  6) Call NdbTransaction::execute()
   *                         (Row will be unlocked from here)
   * 
   * Notes
   * - As with other operation types, Unlock operations can be batched.
   * - Each LockHandle object refers to a lock placed on a row by a single 
   *   primary key read operation.  A single row in the database may have 
   *   concurrent multiple lock holders (of mode LM_Read) and may have 
   *   multiple lock holders pending (LM_Exclusive), so releasing the
   *   claim of one lock holder may not result in a change to the 
   *   observable lock status of the row.
   * - LockHandles are supported for Scan lock takeover operations - the
   *   lockhandle must be requested before the locktakeover is executed.
   * - LockHandles and Unlock operations are not supported for Unique Index
   *   read operations.
   */

  /* unlock
   * 
   * This method creates an Unlock operation on the current transaction.
   * When executed, the Unlock operation will remove the lock referenced
   * by the passed LockHandle.
   * 
   * The unlock operation can fail, for example due to the row being 
   * unlocked already.  In this scenario, the AbortOption specifies how 
   * this will be handled.
   * The default is that errors will cause transaction abort.
   */
  const NdbOperation* unlock(const NdbLockHandle* lockHandle,
                             NdbOperation::AbortOption ao = NdbOperation::DefaultAbortOption);
  
  /* releaseLockHandle
   * This method is used to release a LockHandle object once it
   * is no longer required.
   * For NdbRecord primary key read operations, this cannot be
   * called until the associated read operation has executed.
   * All LockHandles associated with a transaction are released
   * when it is closed.
   */
  int releaseLockHandle(const NdbLockHandle* lockHandle);

  /* Get maximum number of pending Blob read/write bytes before
   * an automatic execute() occurs 
   */
  Uint32 getMaxPendingBlobReadBytes() const;
  Uint32 getMaxPendingBlobWriteBytes() const;

  /* Set maximum number of pending Blob read/write bytes before
   * an automatic execute() occurs
   */
  void setMaxPendingBlobReadBytes(Uint32 bytes);
  void setMaxPendingBlobWriteBytes(Uint32 bytes);

private:                                                
  void releaseCompletedOperations();
  void releaseCompletedQueries();

  typedef Uint64 TimeMillis_t;
  /**************************************************************************
   *    These methods are service methods to other classes in the NDBAPI.   *
   **************************************************************************/
 
  /**************************************************************************
   *    These are the create and delete methods of this class.              *
   **************************************************************************/
  NdbTransaction(Ndb* aNdb); 
  ~NdbTransaction();

  int init();           // Initialize connection object for new transaction

  int executeNoBlobs(ExecType execType, 
                     NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
                     int force = 0 );
  
  void setConnectedNodeId( Uint32 nodeId, Uint32 sequence); 

  void          setMyBlockReference( int );       // Set my block refrerence
  void          setTC_ConnectPtr( Uint32 );       // Sets TC Connect pointer
  int           getTC_ConnectPtr();               // Gets TC Connect pointer
  void          setBuddyConPtr(Uint32);           // Sets Buddy Con Ptr
  Uint32        getBuddyConPtr();                 // Gets Buddy Con Ptr
  NdbTransaction* next();                         // Returns the next pointer
  void          next(NdbTransaction*);            // Sets the next pointer

  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;
  
  int  receiveTCSEIZECONF(const NdbApiSignal* anApiSignal);
  int  receiveTCSEIZEREF(const NdbApiSignal* anApiSignal);
  int  receiveTCRELEASECONF(const NdbApiSignal* anApiSignal);
  int  receiveTCRELEASEREF(const NdbApiSignal* anApiSignal);
  int  receiveTC_COMMITCONF(const class TcCommitConf *, Uint32 len);
  int  receiveTCKEYCONF(const class TcKeyConf *, Uint32 aDataLength);
  int  receiveTCKEY_FAILCONF(const class TcKeyFailConf *);
  int  receiveTCKEY_FAILREF(const NdbApiSignal* anApiSignal);
  int  receiveTC_COMMITREF(const NdbApiSignal* anApiSignal);
  int  receiveTCROLLBACKCONF(const NdbApiSignal* anApiSignal);
  int  receiveTCROLLBACKREF(const NdbApiSignal* anApiSignal);
  int  receiveTCROLLBACKREP(const NdbApiSignal* anApiSignal);
  int  receiveTCINDXREF(const NdbApiSignal*);
  int  receiveSCAN_TABREF(const NdbApiSignal*);
  int  receiveSCAN_TABCONF(const NdbApiSignal*, const Uint32*, Uint32 len);

  int   doSend();                       // Send all operations
  int   sendROLLBACK();                 // Send of an ROLLBACK
  int   sendTC_HBREP();                 // Send a TCHBREP signal;
  int   sendCOMMIT();                   // Send a TC_COMMITREQ signal;
  void  setGCI(int GCI);                // Set the global checkpoint identity
 
  int   OpCompleteFailure();
  int   OpCompleteSuccess();
 
  void  OpSent();                       // Operation Sent with success
  
  // Free connection related resources and close transaction
  void          release();              

  // Release all operations in connection
  void          releaseOperations();    

  // Release all cursor operations in connection
  void releaseOps(NdbOperation*);       
  void releaseQueries(NdbQueryImpl*);
  void releaseScanOperations(NdbIndexScanOperation*);   
  bool releaseScanOperation(NdbIndexScanOperation** listhead,
                            NdbIndexScanOperation** listtail,
                            NdbIndexScanOperation* op);
  void          releaseLockHandles();
  
  // Set the transaction identity of the transaction
  void          setTransactionId(Uint64 aTransactionId);

  // Indicate something went wrong in the definition phase
  void          setErrorCode(int anErrorCode);          

  // Indicate something went wrong in the definition phase
  void          setOperationErrorCode(int anErrorCode); 

  // Indicate something went wrong in the definition phase
  void          setOperationErrorCodeAbort(int anErrorCode, int abortOption = -1);

  int           checkMagicNumber();                    // Verify correct object
  NdbOperation* getNdbOperation(const class NdbTableImpl* aTable,
                                NdbOperation* aNextOp = 0,
                                bool useRec= false);

  NdbIndexScanOperation* getNdbScanOperation(const class NdbTableImpl* aTable);
  NdbIndexOperation* getNdbIndexOperation(const class NdbIndexImpl* anIndex, 
                                          const class NdbTableImpl* aTable,
                                          NdbOperation* aNextOp = 0,
                                          bool useRec= false);
  NdbIndexScanOperation* getNdbIndexScanOperation(const NdbIndexImpl* index,
                                                  const NdbTableImpl* table);
  
  NdbOperation *setupRecordOp(NdbOperation::OperationType type,
                              NdbOperation::LockMode lock_mode,
                              NdbOperation::AbortOption default_ao,
                              const NdbRecord *key_record,
                              const char *key_row,
                              const NdbRecord *attribute_record,
                              const char *attribute_row,
                              const unsigned char *mask,
                              const NdbOperation::OperationOptions *opts,
                              Uint32 sizeOfOptions,
                              const NdbLockHandle* lh = 0);

  void          handleExecuteCompletion();
  
  /****************************************************************************
   * These are the private variables of this class.
   ****************************************************************************/

  Uint32 ptr2int();
  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
  Uint32             theTransArrayIndex;     // Current index in a transaction 
                                             // array for this object
  TimeMillis_t       theStartTransTime;      // Start time of the transaction

  NdbError theError;            // Errorcode on transaction
  int      theErrorLine;        // Method number of last error in NdbOperation
  NdbOperation* theErrorOperation; // The NdbOperation where the error occurred

  Ndb*          theNdb;                      // Pointer to Ndb object      
  NdbTransaction* theNext;                   // Next pointer. Used in idle list.

  NdbOperation* theFirstOpInList;           // First operation in defining list.
  NdbOperation* theLastOpInList;            // Last operation in defining list.

  NdbOperation* theFirstExecOpInList;       // First executing operation in list
  NdbOperation* theLastExecOpInList;        // Last executing operation in list.


  NdbOperation* theCompletedFirstOp;        // First & last operation in completed 
  NdbOperation* theCompletedLastOp;         // operation list.

  Uint32        theNoOfOpSent;                          // How many operations have been sent       
  Uint32        theNoOfOpCompleted;                     // How many operations have completed
  Uint32        theMyRef;                               // Our block reference          
  Uint32        theTCConPtr;                            // Transaction Co-ordinator connection pointer.
  Uint64        theTransactionId;                       // theTransactionId of the transaction
  Uint64        theGlobalCheckpointId;                  // The gloabl checkpoint identity of the transaction
  Uint64 *p_latest_trans_gci;                           // Reference to latest gci for connection
  ConStatusType theStatus;                              // The status of the connection         
  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
                                                        // Current meanings :
                                                        //   0x00FE11DC : NdbTransaction not in use
                                                        //   0x37412619 : NdbTransaction in use
                                                        //   0x00FE11DF : NdbTransaction for scan operation
                                                        //                scan definition not yet complete
  Uint32        thePriority;                            // Transaction Priority

  enum ReturnType {  ReturnSuccess,  ReturnFailure };
  ReturnType    theReturnStatus;                        // Did we have any read/update/delete failing
                                                        // to find the tuple.
  bool theTransactionIsStarted; 
  bool theInUseState;
  bool theSimpleState;

  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
  bool theReleaseOnClose;

  Uint32 m_db_nodes[2];
  Uint32 m_failed_db_nodes[2];
  
  int report_node_failure(Uint32 id);

  // Scan operations
  bool m_waitForReply;     
  NdbIndexScanOperation* m_theFirstScanOperation;
  NdbIndexScanOperation* m_theLastScanOperation;
  
  NdbIndexScanOperation* m_firstExecutedScanOp;

  // Scan operations or queries:
  // The operation or query actually performing the scan.
  // (Only one of theScanningOp/m_scanningQuery be non-NULL,
  //  which indirectly indicates the type)
  NdbScanOperation* theScanningOp;

  Uint32 theBuddyConPtr;
  // optim: any blobs
  bool theBlobFlag;
  Uint8 thePendingBlobOps;
  Uint32 maxPendingBlobReadBytes;
  Uint32 maxPendingBlobWriteBytes;
  Uint32 pendingBlobReadBytes;
  Uint32 pendingBlobWriteBytes;
  inline bool hasBlobOperation() { return theBlobFlag; }

  static void sendTC_COMMIT_ACK(class NdbImpl *, NdbApiSignal *,
                                Uint32 transId1, Uint32 transId2, 
                                Uint32 aBlockRef);

  void completedFail(const char * s);
#ifdef VM_TRACE
  void printState();
#endif
  bool checkState_TransId(const Uint32 * transId) const;

  void remove_list(NdbOperation*& head, NdbOperation*);
  void define_scan_op(NdbIndexScanOperation*);

  NdbLockHandle* m_theFirstLockHandle;
  NdbLockHandle* m_theLastLockHandle;

  NdbLockHandle* getLockHandle();

  friend class HugoOperations;
  friend struct Ndb_free_list_t<NdbTransaction>;

  NdbTransaction(const NdbTransaction&); // Not impl.
  NdbTransaction&operator=(const NdbTransaction&);

  // Query operation (aka multicursor)
  NdbQueryImpl* m_firstQuery;        // First query in defining list.
  NdbQueryImpl* m_firstExecQuery;    // First query to send for execution
  NdbQueryImpl* m_firstActiveQuery;  // First query actively executing, or completed

  // Scan operations or queries:
  // The operation or query actually performing the scan.
  // (Only one of theScanningOp/m_scanningQuery be non-NULL,
  //  which indirectly indicates the type)
  NdbQueryImpl* m_scanningQuery;

  Uint32 m_tcRef;
};

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

inline
Uint32
NdbTransaction::get_send_size()
{
  return 0;
}

inline
void
NdbTransaction::set_send_size(Uint32 send_size)
{
  (void)send_size; //unused
  return;
}

#ifdef NDB_NO_DROPPED_SIGNAL
#include <stdlib.h>
#endif

inline
int
NdbTransaction::checkMagicNumber()
{
  if (theMagicNumber == 0x37412619)
    return 0;
  else {
#ifdef NDB_NO_DROPPED_SIGNAL
    abort();
#endif
    return -1;
  }
}

inline
bool
NdbTransaction::checkState_TransId(const Uint32 * transId) const {
  const Uint32 tTmp1 = transId[0];
  const Uint32 tTmp2 = transId[1];
  Uint64 tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
  bool b = theStatus == Connected && theTransactionId == tRecTransId;
  return b;
}

/************************************************************************************************
void setTransactionId(Uint64 aTransactionId);

Remark:        Set the transaction identity. 
************************************************************************************************/
inline
void
NdbTransaction::setTransactionId(Uint64 aTransactionId)
{
  theTransactionId = aTransactionId;
}

inline
void                    
NdbTransaction::setConnectedNodeId(Uint32 aNode, Uint32 aSequenceNo)
{
  theDBnode = aNode;
  theNodeSequence = aSequenceNo;
}       
/******************************************************************************
int getConnectedNodeId();

Return Value:   Return  theDBnode.
Remark:         Get Connected node id. 
******************************************************************************/
inline
Uint32                  
NdbTransaction::getConnectedNodeId()
{
  return theDBnode;
}       
/******************************************************************************
void setMyBlockReference(int aBlockRef);

Parameters:     aBlockRef: The block refrerence.
Remark:         Set my block refrerence. 
******************************************************************************/
inline
void                    
NdbTransaction::setMyBlockReference(int aBlockRef)      
{
  theMyRef = aBlockRef;
}
/******************************************************************************
void  setTC_ConnectPtr(Uint32 aTCConPtr);

Parameters:     aTCConPtr: The connection pointer.
Remark:         Sets TC Connect pointer. 
******************************************************************************/
inline
void                    
NdbTransaction::setTC_ConnectPtr(Uint32 aTCConPtr)
{
  theTCConPtr = aTCConPtr;
}

/******************************************************************************
int  getTC_ConnectPtr();

Return Value:   Return  theTCConPtr.
Remark:         Gets TC Connect pointer. 
******************************************************************************/
inline
int                     
NdbTransaction::getTC_ConnectPtr()
{
  return theTCConPtr;
}

inline
void
NdbTransaction::setBuddyConPtr(Uint32 aBuddyConPtr)
{
  theBuddyConPtr = aBuddyConPtr;
}

inline
Uint32 NdbTransaction::getBuddyConPtr()
{
  return theBuddyConPtr;
}

/******************************************************************************
NdbTransaction* next();

inline
void
NdbTransaction::setBuddyConPtr(Uint32 aBuddyConPtr)
{
  theBuddyConPtr = aBuddyConPtr;
}

inline
Uint32 NdbTransaction::getBuddyConPtr()
{
  return theBuddyConPtr;
}

Return Value:   Return  next pointer to NdbTransaction object.
Remark:         Get the next pointer. 
******************************************************************************/
inline
NdbTransaction*
NdbTransaction::next()
{
  return theNext;
}

/******************************************************************************
void next(NdbTransaction aTransaction);

Parameters:     aTransaction: The connection object. 
Remark:         Sets the next pointer. 
******************************************************************************/
inline
void
NdbTransaction::next(NdbTransaction* aTransaction)
{
  theNext = aTransaction;
}

/******************************************************************************
ConStatusType  Status();

Return Value    Return the ConStatusType.       
Parameters:     aStatus:  The status.
Remark:         Sets Connect status. 
******************************************************************************/
inline
NdbTransaction::ConStatusType                   
NdbTransaction::Status()
{
  return theStatus;
}

/******************************************************************************
void  Status(ConStatusType aStatus);

Parameters:     aStatus: The status.
Remark:         Sets Connect status. 
******************************************************************************/
inline
void                    
NdbTransaction::Status( ConStatusType aStatus )
{
  theStatus = aStatus;
}


/******************************************************************************
void OpSent();

Remark:       An operation was sent with success that expects a response.
******************************************************************************/
inline
void 
NdbTransaction::OpSent()
{
  theNoOfOpSent++;
}

/******************************************************************************
void executePendingBlobOps();
******************************************************************************/
inline
int
NdbTransaction::executePendingBlobOps(Uint8 flags)
{
  if (thePendingBlobOps & flags) {
    // not executeNoBlobs because there can be new ops with blobs
    return execute(NoCommit);
  }
  return 0;
}

inline
Uint32
NdbTransaction::ptr2int(){
  return theId;
}

typedef NdbTransaction NdbConnection;

#endif // ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

#endif