1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge perch.ndb.mysql.com:/home/jonas/src/mysql-4.1

Browse Source 
into  perch.ndb.mysql.com:/home/jonas/src/mysql-4.1-push
This commit is contained in:
unknown 2005-09-17 10:05:07 +02:00
commit f12f98e226
25 changed files with 374 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
ndb/include/ndbapi/Ndb.hpp
View File

@ -882,10 +882,10 @@ class BaseString;
class NdbEventOperation;
class NdbBlob;
class NdbReceiver;
template <class T> struct Ndb_free_list_t;
typedef void (* NdbEventCallback)(NdbEventOperation*, Ndb*, void*);
#if defined NDB_OSE
/**
* Default time to wait for response after request has been sent to
@ -1386,8 +1386,20 @@ public:
*/
NdbConnection* hupp( NdbConnection* );
Uint32 getReference() const { return theMyRef;}
struct Free_list_usage
{
const char * m_name;
Uint32 m_created;
Uint32 m_free;
Uint32 m_sizeof;
};
Free_list_usage * get_free_list_usage(Free_list_usage*);
#endif
/*****************************************************************************
* These are service routines used by the other classes in the NDBAPI.
****************************************************************************/
@ -1562,22 +1574,8 @@ private:
class NdbDictionaryImpl* theDictionary;
class NdbGlobalEventBufferHandle* theGlobalEventBufferHandle;
NdbConnection* theConIdleList; // First connection in idle list.
NdbOperation* theOpIdleList; // First operation in the idle list.
NdbIndexScanOperation* theScanOpIdleList; // First scan operation in the idle list.
NdbIndexOperation* theIndexOpIdleList; // First index operation in the idle list.
NdbConnection* theTransactionList;
NdbConnection** theConnectionArray;
NdbRecAttr* theRecAttrIdleList;
NdbApiSignal* theSignalIdleList; // First signal in idlelist.
NdbLabel* theLabelList; // First label descriptor in list
NdbBranch* theBranchList; // First branch descriptor in list
NdbSubroutine* theSubroutineList; // First subroutine descriptor in
NdbCall* theCallList; // First call descriptor in list
NdbReceiver* theScanList;
NdbBlob* theNdbBlobIdleList;
Uint32 theMyRef; // My block reference
Uint32 theNode; // The node number of our node

6
ndb/include/ndbapi/NdbBlob.hpp
View File

@ -262,7 +262,7 @@ private:
// for keeping in lists
NdbBlob* theNext;
// initialization
NdbBlob();
NdbBlob(Ndb*);
void init();
void release();
// classify operations
@ -314,6 +314,10 @@ private:
int getOperationType() const;
friend class NdbOut& operator<<(NdbOut&, const NdbBlob&);
#endif
void next(NdbBlob* obj) { theNext= obj;}
NdbBlob* next() { return theNext;}
friend struct Ndb_free_list_t<NdbBlob>;
};
#endif

12
ndb/include/ndbapi/NdbConnection.hpp
View File

@ -18,8 +18,9 @@
#define NdbConnection_H
#include <ndb_types.h>
#include <NdbError.hpp>
#include <NdbDictionary.hpp>
#include "NdbError.hpp"
#include "NdbDictionary.hpp"
#include "Ndb.hpp"
class NdbConnection;
class NdbOperation;
@ -465,10 +466,10 @@ private:
/**************************************************************************
* These are the create and delete methods of this class. *
**************************************************************************/
NdbConnection(Ndb* aNdb);
~NdbConnection();
NdbConnection* next(); // Returns the next pointer
void next(NdbConnection*); // Sets the next pointer
void init(); // Initialize connection object for new transaction
@ -487,8 +488,6 @@ private:
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
enum ConStatusType {
NotConnected,
@ -691,6 +690,7 @@ private:
void define_scan_op(NdbIndexScanOperation*);
friend class HugoOperations;
friend struct Ndb_free_list_t<NdbConnection>;
};
inline

1
ndb/include/ndbapi/NdbIndexOperation.hpp
View File

@ -200,6 +200,7 @@ private:
Uint32 m_theIndexDefined[NDB_MAX_ATTRIBUTES_IN_INDEX][3];
Uint32 m_theIndexLen; // Length of the index in words
Uint32 m_theNoOfIndexDefined; // The number of index attributes
friend struct Ndb_free_list_t<NdbIndexOperation>;
};
#endif

2
ndb/include/ndbapi/NdbIndexScanOperation.hpp
View File

@ -132,6 +132,8 @@ private:
int compare(Uint32 key, Uint32 cols, const NdbReceiver*, const NdbReceiver*);
Uint32 m_sort_columns;
friend struct Ndb_free_list_t<NdbIndexScanOperation>;
};
#endif

8
ndb/include/ndbapi/NdbOperation.hpp
View File

@ -22,6 +22,7 @@
#include "NdbError.hpp"
#include "NdbReceiver.hpp"
#include "NdbDictionary.hpp"
#include "Ndb.hpp"
class Ndb;
class NdbApiSignal;
@ -723,8 +724,6 @@ protected:
/******************************************************************************
* These are the methods used to create and delete the NdbOperation objects.
*****************************************************************************/
NdbOperation(Ndb* aNdb);
virtual ~NdbOperation();
bool needReply();
/******************************************************************************
@ -736,8 +735,9 @@ protected:
int init(const class NdbTableImpl*, NdbConnection* aCon);
void initInterpreter();
NdbOperation(Ndb* aNdb);
virtual ~NdbOperation();
void next(NdbOperation*); // Set next pointer
NdbOperation* next(); // Get next pointer
enum OperationStatus{
@ -925,6 +925,8 @@ protected:
* IgnoreError on connection level.
*/
Int8 m_abortOption;
friend struct Ndb_free_list_t<NdbOperation>;
};
#ifdef NDB_NO_DROPPED_SIGNAL

7
ndb/include/ndbapi/NdbRecAttr.hpp
View File

@ -17,7 +17,8 @@
#ifndef NdbRecAttr_H
#define NdbRecAttr_H
#include <NdbDictionary.hpp>
#include "NdbDictionary.hpp"
#include "Ndb.hpp"
class NdbOperation;
@ -242,7 +243,6 @@ public:
*/
~NdbRecAttr();
private:
NdbRecAttr();
Uint32 attrId() const; /* Get attribute id */
bool setNULL(); /* Set NULL indicator */
@ -251,6 +251,7 @@ private:
void release(); /* Release memory if allocated */
void init(); /* Initialise object when allocated */
NdbRecAttr(Ndb*);
void next(NdbRecAttr* aRecAttr);
NdbRecAttr* next() const;
@ -273,6 +274,8 @@ private:
Uint32 theAttrSize;
Uint32 theArraySize;
const NdbDictionary::Column* m_column;
friend struct Ndb_free_list_t<NdbRecAttr>;
};
inline

19
ndb/src/ndbapi/NdbApiSignal.cpp
View File

@ -62,6 +62,25 @@ NdbApiSignal::NdbApiSignal(BlockReference ref)
theNextSignal = 0;
}
NdbApiSignal::NdbApiSignal(Ndb* ndb)
{
BlockReference ref = ndb->theMyRef;
theVerId_signalNumber = 0; // 4 bit ver id - 16 bit gsn
theReceiversBlockNumber = 0; // Only 16 bit blocknum
theSendersBlockRef = refToBlock(ref);
theLength = 0;
theSendersSignalId = 0;
theSignalId = 0;
theTrace = 0;
m_noOfSections = 0;
m_fragmentInfo = 0;
for (int i = 0; i < 25; i++)
theData[i] = 0x13579753;
setDataPtr(&theData[0]);
theNextSignal = 0;
}
/**
* Copy constructor
*/

3
ndb/src/ndbapi/NdbApiSignal.hpp
View File

@ -46,7 +46,8 @@
class NdbApiSignal : public SignalHeader
{
public:
NdbApiSignal(BlockReference myRef);
NdbApiSignal(Ndb* ndb);
NdbApiSignal(BlockReference ref);
NdbApiSignal(const NdbApiSignal &);
NdbApiSignal(const SignalHeader &header)
: SignalHeader(header), theNextSignal(0), theRealData(0) {};

2
ndb/src/ndbapi/NdbBlob.cpp
View File

@ -137,7 +137,7 @@ NdbBlob::getBlobTable(NdbTableImpl& bt, const NdbTableImpl* t, const NdbColumnIm
// initialization
NdbBlob::NdbBlob()
NdbBlob::NdbBlob(Ndb*)
{
init();
}

119
ndb/src/ndbapi/NdbImpl.hpp
View File

@ -32,6 +32,21 @@
#include "NdbDictionaryImpl.hpp"
#include "ObjectMap.hpp"
template <class T>
struct Ndb_free_list_t
{
Ndb_free_list_t();
~Ndb_free_list_t();
void fill(Ndb*, Uint32 cnt);
T* seize(Ndb*);
void release(T*);
void clear();
Uint32 get_sizeof() const { return sizeof(T); }
T * m_free_list;
Uint32 m_alloc_cnt, m_free_cnt;
};
/**
* Private parts of the Ndb object (corresponding to Ndb.hpp in public API)
*/
@ -59,6 +74,23 @@ public:
NdbWaiter theWaiter;
int m_optimized_node_selection;
/**
* NOTE free lists must be _after_ theNdbObjectIdMap take
* assure that destructors are run in correct order
*/
Ndb_free_list_t<NdbConnection> theConIdleList;
Ndb_free_list_t<NdbOperation> theOpIdleList;
Ndb_free_list_t<NdbIndexScanOperation> theScanOpIdleList;
Ndb_free_list_t<NdbIndexOperation> theIndexOpIdleList;
Ndb_free_list_t<NdbRecAttr> theRecAttrIdleList;
Ndb_free_list_t<NdbApiSignal> theSignalIdleList;
Ndb_free_list_t<NdbLabel> theLabelList;
Ndb_free_list_t<NdbBranch> theBranchList;
Ndb_free_list_t<NdbSubroutine> theSubroutineList;
Ndb_free_list_t<NdbCall> theCallList;
Ndb_free_list_t<NdbBlob> theNdbBlobIdleList;
Ndb_free_list_t<NdbReceiver> theScanList;
};
#ifdef VM_TRACE
@ -133,4 +165,91 @@ enum LockMode {
Delete
};
template<class T>
inline
Ndb_free_list_t<T>::Ndb_free_list_t()
{
m_free_list= 0;
m_alloc_cnt= m_free_cnt= 0;
}
template<class T>
inline
Ndb_free_list_t<T>::~Ndb_free_list_t()
{
clear();
}
template<class T>
inline
void
Ndb_free_list_t<T>::fill(Ndb* ndb, Uint32 cnt)
{
if (m_free_list == 0)
{
m_free_cnt++;
m_alloc_cnt++;
m_free_list = new T(ndb);
}
while(m_alloc_cnt < cnt)
{
T* obj= new T(ndb);
if(obj == 0)
return;
obj->next(m_free_list);
m_free_cnt++;
m_alloc_cnt++;
m_free_list = obj;
}
}
template<class T>
inline
T*
Ndb_free_list_t<T>::seize(Ndb* ndb)
{
T* tmp = m_free_list;
if (tmp)
{
m_free_list = (T*)tmp->next();
tmp->next(NULL);
m_free_cnt--;
return tmp;
}
if((tmp = new T(ndb)))
{
m_alloc_cnt++;
}
return tmp;
}
template<class T>
inline
void
Ndb_free_list_t<T>::release(T* obj)
{
obj->next(m_free_list);
m_free_list = obj;
m_free_cnt++;
}
template<class T>
inline
void
Ndb_free_list_t<T>::clear()
{
T* obj = m_free_list;
while(obj)
{
T* curr = obj;
obj = (T*)obj->next();
delete curr;
m_alloc_cnt--;
}
}
#endif

4
ndb/src/ndbapi/NdbRecAttr.cpp
View File

@ -33,7 +33,7 @@ Adjust: 971206 UABRONM First version
#include "NdbDictionaryImpl.hpp"
#include <NdbTCP.h>
NdbRecAttr::NdbRecAttr()
NdbRecAttr::NdbRecAttr(Ndb*)
{
init();
}
@ -109,7 +109,7 @@ NdbRecAttr::copyout()
NdbRecAttr *
NdbRecAttr::clone() const {
NdbRecAttr * ret = new NdbRecAttr();
NdbRecAttr * ret = new NdbRecAttr(0);
ret->theAttrId = theAttrId;
ret->theNULLind = theNULLind;

16
ndb/src/ndbapi/NdbUtil.cpp
View File

@ -30,8 +30,7 @@ Comment:
#include "NdbUtil.hpp"
NdbLabel::NdbLabel() :
theNext(NULL)
NdbLabel::NdbLabel(Ndb*)
{
}
@ -39,8 +38,7 @@ NdbLabel::~NdbLabel()
{
}
NdbSubroutine::NdbSubroutine() :
theNext(NULL)
NdbSubroutine::NdbSubroutine(Ndb*)
{
}
@ -48,9 +46,8 @@ NdbSubroutine::~NdbSubroutine()
{
}
NdbBranch::NdbBranch() :
theSignal(NULL),
theNext(NULL)
NdbBranch::NdbBranch(Ndb*) :
theSignal(NULL)
{
}
@ -58,9 +55,8 @@ NdbBranch::~NdbBranch()
{
}
NdbCall::NdbCall() :
theSignal(NULL),
theNext(NULL)
NdbCall::NdbCall(Ndb*) :
theSignal(NULL)
{
}

40
ndb/src/ndbapi/NdbUtil.hpp
View File

@ -34,41 +34,49 @@ Comment:
class NdbApiSignal;
class NdbOperation;
class NdbLabel
template<class T>
struct Free_list_element
{
Free_list_element() { theNext = 0;}
void next(T* obj) { theNext = obj;}
T* next() { return theNext;}
T* theNext;
};
class NdbLabel : public Free_list_element<NdbLabel>
{
friend class NdbOperation;
friend class Ndb;
private:
NdbLabel();
public:
NdbLabel(Ndb*);
~NdbLabel();
NdbLabel* theNext;
private:
Uint32 theSubroutine[16];
Uint32 theLabelAddress[16];
Uint32 theLabelNo[16];
};
class NdbSubroutine
class NdbSubroutine : public Free_list_element<NdbSubroutine>
{
friend class NdbOperation;
friend class Ndb;
private:
NdbSubroutine();
public:
NdbSubroutine(Ndb*);
~NdbSubroutine();
NdbSubroutine* theNext;
Uint32 theSubroutineAddress[16];
};
class NdbBranch
class NdbBranch : public Free_list_element<NdbBranch>
{
friend class NdbOperation;
friend class Ndb;
private:
NdbBranch();
public:
NdbBranch(Ndb*);
~NdbBranch();
NdbApiSignal* theSignal;
@ -76,22 +84,20 @@ private:
Uint32 theBranchAddress;
Uint32 theBranchLabel;
Uint32 theSubroutine;
NdbBranch* theNext;
};
class NdbCall
class NdbCall : public Free_list_element<NdbCall>
{
friend class NdbOperation;
friend class Ndb;
private:
NdbCall();
public:
NdbCall(Ndb*);
~NdbCall();
NdbApiSignal* theSignal;
Uint32 theSignalAddress;
Uint32 theSubroutine;
NdbCall* theNext;
};
#endif

9
ndb/src/ndbapi/Ndbif.cpp
View File

@ -143,15 +143,6 @@ Ndb::init(int aMaxNoOfTransactions)
error_handler:
ndbout << "error_handler" << endl;
releaseTransactionArrays();
while ( theConIdleList != NULL )
freeNdbCon();
while ( theSignalIdleList != NULL )
freeSignal();
while (theRecAttrIdleList != NULL)
freeRecAttr();
while (theOpIdleList != NULL)
freeOperation();
delete theDictionary;
TransporterFacade::instance()->close(theNdbBlockNumber, 0);
DBUG_RETURN(-1);

39
ndb/src/ndbapi/Ndbinit.cpp
View File

@ -99,20 +99,8 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
theMaxNoOfTransactions= 0;
theMinNoOfEventsToWakeUp= 0;
prefixEnd= NULL;
theConIdleList= NULL;
theOpIdleList= NULL;
theScanOpIdleList= NULL;
theIndexOpIdleList= NULL;
theTransactionList= NULL;
theConnectionArray= NULL;
theRecAttrIdleList= NULL;
theSignalIdleList= NULL;
theLabelList= NULL;
theBranchList= NULL;
theSubroutineList= NULL;
theCallList= NULL;
theScanList= NULL;
theNdbBlobIdleList= NULL;
the_last_check_time= 0;
theFirstTransId= 0;
theRestartGCI= 0;
@ -204,33 +192,6 @@ Ndb::~Ndb()
TransporterFacade::instance()->close(theNdbBlockNumber, theFirstTransId);
}
// if (theSchemaConToNdbList != NULL)
// closeSchemaTransaction(theSchemaConToNdbList);
while ( theConIdleList != NULL )
freeNdbCon();
while (theOpIdleList != NULL)
freeOperation();
while (theScanOpIdleList != NULL)
freeScanOperation();
while (theIndexOpIdleList != NULL)
freeIndexOperation();
while (theLabelList != NULL)
freeNdbLabel();
while (theBranchList != NULL)
freeNdbBranch();
while (theSubroutineList != NULL)
freeNdbSubroutine();
while (theCallList != NULL)
freeNdbCall();
while (theScanList != NULL)
freeNdbScanRec();
while (theNdbBlobIdleList != NULL)
freeNdbBlob();
while (theRecAttrIdleList != NULL)
freeRecAttr();
while ( theSignalIdleList != NULL )
freeSignal();
releaseTransactionArrays();
delete []theConnectionArray;

519
ndb/src/ndbapi/Ndblist.cpp
View File

@ -76,25 +76,7 @@ Ndb::checkFailedNode()
int
Ndb::createConIdleList(int aNrOfCon)
{
for (int i = 0; i < aNrOfCon; i++)
{
NdbConnection* tNdbCon = new NdbConnection(this);
if (tNdbCon == NULL)
{
return -1;
}
if (theConIdleList == NULL)
{
theConIdleList = tNdbCon;
theConIdleList->next(NULL);
} else
{
tNdbCon->next(theConIdleList);
theConIdleList = tNdbCon;
}
tNdbCon->Status(NdbConnection::NotConnected);
}
theNoOfAllocatedTransactions = aNrOfCon;
theImpl->theConIdleList.fill(this, aNrOfCon);
return aNrOfCon;
}
@ -110,19 +92,7 @@ Ndb::createConIdleList(int aNrOfCon)
int
Ndb::createOpIdleList(int aNrOfOp)
{
for (int i = 0; i < aNrOfOp; i++){
NdbOperation* tOp = new NdbOperation(this);
if ( tOp == NULL ){
return -1;
}
if (theOpIdleList == NULL){
theOpIdleList = tOp;
theOpIdleList->next(NULL);
} else{
tOp->next(theOpIdleList);
theOpIdleList = tOp;
}
}
theImpl->theOpIdleList.fill(this, aNrOfOp);
return aNrOfOp;
}
@ -136,22 +106,7 @@ Ndb::createOpIdleList(int aNrOfOp)
NdbBranch*
Ndb::getNdbBranch()
{
NdbBranch* tNdbBranch;
if ( theBranchList == NULL )
{
tNdbBranch = new NdbBranch;
if (tNdbBranch == NULL)
{
return NULL;
}
tNdbBranch->theNext = NULL;
} else
{
tNdbBranch = theBranchList;
theBranchList = tNdbBranch->theNext;
tNdbBranch->theNext = NULL;
}
return tNdbBranch;
return theImpl->theBranchList.seize(this);
}
/***************************************************************************
@ -164,22 +119,7 @@ Ndb::getNdbBranch()
NdbCall*
Ndb::getNdbCall()
{
NdbCall* tNdbCall;
if ( theCallList == NULL )
{
tNdbCall = new NdbCall;
if (tNdbCall == NULL)
{
return NULL;
}
tNdbCall->theNext = NULL;
} else
{
tNdbCall = theCallList;
theCallList = tNdbCall->theNext;
tNdbCall->theNext = NULL;
}
return tNdbCall;
return theImpl->theCallList.seize(this);
}
/***************************************************************************
@ -192,25 +132,14 @@ Ndb::getNdbCall()
NdbConnection*
Ndb::getNdbCon()
{
NdbConnection* tNdbCon;
if ( theConIdleList == NULL ) {
if (theNoOfAllocatedTransactions < theMaxNoOfTransactions) {
tNdbCon = new NdbConnection(this);
if (tNdbCon == NULL) {
return NULL;
}//if
theNoOfAllocatedTransactions++;
} else {
ndbout << "theNoOfAllocatedTransactions = " << theNoOfAllocatedTransactions << " theMaxNoOfTransactions = " << theMaxNoOfTransactions << endl;
return NULL;
}//if
tNdbCon->next(NULL);
} else
NdbConnection* tNdbCon = theImpl->theConIdleList.seize(this);
if (unlikely(theImpl->theConIdleList.m_alloc_cnt > theMaxNoOfTransactions))
{
tNdbCon = theConIdleList;
theConIdleList = tNdbCon->next();
tNdbCon->next(NULL);
}
theImpl->theConIdleList.release(tNdbCon);
ndbout << "theNoOfAllocatedTransactions = " << theNoOfAllocatedTransactions << " theMaxNoOfTransactions = " << theMaxNoOfTransactions << endl;
return NULL;
}//if
tNdbCon->theMagicNumber = 0x37412619;
return tNdbCon;
}
@ -225,22 +154,7 @@ Ndb::getNdbCon()
NdbLabel*
Ndb::getNdbLabel()
{
NdbLabel* tNdbLabel;
if ( theLabelList == NULL )
{
tNdbLabel = new NdbLabel;
if (tNdbLabel == NULL)
{
return NULL;
}
tNdbLabel->theNext = NULL;
} else
{
tNdbLabel = theLabelList;
theLabelList = tNdbLabel->theNext;
tNdbLabel->theNext = NULL;
}
return tNdbLabel;
return theImpl->theLabelList.seize(this);
}
/***************************************************************************
@ -254,23 +168,7 @@ Ndb::getNdbLabel()
NdbReceiver*
Ndb::getNdbScanRec()
{
NdbReceiver* tNdbScanRec;
if ( theScanList == NULL )
{
tNdbScanRec = new NdbReceiver(this);
if (tNdbScanRec == NULL)
{
return NULL;
}
tNdbScanRec->next(NULL);
} else
{
tNdbScanRec = theScanList;
theScanList = tNdbScanRec->next();
tNdbScanRec->next(NULL);
}
return tNdbScanRec;
return theImpl->theScanList.seize(this);
}
/***************************************************************************
@ -283,22 +181,7 @@ Ndb::getNdbScanRec()
NdbSubroutine*
Ndb::getNdbSubroutine()
{
NdbSubroutine* tNdbSubroutine;
if ( theSubroutineList == NULL )
{
tNdbSubroutine = new NdbSubroutine;
if (tNdbSubroutine == NULL)
{
return NULL;
}
tNdbSubroutine->theNext = NULL;
} else
{
tNdbSubroutine = theSubroutineList;
theSubroutineList = tNdbSubroutine->theNext;
tNdbSubroutine->theNext = NULL;
}
return tNdbSubroutine;
return theImpl->theSubroutineList.seize(this);
}
/***************************************************************************
@ -311,18 +194,7 @@ Remark: Get an operation from theOpIdleList and return the object .
NdbOperation*
Ndb::getOperation()
{
NdbOperation* tOp = theOpIdleList;
if (tOp != NULL ) {
NdbOperation* tOpNext = tOp->next();
tOp->next(NULL);
theOpIdleList = tOpNext;
return tOp;
} else {
tOp = new NdbOperation(this);
if (tOp != NULL)
tOp->next(NULL);
}
return tOp;
return theImpl->theOpIdleList.seize(this);
}
/***************************************************************************
@ -335,18 +207,7 @@ Remark: Get an operation from theScanOpIdleList and return the object .
NdbIndexScanOperation*
Ndb::getScanOperation()
{
NdbIndexScanOperation* tOp = theScanOpIdleList;
if (tOp != NULL ) {
NdbIndexScanOperation* tOpNext = (NdbIndexScanOperation*)tOp->next();
tOp->next(NULL);
theScanOpIdleList = tOpNext;
return tOp;
} else {
tOp = new NdbIndexScanOperation(this);
if (tOp != NULL)
tOp->next(NULL);
}
return tOp;
return theImpl->theScanOpIdleList.seize(this);
}
/***************************************************************************
@ -359,18 +220,7 @@ Remark: Get an operation from theIndexOpIdleList and return the object .
NdbIndexOperation*
Ndb::getIndexOperation()
{
NdbIndexOperation* tOp = theIndexOpIdleList;
if (tOp != NULL ) {
NdbIndexOperation* tOpNext = (NdbIndexOperation*) tOp->next();
tOp->next(NULL);
theIndexOpIdleList = tOpNext;
return tOp;
} else {
tOp = new NdbIndexOperation(this);
if (tOp != NULL)
tOp->next(NULL);
}
return tOp;
return theImpl->theIndexOpIdleList.seize(this);
}
/***************************************************************************
@ -382,21 +232,14 @@ Return Value: Return a reference to a receive attribute object.
NdbRecAttr*
Ndb::getRecAttr()
{
NdbRecAttr* tRecAttr;
tRecAttr = theRecAttrIdleList;
if (tRecAttr != NULL) {
NdbRecAttr* tRecAttrNext = tRecAttr->next();
NdbRecAttr* tRecAttr = theImpl->theRecAttrIdleList.seize(this);
if (tRecAttr != NULL)
{
tRecAttr->init();
theRecAttrIdleList = tRecAttrNext;
return tRecAttr;
} else {
tRecAttr = new NdbRecAttr;
if (tRecAttr == NULL)
return NULL;
tRecAttr->next(NULL);
}//if
tRecAttr->init();
return tRecAttr;
}
return NULL;
}
/***************************************************************************
@ -408,34 +251,16 @@ Return Value: Return a reference to a signal object.
NdbApiSignal*
Ndb::getSignal()
{
NdbApiSignal* tSignal = theSignalIdleList;
if (tSignal != NULL){
NdbApiSignal* tSignalNext = tSignal->next();
tSignal->next(NULL);
theSignalIdleList = tSignalNext;
} else {
tSignal = new NdbApiSignal(theMyRef);
#ifdef POORMANSPURIFY
cnewSignals++;
#endif
if (tSignal != NULL)
tSignal->next(NULL);
}
#ifdef POORMANSPURIFY
cgetSignals++;
#endif
return tSignal;
return theImpl->theSignalIdleList.seize(this);
}
NdbBlob*
Ndb::getNdbBlob()
{
NdbBlob* tBlob = theNdbBlobIdleList;
if (tBlob != NULL) {
theNdbBlobIdleList = tBlob->theNext;
NdbBlob* tBlob = theImpl->theNdbBlobIdleList.seize(this);
if(tBlob)
{
tBlob->init();
} else {
tBlob = new NdbBlob;
}
return tBlob;
}
@ -449,8 +274,7 @@ Remark: Add a NdbBranch object into the Branch idlelist.
void
Ndb::releaseNdbBranch(NdbBranch* aNdbBranch)
{
aNdbBranch->theNext = theBranchList;
theBranchList = aNdbBranch;
theImpl->theBranchList.release(aNdbBranch);
}
/***************************************************************************
@ -462,8 +286,7 @@ Remark: Add a NdbBranch object into the Branch idlelist.
void
Ndb::releaseNdbCall(NdbCall* aNdbCall)
{
aNdbCall->theNext = theCallList;
theCallList = aNdbCall;
theImpl->theCallList.release(aNdbCall);
}
/***************************************************************************
@ -475,9 +298,8 @@ Remark: Add a Connection object into the signal idlelist.
void
Ndb::releaseNdbCon(NdbConnection* aNdbCon)
{
aNdbCon->next(theConIdleList);
aNdbCon->theMagicNumber = 0xFE11DD;
theConIdleList = aNdbCon;
theImpl->theConIdleList.release(aNdbCon);
}
/***************************************************************************
@ -489,8 +311,7 @@ Remark: Add a NdbLabel object into the Label idlelist.
void
Ndb::releaseNdbLabel(NdbLabel* aNdbLabel)
{
aNdbLabel->theNext = theLabelList;
theLabelList = aNdbLabel;
theImpl->theLabelList.release(aNdbLabel);
}
/***************************************************************************
@ -502,8 +323,7 @@ Remark: Add a NdbScanReceiver object into the Scan idlelist.
void
Ndb::releaseNdbScanRec(NdbReceiver* aNdbScanRec)
{
aNdbScanRec->next(theScanList);
theScanList = aNdbScanRec;
theImpl->theScanList.release(aNdbScanRec);
}
/***************************************************************************
@ -515,8 +335,7 @@ Remark: Add a NdbSubroutine object into theSubroutine idlelist.
void
Ndb::releaseNdbSubroutine(NdbSubroutine* aNdbSubroutine)
{
aNdbSubroutine->theNext = theSubroutineList;
theSubroutineList = aNdbSubroutine;
theImpl->theSubroutineList.release(aNdbSubroutine);
}
/***************************************************************************
@ -529,16 +348,14 @@ void
Ndb::releaseOperation(NdbOperation* anOperation)
{
if(anOperation->m_tcReqGSN == GSN_TCKEYREQ){
anOperation->next(theOpIdleList);
anOperation->theNdbCon = NULL;
anOperation->theMagicNumber = 0xFE11D0;
theOpIdleList = anOperation;
theImpl->theOpIdleList.release(anOperation);
} else {
assert(anOperation->m_tcReqGSN == GSN_TCINDXREQ);
anOperation->next(theIndexOpIdleList);
anOperation->theNdbCon = NULL;
anOperation->theMagicNumber = 0xFE11D1;
theIndexOpIdleList = (NdbIndexOperation*)anOperation;
theImpl->theIndexOpIdleList.release((NdbIndexOperation*)anOperation);
}
}
@ -551,10 +368,9 @@ Remark: Add a NdbScanOperation object into the signal idlelist.
void
Ndb::releaseScanOperation(NdbIndexScanOperation* aScanOperation)
{
aScanOperation->next(theScanOpIdleList);
aScanOperation->theNdbCon = NULL;
aScanOperation->theMagicNumber = 0xFE11D2;
theScanOpIdleList = aScanOperation;
theImpl->theScanOpIdleList.release(aScanOperation);
}
/***************************************************************************
@ -567,8 +383,7 @@ void
Ndb::releaseRecAttr(NdbRecAttr* aRecAttr)
{
aRecAttr->release();
aRecAttr->next(theRecAttrIdleList);
theRecAttrIdleList = aRecAttr;
theImpl->theRecAttrIdleList.release(aRecAttr);
}
/***************************************************************************
@ -595,8 +410,7 @@ Ndb::releaseSignal(NdbApiSignal* aSignal)
#ifdef POORMANSPURIFY
creleaseSignals++;
#endif
aSignal->next(theSignalIdleList);
theSignalIdleList = aSignal;
theImpl->theSignalIdleList.release(aSignal);
}
void
@ -612,163 +426,7 @@ Ndb::releaseSignalsInList(NdbApiSignal** pList){
void
Ndb::releaseNdbBlob(NdbBlob* aBlob)
{
aBlob->release();
aBlob->theNext = theNdbBlobIdleList;
theNdbBlobIdleList = aBlob;
}
/***************************************************************************
void freeOperation();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeOperation()
{
NdbOperation* tOp = theOpIdleList;
theOpIdleList = theOpIdleList->next();
delete tOp;
}
/***************************************************************************
void freeScanOperation();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeScanOperation()
{
NdbIndexScanOperation* tOp = theScanOpIdleList;
theScanOpIdleList = (NdbIndexScanOperation *)tOp->next();
delete tOp;
}
/***************************************************************************
void freeIndexOperation();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeIndexOperation()
{
NdbIndexOperation* tOp = theIndexOpIdleList;
theIndexOpIdleList = (NdbIndexOperation *) theIndexOpIdleList->next();
delete tOp;
}
/***************************************************************************
void freeNdbBranch();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbBranch()
{
NdbBranch* tNdbBranch = theBranchList;
theBranchList = theBranchList->theNext;
delete tNdbBranch;
}
/***************************************************************************
void freeNdbCall();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbCall()
{
NdbCall* tNdbCall = theCallList;
theCallList = theCallList->theNext;
delete tNdbCall;
}
/***************************************************************************
void freeNdbScanRec();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbScanRec()
{
NdbReceiver* tNdbScanRec = theScanList;
theScanList = theScanList->next();
delete tNdbScanRec;
}
/***************************************************************************
void freeNdbCon();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbCon()
{
NdbConnection* tNdbCon = theConIdleList;
theConIdleList = theConIdleList->next();
delete tNdbCon;
}
/***************************************************************************
void freeNdbLabel();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbLabel()
{
NdbLabel* tNdbLabel = theLabelList;
theLabelList = theLabelList->theNext;
delete tNdbLabel;
}
/***************************************************************************
void freeNdbSubroutine();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeNdbSubroutine()
{
NdbSubroutine* tNdbSubroutine = theSubroutineList;
theSubroutineList = theSubroutineList->theNext;
delete tNdbSubroutine;
}
/***************************************************************************
void freeRecAttr();
Remark: Always release the first item in the free list
***************************************************************************/
void
Ndb::freeRecAttr()
{
NdbRecAttr* tRecAttr = theRecAttrIdleList;
theRecAttrIdleList = theRecAttrIdleList->next();
delete tRecAttr;
}
/***************************************************************************
void freeSignal();
Remark: Delete a signal object from the signal idlelist.
***************************************************************************/
void
Ndb::freeSignal()
{
NdbApiSignal* tSignal = theSignalIdleList;
theSignalIdleList = tSignal->next();
delete tSignal;
#ifdef POORMANSPURIFY
cfreeSignals++;
#endif
}
void
Ndb::freeNdbBlob()
{
NdbBlob* tBlob = theNdbBlobIdleList;
theNdbBlobIdleList = tBlob->theNext;
delete tBlob;
theImpl->theNdbBlobIdleList.release(aBlob);
}
/****************************************************************************
@ -823,3 +481,102 @@ Ndb::releaseConnectToNdb(NdbConnection* a_con)
DBUG_VOID_RETURN;
}
template<class T>
static
Ndb::Free_list_usage*
update(Ndb::Free_list_usage* curr,
Ndb_free_list_t<T> & list,
const char * name)
{
curr->m_name = name;
curr->m_created = list.m_alloc_cnt;
curr->m_free = list.m_free_cnt;
curr->m_sizeof = sizeof(T);
return curr;
}
Ndb::Free_list_usage*
Ndb::get_free_list_usage(Ndb::Free_list_usage* curr)
{
if (curr == 0)
{
return 0;
}
if(curr->m_name == 0)
{
update(curr, theImpl->theConIdleList, "NdbTransaction");
}
else if(!strcmp(curr->m_name, "NdbTransaction"))
{
update(curr, theImpl->theOpIdleList, "NdbOperation");
}
else if(!strcmp(curr->m_name, "NdbOperation"))
{
update(curr, theImpl->theScanOpIdleList, "NdbIndexScanOperation");
}
else if(!strcmp(curr->m_name, "NdbIndexScanOperation"))
{
update(curr, theImpl->theIndexOpIdleList, "NdbIndexOperation");
}
else if(!strcmp(curr->m_name, "NdbIndexOperation"))
{
update(curr, theImpl->theRecAttrIdleList, "NdbRecAttr");
}
else if(!strcmp(curr->m_name, "NdbRecAttr"))
{
update(curr, theImpl->theSignalIdleList, "NdbApiSignal");
}
else if(!strcmp(curr->m_name, "NdbApiSignal"))
{
update(curr, theImpl->theLabelList, "NdbLabel");
}
else if(!strcmp(curr->m_name, "NdbLabel"))
{
update(curr, theImpl->theBranchList, "NdbBranch");
}
else if(!strcmp(curr->m_name, "NdbBranch"))
{
update(curr, theImpl->theSubroutineList, "NdbSubroutine");
}
else if(!strcmp(curr->m_name, "NdbSubroutine"))
{
update(curr, theImpl->theCallList, "NdbCall");
}
else if(!strcmp(curr->m_name, "NdbCall"))
{
update(curr, theImpl->theNdbBlobIdleList, "NdbBlob");
}
else if(!strcmp(curr->m_name, "NdbBlob"))
{
update(curr, theImpl->theScanList, "NdbReceiver");
}
else if(!strcmp(curr->m_name, "NdbReceiver"))
{
return 0;
}
else
{
update(curr, theImpl->theConIdleList, "NdbTransaction");
}
return curr;
}
#define TI(T) \
template Ndb::Free_list_usage* \
update(Ndb::Free_list_usage*, Ndb_free_list_t<T> &, const char * name);\
template struct Ndb_free_list_t<T>
TI(NdbBlob);
TI(NdbCall);
TI(NdbLabel);
TI(NdbBranch);
TI(NdbSubroutine);
TI(NdbApiSignal);
TI(NdbRecAttr);
TI(NdbOperation);
TI(NdbReceiver);
TI(NdbConnection);
TI(NdbIndexOperation);
TI(NdbIndexScanOperation);

2
ndb/test/include/NDBT_Test.hpp
View File

@ -426,7 +426,7 @@ C##suitname():NDBT_TestSuite(#suitname){ \
pt->addTable(tableName, false);
#define NDBT_TESTSUITE_END(suitname) \
} } ; C##suitname suitname;
} } ; C##suitname suitname
// Helper functions for retrieving variables from NDBT_Step
#define GETNDB(ps) ((NDBT_NdbApiStep*)ps)->getNdb()

4
ndb/test/ndbapi/bank/BankLoad.cpp
View File

@ -321,7 +321,7 @@ int Bank::loadGl(){
m_ndb.closeTransaction(pTrans);
return NDBT_OK;
};
}
int Bank::getBalanceForAccountType(const Uint32 accountType,
@ -460,7 +460,7 @@ int Bank::loadAccountType(){
m_ndb.closeTransaction(pTrans);
return NDBT_OK;
};
}
/**
* Load ACCOUNT table

6
ndb/test/ndbapi/testOIBasic.cpp
View File

@ -2187,7 +2187,7 @@ pkinsert(Par par)
}
con.closeTransaction();
return 0;
};
}
static int
pkupdate(Par par)
@ -2250,7 +2250,7 @@ pkupdate(Par par)
}
con.closeTransaction();
return 0;
};
}
static int
pkdelete(Par par)
@ -2306,7 +2306,7 @@ pkdelete(Par par)
}
con.closeTransaction();
return 0;
};
}
static int
pkread(Par par)

6
ndb/test/src/HugoCalculator.cpp
View File

@ -51,7 +51,7 @@ HugoCalculator::HugoCalculator(const NdbDictionary::Table& tab) : m_tab(tab) {
#endif
// Check that idCol is not conflicting with updatesCol
assert(m_idCol != m_updatesCol && m_idCol != -1 && m_updatesCol != -1);
};
}
Int32
HugoCalculator::calcValue(int record,
@ -73,7 +73,7 @@ HugoCalculator::calcValue(int record,
else
val = record + attrib + updates;
return val;
};
}
#if 0
HugoCalculator::U_Int32 calcValue(int record, int attrib, int updates) const;
HugoCalculator::U_Int64 calcValue(int record, int attrib, int updates) const;
@ -123,7 +123,7 @@ HugoCalculator::calcValue(int record,
buf[len] = 0;
}
return buf;
};
}
int
HugoCalculator::verifyRowValues(NDBT_ResultRow* const pRow) const{

2
ndb/test/src/NDBT_Test.cpp
View File

@ -624,7 +624,7 @@ int NDBT_TestCase::execute(NDBT_Context* ctx){
<< endl;
}
return res;
};
}
void NDBT_TestCase::startTimer(NDBT_Context* ctx){

2
ndb/test/src/NdbBackup.cpp
View File

@ -345,7 +345,7 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
}
return NDBT_OK;
};
}
int
FailS_codes[] = {

30
ndb/test/src/NdbRestarts.cpp
View File

@ -213,7 +213,7 @@ NdbRestarts::NdbRestart::NdbRestart(const char* _name,
m_restartFunc = _func;
m_numRequiredNodes = _requiredNodes;
// m_arg1 = arg1;
};
}
int NdbRestarts::getNumRestarts(){
@ -367,7 +367,7 @@ int restartRandomNodeGraceful(NdbRestarter& _restarter,
"Could not restart node "<<nodeId);
return NDBT_OK;
};
}
int restartRandomNodeAbort(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -382,7 +382,7 @@ int restartRandomNodeAbort(NdbRestarter& _restarter,
"Could not restart node "<<nodeId);
return NDBT_OK;
};
}
int restartRandomNodeError(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -397,7 +397,7 @@ int restartRandomNodeError(NdbRestarter& _restarter,
"Could not restart node "<<nodeId);
return NDBT_OK;
};
}
int restartMasterNodeError(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -410,7 +410,7 @@ int restartMasterNodeError(NdbRestarter& _restarter,
"Could not restart node "<<nodeId);
return NDBT_OK;
};
}
int restartRandomNodeInitial(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -425,7 +425,7 @@ int restartRandomNodeInitial(NdbRestarter& _restarter,
"Could not restart node "<<nodeId);
return NDBT_OK;
};
}
int twoNodeFailure(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -453,7 +453,7 @@ int twoNodeFailure(NdbRestarter& _restarter,
"Could not restart node "<< nodeId);
return NDBT_OK;
};
}
int twoMasterNodeFailure(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -478,7 +478,7 @@ int twoMasterNodeFailure(NdbRestarter& _restarter,
"Could not restart node "<< nodeId);
return NDBT_OK;
};
}
int get50PercentOfNodes(NdbRestarter& restarter,
int * _nodes){
@ -519,7 +519,7 @@ int fiftyPercentFail(NdbRestarter& _restarter,
"Could not start all nodes");
return NDBT_OK;
};
}
int restartAllNodesGracfeul(NdbRestarter& _restarter,
@ -533,7 +533,7 @@ int restartAllNodesGracfeul(NdbRestarter& _restarter,
return NDBT_OK;
};
}
int restartAllNodesAbort(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -545,7 +545,7 @@ int restartAllNodesAbort(NdbRestarter& _restarter,
"Could not restart all nodes");
return NDBT_OK;
};
}
int restartAllNodesError9999(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -557,7 +557,7 @@ int restartAllNodesError9999(NdbRestarter& _restarter,
"Could not restart all nodes ");
return NDBT_OK;
};
}
int fiftyPercentStopAndWait(NdbRestarter& _restarter,
const NdbRestarts::NdbRestart* _restart){
@ -590,7 +590,7 @@ int fiftyPercentStopAndWait(NdbRestarter& _restarter,
g_info << _restart->m_name << endl;
return NDBT_OK;
};
}
int
NFDuringNR_codes[] = {
@ -713,7 +713,7 @@ int restartNFDuringNR(NdbRestarter& _restarter,
}
return NDBT_OK;
};
}
int
NRDuringLCP_Master_codes[] = {
@ -864,7 +864,7 @@ int stopOnError(NdbRestarter& _restarter,
} while (false);
return NDBT_OK;
};
}
int getRandomNodeId(NdbRestarter& _restarter) {
myRandom48Init(NdbTick_CurrentMillisecond());

2
ndb/tools/restore/Restore.cpp
View File

@ -869,7 +869,7 @@ operator<<(NdbOut& ndbout, const AttributeS& attr){
return ndbout;
}
NdbRecAttr tmprec;
NdbRecAttr tmprec(0);
tmprec.setup(desc.m_column, (char *)data.void_value);
ndbout << tmprec;