mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-22 14:54:20 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/ndb/include/ndbapi/NdbConnection.hpp

884 lines
30 KiB
C++
Raw Blame History

/* 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>
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
Reference in a new issue View git blame Copy permalink