diff options
Diffstat (limited to 'ndb/include/ndbapi/NdbConnection.hpp')
| -rw-r--r-- | ndb/include/ndbapi/NdbConnection.hpp | 885 |
1 files changed, 885 insertions, 0 deletions
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp new file mode 100644 index 00000000000..a1532bb2f0e --- /dev/null +++ b/ndb/include/ndbapi/NdbConnection.hpp @@ -0,0 +1,885 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbConnection_H +#define NdbConnection_H + +#include <ndb_types.h> +#include "AttrType.hpp" +#include <NdbError.hpp> +#include <stdlib.h> + +class NdbConnection; +class NdbOperation; +class NdbCursorOperation; +class NdbScanOperation; +class NdbIndexOperation; +class NdbApiSignal; +class Ndb; +class NdbScanReceiver; + + +/** + * NdbAsynchCallback functions are used when executing asynchronous + * transactions (using NdbConnection::executeAsynchPrepare, or + * NdbConnection::executeAsynch). + * The functions are called when the execute has finished. + * See @ref secAsync for more information. + */ +typedef void (* NdbAsynchCallback)(int, NdbConnection*, void*); + +/** + * @class NdbConnection + * @brief Represents a transaction. + * + * A transaction (represented by an NdbConnection object) + * belongs to an Ndb object and is typically created using + * Ndb::startTransaction. + * A transaction consists of a list of operations + * (represented by NdbOperation objects). + * Each operation access exactly one table. + * + * After getting the NdbConnection object, + * the first step is to get (allocate) an operation given the table name. + * Then the operation is defined. + * Several operations can be defined in parallel on the same + * NdbConnection object. + * When all operations are defined, the NdbConnection::execute + * method sends them to the NDB kernel for execution. + * + * The NdbConnection::execute method returns when the NDB kernel has + * completed execution of all operations defined before the call to + * NdbConnection::execute. + * All allocated operations should be properly defined + * before calling NdbConnection::execute. + * + * A call to NdbConnection::execute uses one out of three types of execution: + * -# ExecType::NoCommit Executes operations without committing them. + * -# ExecType::Commit Executes remaining operation and commits the + * complete transaction + * -# ExecType::Rollback Rollbacks the entire transaction. + * + * NdbConnection::execute is equipped with an extra error handling parameter + * There are two alternatives: + * -# AbortOption::AbortOnError (default). + * The transaction is aborted if there are any error during the + * execution + * -# AbortOption::IgnoreError + * Continue execution of transaction even if operation fails + * + * NdbConnection::execute can sometimes indicate an error + * (return with -1) while the error code on the NdbConnection is 0. + * This is an indication that one of the operations found a record + * problem. The transaction is still ok and can continue as usual. + * The NdbConnection::execute returns -1 together with error code + * on NdbConnection object equal to 0 always means that an + * operation was not successful but that the total transaction was OK. + * By checking error codes on the individual operations it is possible + * to find out which operation was not successful. + * + * NdbConnection::executeScan is used to setup a scan in the NDB kernel + * after it has been defined. + * NdbConnection::nextScanResult is used to iterate through the + * scanned tuples. + * After each call to NdbConnection::nextScanResult, the pointers + * of NdbRecAttr objects defined in the NdbOperation::getValue + * operations are updated with the values of the new the scanned tuple. + */ + +/* FUTURE IMPLEMENTATION: + * Later a prepare mode will be added when Ndb supports Prepare-To-Commit + * The NdbConnection 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 NdbConnection::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 NdbConnection +{ + friend class Ndb; + friend class NdbOperation; + friend class NdbScanOperation; + friend class NdbIndexOperation; + friend class NdbScanReceiver; + +public: + + /** + * Get an NdbOperation for a table. + * Note that the operation has to be defined before it is executed. + * + * @note All operations within the same transaction need to + * be initialized with this method. + * + * @param aTableName The table name. + * @return Pointer to an NdbOperation object if successful, otherwise NULL. + */ + NdbOperation* getNdbOperation(const char* aTableName); + + /** + * Get an NdbOperation for index scan of a table. + * Note that the operation has to be defined before it is executed. + * + * @note All operations within the same transaction need to + * be initialized with this method. + * + * @param anIndexName The index name. + * @param aTableName The table name. + * @return Pointer to an NdbOperation object if successful, otherwise NULL. + */ + NdbOperation* getNdbOperation(const char* anIndexName, + const char* aTableName); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Get an operation from NdbScanOperation idlelist and + * get the NdbConnection object which + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object.synchronous. + * + * @param aTableName a table name. + * @return pointer to an NdbOperation object if successful, otherwise NULL + */ + NdbScanOperation* getNdbScanOperation(const char* aTableName); +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Get an operation from NdbScanOperation idlelist and + * get the NdbConnection object which + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object.synchronous. + * + * @param anIndexName The index name. + * @param aTableName a table name. + * @return pointer to an NdbOperation object if successful, otherwise NULL + */ + NdbScanOperation* getNdbScanOperation(const char* anIndexName, + const char* aTableName); +#endif + + + /** + * Get an operation from NdbIndexOperation idlelist and + * get the NdbConnection object that + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object. Synchronous. + * + * @param indexName An index name (as created by createIndex). + * @param tableName A table name. + * @return Pointer to an NdbIndexOperation object if + * successful, otherwise NULL + */ + NdbIndexOperation* getNdbIndexOperation(const char* indexName, + const char* tableName); + + /** + * @name Execute Transaction + * @{ + */ + + /** + * Executes transaction. + * + * @param execType Execution type:<br> + * ExecType::NoCommit executes operations without + * committing them.<br> + * ExecType::Commit executes remaining operations and + * commits the complete transaction.<br> + * ExecType::Rollback rollbacks the entire transaction. + * @param abortOption Handling of error while excuting + * AbortOnError - Abort transaction if an operation fail + * IgnoreError - Accept failing operations + * @param force When operations should be sent to NDB Kernel. + * (See @ref secAdapt.) + * - 0: non-force, adaptive algorithm notices it + * (default); + * - 1: force send, adaptive algorithm notices it; + * - 2: non-force, adaptive algorithm do not notice + * the send. + * @return 0 if successful otherwise -1. + */ + int execute(ExecType execType, + AbortOption abortOption = AbortOnError, + int force = 0 ); + + /** + * Prepare an asynchronous transaction. + * + * See @ref secAsync for more information on + * how to use this method. + * + * @param execType Execution type:<br> + * ExecType::NoCommit executes operations without committing them.<br> + * ExecType::Commit executes remaining operations and commits the + * complete transaction.<br> + * ExecType::Rollback rollbacks the entire transaction. + * @param callback A callback method. This method gets + * called when the transaction has been + * executed. See @ref ndbapi_example2.cpp + * for an example on how to specify and use + * a callback method. + * @param anyObject A void pointer. This pointer is forwarded to the + * callback method and can be used to give + * the callback method some data to work on. + * It is up to the application programmer + * to decide on the use of this pointer. + * @param abortOption see @ref execute + */ + void executeAsynchPrepare(ExecType execType, + NdbAsynchCallback callback, + void* anyObject, + AbortOption abortOption = AbortOnError); + + /** + * Prepare and send an asynchronous transaction. + * + * This method perform the same action as + * NdbConnection::executeAsynchPrepare + * but also sends the operations to the NDB kernel. + * + * See NdbConnection::executeAsynchPrepare for information + * about the parameters of this method. + * + * See @ref secAsync for more information on + * how to use this method. + */ + void executeAsynch(ExecType aTypeOfExec, + NdbAsynchCallback aCallback, + void* anyObject, + AbortOption abortOption = AbortOnError); + + /** + * Refresh + * Update timeout counter of this transaction + * in the database. If you want to keep the transaction + * active in the database longer than the + * transaction abort timeout. + * @note It's not advised to take a lock on a record and keep it + * for a extended time since this can impact other transactions. + * + */ + int refresh(); + + /** + * Close transaction + * @note It is not allowed to call NdbConnection::close after sending the + * transaction asynchronously before the callback method has + * been called. + * (The application should keep track of the number of + * outstanding transactions and wait until all of them + * has completed before calling NdbConnection::close). + * If the transaction is not committed it will be aborted. + */ + void close(); + + /** @} *********************************************************************/ + + /** + * @name Scan Transactions + * @{ + */ + + /** + * Execute a scan transaction. This will define + * and start the scan transaction in the NDB kernel. + * + * @return 0 if successful otherwise -1. + */ + int executeScan(); + + /** + * Get the next tuple in a scan transaction. + * + * After each call to NdbConnection::nextScanResult + * the buffers and NdbRecAttr objects defined in + * NdbOperation::getValue are updated with values + * from the scanned tuple. + * + * @param fetchAllowed If set to false, then fetching is disabled + * + * The NDB API will contact the NDB Kernel for more tuples + * when necessary to do so unless you set the fetchAllowed + * to false. + * This will force NDB to process any records it + * already has in it's caches. When there are no more cached + * records it will return 2. You must then call nextScanResult + * with fetchAllowed = true in order to contact NDB for more + * records. + * + * fetchAllowed = false is useful when you want to update or + * delete all the records fetched in one transaction(This will save a + * lot of round trip time and make updates or deletes of scanned + * records a lot faster). + * While nextScanResult(false) + * returns 0 take over the record to another transaction. When + * nextScanResult(false) returns 2 you must execute and commit the other + * transaction. This will cause the locks to be transferred to the + * other transaction, updates or deletes will be made and then the + * locks will be released. + * After that, call nextScanResult(true) which will fetch new records and + * cache them in the NdbApi. + * + * @note If you don't take over the records to another transaction the + * locks on those records will be released the next time NDB Kernel + * is contacted for more records. + * + * @note Please contact for examples of efficient scan + * updates and deletes. + * + * @return + * - -1: if unsuccessful,<br> + * - 0: if another tuple was received, and<br> + * - 1: if there are no more tuples to scan. + * - 2: if there are no more cached records in NdbApi + */ + int nextScanResult(bool fetchAllowed = true); + + /** + * Stops the scan. Used if no more tuples are wanted. + * The transaction should still be closed with + * Ndb::closeTransaction. + * + * @return 0 if successful otherwise -1. + */ + int stopScan(); + + /** + * @name Meta Information + * @{ + */ + + /** + * Get global checkpoint identity (GCI) of transaction. + * + * Each committed transaction belong to a GCI. + * The log for the committed transaction is saved on + * disk when a global checkpoint occurs. + * + * Whether or not the global checkpoint with this GCI has been + * saved on disk or not cannot be determined by this method. + * + * By comparing the GCI of a transaction with the value + * last GCI restored in a restarted NDB Cluster one can determine + * whether the transaction was restored or not. + * + * @note Global Checkpoint Identity is undefined for scan transactions + * (This is because no updates are performed in scan transactions.) + * + * @return GCI of transaction or -1 if GCI is not available. + * (Note that there has to be an NdbConnection::execute call + * with Ndb::Commit for the GCI to be available.) + */ + int getGCI(); + + /** + * Get transaction identity. + * + * @return Transaction id. + */ + Uint64 getTransactionId(); + + /** + * Returns the commit status of the transaction. + * + * @return The commit status of the transaction, i.e. one of + * { NotStarted, Started, TimeOut, Committed, Aborted, NeedAbort } + */ + CommitStatusType commitStatus(); + + /** @} *********************************************************************/ + + /** + * @name Error Handling + * @{ + */ + + /** + * Get error object with information about the latest error. + * + * @return An error object with information about the latest error. + */ + const NdbError & getNdbError() const; + + /** + * Get the latest NdbOperation which had an error. + * This method is used on the NdbConnection object to find the + * NdbOperation causing an error. + * To find more information about the + * actual error, use method NdbOperation::getNdbError + * on the returned NdbOperation object. + * + * @return The NdbOperation causing the latest error. + */ + NdbOperation* getNdbErrorOperation(); + + /** + * Get the method number where the latest error occured. + * + * @return Line number where latest error occured. + */ + int getNdbErrorLine(); + + /** + * Get completed (i.e. executed) operations of a transaction + * + * This method should only be used <em>after</em> a transaction + * has been executed. + * - NdbConnection::getNextCompletedOperation(NULL) returns the + * first NdbOperation object. + * - NdbConnection::getNextCompletedOperation(op) returns the + * NdbOperation object defined after the NdbOperation "op". + * + * This method is typically used to fetch all NdbOperation:s of + * a transaction to check for errors (use NdbOperation::getNdbError + * to fetch the NdbError object of an NdbOperation). + * + * @note This method should only be used after the transaction has been + * executed and before the transaction has been closed. + * + * @param op Operation, NULL means get first operation + * @return Operation "after" op + */ + const NdbOperation * getNextCompletedOperation(const NdbOperation * op)const; + + /** + * Release completed operations + */ + void releaseCompletedOperations(); + + + /** @} *********************************************************************/ + +private: + + 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. * + **************************************************************************/ + + NdbConnection(Ndb* aNdb); + + ~NdbConnection(); + + void init(); // Initialize connection object for new transaction + + /** + * Set Connected node id + * and sequence no + */ + void setConnectedNodeId( Uint32 nodeId, Uint32 sequence); + + Uint32 getConnectedNodeId(); // Get Connected node id + 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 + 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 + Uint32 get_send_size(); // Get size to send + void set_send_size(Uint32); // Set size to send; + + int receiveDIHNDBTAMPER(NdbApiSignal* anApiSignal); + int receiveTCSEIZECONF(NdbApiSignal* anApiSignal); + int receiveTCSEIZEREF(NdbApiSignal* anApiSignal); + int receiveTCRELEASECONF(NdbApiSignal* anApiSignal); + int receiveTCRELEASEREF(NdbApiSignal* anApiSignal); + int receiveTC_COMMITCONF(const class TcCommitConf *); + int receiveTCKEYCONF(const class TcKeyConf *, Uint32 aDataLength); + int receiveTCKEY_FAILCONF(const class TcKeyFailConf *); + int receiveTCKEY_FAILREF(NdbApiSignal* anApiSignal); + int receiveTC_COMMITREF(NdbApiSignal* anApiSignal); + int receiveTCROLLBACKCONF(NdbApiSignal* anApiSignal); // Rec TCPREPARECONF ? + int receiveTCROLLBACKREF(NdbApiSignal* anApiSignal); // Rec TCPREPAREREF ? + int receiveTCROLLBACKREP(NdbApiSignal* anApiSignal); + int receiveTCINDXCONF(const class TcIndxConf *, Uint32 aDataLength); + int receiveTCINDXREF(NdbApiSignal*); + int receiveSCAN_TABREF(NdbApiSignal*); + int receiveSCAN_TABCONF(NdbApiSignal*); + int receiveSCAN_TABINFO(NdbApiSignal*); + + int checkNextScanResultComplete(); + int sendScanStart(); + int sendScanNext(bool stopScanFlag); + int fetchNextScanResult(); + + 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(); // Operation Completed with success + int OpCompleteSuccess(); // Operation Completed with success + + void CompletedOperations(); // Move active ops to list of completed + + 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 releaseCursorOperations(NdbCursorOperation*); + + // 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 checkMagicNumber(); // Verify correct object + NdbOperation* getNdbOperation(class NdbTableImpl* aTable); + NdbScanOperation* getNdbScanOperation(class NdbTableImpl* aTable); + NdbIndexOperation* getNdbIndexOperation(class NdbIndexImpl* anIndex, + class NdbTableImpl* aTable); + + void handleExecuteCompletion(); + + /**************************************************************************** + * These are the private variables of this class. + ****************************************************************************/ + + Uint32 ptr2int(); + Uint32 theId; + + // Keeps track of what the send method should do. + 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 + NdbConnection* 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 operation in completed + // operation list. + + Uint32 theNoOfOpSent; // How many operations have been sent + Uint32 theNoOfOpCompleted; // How many operations have completed + Uint32 theNoOfOpFetched; // How many operations was actually fetched + Uint32 theNoOfSCANTABCONFRecv; // How many SCAN_TABCONF have been received + Uint32 theMyRef; // Our block reference + Uint32 theTCConPtr; // Transaction Co-ordinator connection pointer. + 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 + CommitStatusType theCommitStatus; // The commit status of the transaction + Uint32 theMagicNumber; // Magic Number to verify correct object + + Uint32 thePriority; // Transaction Priority + ReturnType theReturnStatus; // Did we have any read/update/delete failing + // to find the tuple. + bool theTransactionIsStarted; + bool theInUseState; + bool theSimpleState; + Uint8 m_abortOption; // Type of commit + + ListState theListState; + + Uint32 theDBnode; // The database node we are connected to + Uint32 theNodeSequence; // The sequence no of the db node + bool theReleaseOnClose; + + // Cursor operations + bool m_waitForReply; + NdbCursorOperation* m_theFirstCursorOperation; + NdbCursorOperation* m_theLastCursorOperation; + + NdbCursorOperation* m_firstExecutedCursorOp; + // Scan operations + bool theScanFinished; + + NdbScanReceiver* theCurrentScanRec; // The current operation to + // distribute to the app. + NdbScanReceiver* thePreviousScanRec; // The previous operation read by + // nextScanResult. + NdbOperation* theScanningOp; // The operation actually performing the scan + Uint32 theBuddyConPtr; + + static void sendTC_COMMIT_ACK(NdbApiSignal *, + Uint32 transId1, Uint32 transId2, + Uint32 aBlockRef); + + void completedFail(const char * s); +#ifdef VM_TRACE + void printState(); +#endif +}; + +inline +Uint32 +NdbConnection::get_send_size() +{ + return 0; +} + +inline +void +NdbConnection::set_send_size(Uint32 send_size) +{ + return; +} + +inline +int +NdbConnection::checkMagicNumber() +{ + if (theMagicNumber == 0x37412619) + return 0; + else { +#ifdef NDB_NO_DROPPED_SIGNAL + abort(); +#endif + return -1; + } +} + +/************************************************************************************************ +void setTransactionId(Uint64 aTransactionId); + +Remark: Set the transaction identity. +************************************************************************************************/ +inline +void +NdbConnection::setTransactionId(Uint64 aTransactionId) +{ + theTransactionId = aTransactionId; +} + +inline +void +NdbConnection::setConnectedNodeId(Uint32 aNode, Uint32 aSequenceNo) +{ + theDBnode = aNode; + theNodeSequence = aSequenceNo; +} +/****************************************************************************** +int getConnectedNodeId(); + +Return Value: Return theDBnode. +Remark: Get Connected node id. +******************************************************************************/ +inline +Uint32 +NdbConnection::getConnectedNodeId() +{ + return theDBnode; +} +/****************************************************************************** +void setMyBlockReference(int aBlockRef); + +Parameters: aBlockRef: The block refrerence. +Remark: Set my block refrerence. +******************************************************************************/ +inline +void +NdbConnection::setMyBlockReference(int aBlockRef) +{ + theMyRef = aBlockRef; +} +/****************************************************************************** +void setTC_ConnectPtr(Uint32 aTCConPtr); + +Parameters: aTCConPtr: The connection pointer. +Remark: Sets TC Connect pointer. +******************************************************************************/ +inline +void +NdbConnection::setTC_ConnectPtr(Uint32 aTCConPtr) +{ + theTCConPtr = aTCConPtr; +} + +/****************************************************************************** +int getTC_ConnectPtr(); + +Return Value: Return theTCConPtr. +Remark: Gets TC Connect pointer. +******************************************************************************/ +inline +int +NdbConnection::getTC_ConnectPtr() +{ + return theTCConPtr; +} + +inline +void +NdbConnection::setBuddyConPtr(Uint32 aBuddyConPtr) +{ + theBuddyConPtr = aBuddyConPtr; +} + +inline +Uint32 NdbConnection::getBuddyConPtr() +{ + return theBuddyConPtr; +} + +/****************************************************************************** +NdbConnection* next(); + +inline +void +NdbConnection::setBuddyConPtr(Uint32 aBuddyConPtr) +{ + theBuddyConPtr = aBuddyConPtr; +} + +inline +Uint32 NdbConnection::getBuddyConPtr() +{ + return theBuddyConPtr; +} + +Return Value: Return next pointer to NdbConnection object. +Remark: Get the next pointer. +******************************************************************************/ +inline +NdbConnection* +NdbConnection::next() +{ + return theNext; +} + +/****************************************************************************** +void next(NdbConnection aConnection); + +Parameters: aConnection: The connection object. +Remark: Sets the next pointer. +******************************************************************************/ +inline +void +NdbConnection::next(NdbConnection* aConnection) +{ + theNext = aConnection; +} + +/****************************************************************************** +ConStatusType Status(); + +Return Value Return the ConStatusType. +Parameters: aStatus: The status. +Remark: Sets Connect status. +******************************************************************************/ +inline +ConStatusType +NdbConnection::Status() +{ + return theStatus; +} + +/****************************************************************************** +void Status(ConStatusType aStatus); + +Parameters: aStatus: The status. +Remark: Sets Connect status. +******************************************************************************/ +inline +void +NdbConnection::Status( ConStatusType aStatus ) +{ + theStatus = aStatus; +} + +/****************************************************************************** + void setGCI(); + +Remark: Set global checkpoint identity of the transaction +******************************************************************************/ +inline +void +NdbConnection::setGCI(int aGlobalCheckpointId) +{ + theGlobalCheckpointId = aGlobalCheckpointId; +} + +/****************************************************************************** +void OpSent(); + +Remark: An operation was sent with success that expects a response. +******************************************************************************/ +inline +void +NdbConnection::OpSent() +{ + theNoOfOpSent++; +} + +inline +Uint32 +NdbConnection::ptr2int(){ + return theId; +} + +#endif + + |