database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Merge bk-internal.mysql.com:/home/bk/mysql-5.0

Browse Source 
into  bodhi.local:/opt/local/work/mysql-5.0-runtime-merge-41


sql/opt_range.cc:
  Auto merged
support-files/mysql.spec.sh:
  Auto merged
mysql-test/Makefile.am:
  Manual merge.
This commit is contained in:
unknown
2006-07-11 08:36:50 +04:00
parent 7b659332e4 66fc547d1b
commit aedfd07248
16 changed files with 343 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
mysql-test/Makefile.am
View File

@ -101,15 +101,15 @@ uninstall-local:
@RM@ -f -r $(DESTDIR)$(testdir)
std_data/client-key.pem: $(top_srcdir)/SSL/$(@F)
@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
std_data/client-cert.pem: $(top_srcdir)/SSL/$(@F)
@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
std_data/cacert.pem: $(top_srcdir)/SSL/$(@F)
@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
std_data/server-cert.pem: $(top_srcdir)/SSL/$(@F)
@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
std_data/server-key.pem: $(top_srcdir)/SSL/$(@F)
@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
SUFFIXES = .sh

1
ndb/include/kernel/GlobalSignalNumbers.h
View File

@ -587,6 +587,7 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
#define GSN_BLOCK_COMMIT_ORD 485
#define GSN_UNBLOCK_COMMIT_ORD 486
#define GSN_NODE_START_REP 502
#define GSN_NODE_STATE_REP 487
#define GSN_CHANGE_NODE_STATE_REQ 488
#define GSN_CHANGE_NODE_STATE_CONF 489

2
ndb/src/common/debugger/signaldata/SignalNames.cpp
View File

@ -399,6 +399,8 @@ const GsnName SignalNames [] = {
,{ GSN_TUP_COM_UNBLOCK, "TUP_COM_UNBLOCK" }
,{ GSN_DUMP_STATE_ORD, "DUMP_STATE_ORD" }
,{ GSN_NODE_START_REP, "NODE_START_REP" }
,{ GSN_START_INFOREQ, "START_INFOREQ" }
,{ GSN_START_INFOREF, "START_INFOREF" }
,{ GSN_START_INFOCONF, "START_INFOCONF" }

4
ndb/src/kernel/blocks/ERROR_codes.txt
View File

@ -2,7 +2,7 @@ Next QMGR 1
Next NDBCNTR 1000
Next NDBFS 2000
Next DBACC 3002
Next DBTUP 4013
Next DBTUP 4014
Next DBLQH 5043
Next DBDICT 6007
Next DBDIH 7177
@ -437,6 +437,8 @@ Drop Table/Index:
8036: Fail next index drop in TC
6006: Crash participant in create index
4013: verify TUP tab descr before and after next DROP TABLE
System Restart:
---------------

12
ndb/src/kernel/blocks/dbdict/DictLock.txt
View File

@ -85,10 +85,14 @@ DIH/s
START_MECONF
DIH/s
* sp7 - release DICT lock
* (copy data, omitted)
DIH/s
DICT_UNLOCK_ORD
DICT/m
* SL_STARTED - release DICT lock
CNTR/s
NODE_START_REP
DIH/s
DICT_UNLOCK_ORD
DICT/m
# vim: set et sw=4:

3
ndb/src/kernel/blocks/dbdih/Dbdih.hpp
View File

@ -1599,6 +1599,9 @@ private:
*/
void startInfoReply(Signal *, Uint32 nodeId);
// DIH specifics for execNODE_START_REP (sendDictUnlockOrd)
void exec_node_start_rep(Signal* signal);
/*
* Lock master DICT. Only current use is by starting node
* during NR. A pool of slave records is convenient anyway.

40
ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
View File

@ -1356,24 +1356,6 @@ void Dbdih::execNDB_STTOR(Signal* signal)
}
ndbrequire(false);
break;
case ZNDB_SPH7:
jam();
switch (typestart) {
case NodeState::ST_INITIAL_START:
case NodeState::ST_SYSTEM_RESTART:
jam();
ndbsttorry10Lab(signal, __LINE__);
return;
case NodeState::ST_NODE_RESTART:
case NodeState::ST_INITIAL_NODE_RESTART:
jam();
sendDictUnlockOrd(signal, c_dictLockSlavePtrI_nodeRestart);
c_dictLockSlavePtrI_nodeRestart = RNIL;
ndbsttorry10Lab(signal, __LINE__);
return;
}
ndbrequire(false);
break;
default:
jam();
ndbsttorry10Lab(signal, __LINE__);
@ -1381,6 +1363,27 @@ void Dbdih::execNDB_STTOR(Signal* signal)
}//switch
}//Dbdih::execNDB_STTOR()
void
Dbdih::exec_node_start_rep(Signal* signal)
{
/*
* Send DICT_UNLOCK_ORD when this node is SL_STARTED.
*
* Sending it before (sp 7) conflicts with code which assumes
* SL_STARTING means we are in copy phase of NR.
*
* NodeState::starting.restartType is not supposed to be used
* when SL_STARTED. Also it seems NODE_START_REP can arrive twice.
*
* For these reasons there are no consistency checks and
* we rely on c_dictLockSlavePtrI_nodeRestart alone.
*/
if (c_dictLockSlavePtrI_nodeRestart != RNIL) {
sendDictUnlockOrd(signal, c_dictLockSlavePtrI_nodeRestart);
c_dictLockSlavePtrI_nodeRestart = RNIL;
}
}
void
Dbdih::createMutexes(Signal * signal, Uint32 count){
Callback c = { safe_cast(&Dbdih::createMutex_done), count };
@ -1605,6 +1608,7 @@ void Dbdih::nodeRestartPh2Lab(Signal* signal)
void Dbdih::recvDictLockConf_nodeRestart(Signal* signal, Uint32 data, Uint32 ret)
{
ndbrequire(c_dictLockSlavePtrI_nodeRestart == RNIL);
ndbrequire(data != RNIL);
c_dictLockSlavePtrI_nodeRestart = data;
nodeRestartPh2Lab2(signal);

9
ndb/src/kernel/blocks/dbtup/Dbtup.hpp
View File

@ -2185,15 +2185,18 @@ private:
// Public methods
Uint32 getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset);
Uint32 allocTabDescr(const Tablerec* regTabPtr, Uint32* offset);
void freeTabDescr(Uint32 retRef, Uint32 retNo);
void freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal = true);
Uint32 getTabDescrWord(Uint32 index);
void setTabDescrWord(Uint32 index, Uint32 word);
// Private methods
Uint32 sizeOfReadFunction();
void removeTdArea(Uint32 tabDesRef, Uint32 list);
void insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list);
Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo);
void insertTdArea(Uint32 tabDesRef, Uint32 list);
void itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal);
#ifdef VM_TRACE
void verifytabdes();
#endif
//------------------------------------------------------------------------------------------------------
// Page Memory Manager

11
ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
View File

@ -601,6 +601,11 @@ void
Dbtup::execDROP_TAB_REQ(Signal* signal)
{
ljamEntry();
if (ERROR_INSERTED(4013)) {
#ifdef VM_TRACE
verifytabdes();
#endif
}
DropTabReq* req = (DropTabReq*)signal->getDataPtr();
TablerecPtr tabPtr;
@ -719,5 +724,11 @@ void Dbtup::execFSREMOVECONF(Signal* signal)
releaseTabDescr(tabPtr.p);
initTab(tabPtr.p);
if (ERROR_INSERTED(4013)) {
CLEAR_ERROR_INSERT_VALUE;
#ifdef VM_TRACE
verifytabdes();
#endif
}
}//Dbtup::execFSREMOVECONF()

169
ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
View File

@ -24,13 +24,15 @@
#define ljam() { jamLine(22000 + __LINE__); }
#define ljamEntry() { jamEntryLine(22000 + __LINE__); }
/* **************************************************************** */
/* *********** TABLE DESCRIPTOR MEMORY MANAGER ******************** */
/* **************************************************************** */
/* This module is used to allocate and deallocate table descriptor */
/* memory attached to fragments (could be allocated per table */
/* instead. Performs its task by a buddy algorithm. */
/* **************************************************************** */
/*
* TABLE DESCRIPTOR MEMORY MANAGER
*
* Each table has a descriptor which is a contiguous array of words.
* The descriptor is allocated from a global array using a buddy
* algorithm. Free lists exist for each power of 2 words. Freeing
* a piece first merges with free right and left neighbours and then
* divides itself up into free list chunks.
*/
Uint32
Dbtup::getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset)
@ -59,7 +61,7 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
Uint32 reference = RNIL;
Uint32 allocSize = getTabDescrOffsets(regTabPtr, offset);
/* ---------------------------------------------------------------- */
/* ALWAYS ALLOCATE A MULTIPLE OF 16 BYTES */
/* ALWAYS ALLOCATE A MULTIPLE OF 16 WORDS */
/* ---------------------------------------------------------------- */
allocSize = (((allocSize - 1) >> 4) + 1) << 4;
Uint32 list = nextHigherTwoLog(allocSize - 1); /* CALCULATE WHICH LIST IT BELONGS TO */
@ -72,9 +74,9 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
Uint32 retNo = (1 << i) - allocSize; /* CALCULATE THE DIFFERENCE */
if (retNo >= ZTD_FREE_SIZE) {
ljam();
Uint32 retRef = reference + allocSize; /* SET THE RETURN POINTER */
retNo = itdaMergeTabDescr(retRef, retNo); /* MERGE WITH POSSIBLE RIGHT NEIGHBOURS */
freeTabDescr(retRef, retNo); /* RETURN UNUSED TD SPACE TO THE TD AREA */
// return unused words, of course without attempting left merge
Uint32 retRef = reference + allocSize;
freeTabDescr(retRef, retNo, false);
} else {
ljam();
allocSize = 1 << i;
@ -100,17 +102,19 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
}//if
}//Dbtup::allocTabDescr()
void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo)
void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)
{
itdaMergeTabDescr(retRef, retNo, normal); /* MERGE WITH POSSIBLE NEIGHBOURS */
while (retNo >= ZTD_FREE_SIZE) {
ljam();
Uint32 list = nextHigherTwoLog(retNo);
list--; /* RETURN TO NEXT LOWER LIST */
Uint32 sizeOfChunk = 1 << list;
insertTdArea(sizeOfChunk, retRef, list);
insertTdArea(retRef, list);
retRef += sizeOfChunk;
retNo -= sizeOfChunk;
}//while
ndbassert(retNo == 0);
}//Dbtup::freeTabDescr()
Uint32
@ -127,7 +131,7 @@ Dbtup::setTabDescrWord(Uint32 index, Uint32 word)
tableDescriptor[index].tabDescr = word;
}//Dbtup::setTabDescrWord()
void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list)
void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list)
{
ndbrequire(list < 16);
setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
@ -144,19 +148,14 @@ void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list)
setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_SIZE, 1 << list);
}//Dbtup::insertTdArea()
/* ---------------------------------------------------------------- */
/* ----------------------- MERGE_TAB_DESCR ------------------------ */
/* ---------------------------------------------------------------- */
/* INPUT: TAB_DESCR_PTR POINTING AT THE CURRENT CHUNK */
/* */
/* SHORTNAME: MTD */
/* -----------------------------------------------------------------*/
Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo)
/*
* Merge to-be-removed chunk (which need not be initialized with header
* and trailer) with left and right buddies. The start point retRef
* moves to left and the size retNo increases to match the new chunk.
*/
void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
{
/* THE SIZE OF THE PART TO MERGE MUST BE OF THE SAME SIZE AS THE INSERTED PART */
/* THIS IS TRUE EITHER IF ONE PART HAS THE SAME SIZE OR THE SUM OF BOTH PARTS */
/* TOGETHER HAS THE SAME SIZE AS THE PART TO BE INSERTED */
/* FIND THE SIZES OF THE PARTS TO THE RIGHT OF THE PART TO BE REINSERTED */
// merge right
while ((retRef + retNo) < cnoOfTabDescrRec) {
ljam();
Uint32 tabDesRef = retRef + retNo;
@ -170,11 +169,28 @@ Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo)
removeTdArea(tabDesRef, list);
} else {
ljam();
return retNo;
}//if
}//while
ndbrequire((retRef + retNo) == cnoOfTabDescrRec);
return retNo;
break;
}
}
// merge left
const bool mergeLeft = normal;
while (mergeLeft && retRef > 0) {
ljam();
Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);
if (trailerWord == ZTD_TYPE_FREE) {
ljam();
Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);
ndbrequire(retRef >= sizeOfMergedPart);
retRef -= sizeOfMergedPart;
retNo += sizeOfMergedPart;
Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
removeTdArea(retRef, list);
} else {
ljam();
break;
}
}
ndbrequire((retRef + retNo) <= cnoOfTabDescrRec);
}//Dbtup::itdaMergeTabDescr()
/* ---------------------------------------------------------------- */
@ -210,3 +226,94 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list)
setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);
}//if
}//Dbtup::removeTdArea()
#ifdef VM_TRACE
void
Dbtup::verifytabdes()
{
struct WordType {
short fl; // free list 0-15
short ti; // table id
WordType() : fl(-1), ti(-1) {}
};
WordType* wt = new WordType [cnoOfTabDescrRec];
uint free_frags = 0;
// free lists
{
for (uint i = 0; i < 16; i++) {
Uint32 desc2 = RNIL;
Uint32 desc = cfreeTdList[i];
while (desc != RNIL) {
const Uint32 size = (1 << i);
ndbrequire(size >= ZTD_FREE_SIZE);
ndbrequire(desc + size <= cnoOfTabDescrRec);
{ Uint32 index = desc + ZTD_FL_HEADER;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
}
{ Uint32 index = desc + ZTD_FL_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + size - ZTD_TR_TYPE;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
}
{ Uint32 index = desc + size - ZTD_TR_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + ZTD_FL_PREV;
ndbrequire(tableDescriptor[index].tabDescr == desc2);
}
for (uint j = 0; j < size; j++) {
ndbrequire(wt[desc + j].fl == -1);
wt[desc + j].fl = i;
}
desc2 = desc;
desc = tableDescriptor[desc + ZTD_FL_NEXT].tabDescr;
free_frags++;
}
}
}
// tables
{
for (uint i = 0; i < cnoOfTablerec; i++) {
TablerecPtr ptr;
ptr.i = i;
ptrAss(ptr, tablerec);
if (ptr.p->tableStatus == DEFINED) {
Uint32 offset[10];
const Uint32 alloc = getTabDescrOffsets(ptr.p, offset);
const Uint32 desc = ptr.p->readKeyArray - offset[3];
Uint32 size = alloc;
if (size % ZTD_FREE_SIZE != 0)
size += ZTD_FREE_SIZE - size % ZTD_FREE_SIZE;
ndbrequire(desc + size <= cnoOfTabDescrRec);
{ Uint32 index = desc + ZTD_FL_HEADER;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
}
{ Uint32 index = desc + ZTD_FL_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + size - ZTD_TR_TYPE;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
}
{ Uint32 index = desc + size - ZTD_TR_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
for (uint j = 0; j < size; j++) {
ndbrequire(wt[desc + j].ti == -1);
wt[desc + j].ti = i;
}
}
}
}
// all words
{
for (uint i = 0; i < cnoOfTabDescrRec; i++) {
bool is_fl = wt[i].fl != -1;
bool is_ti = wt[i].ti != -1;
ndbrequire(is_fl != is_ti);
}
}
delete [] wt;
ndbout << "verifytabdes: frags=" << free_frags << endl;
}
#endif

7
ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
View File

@ -591,6 +591,13 @@ Ndbcntr::execCNTR_START_REP(Signal* signal){
Uint32 nodeId = signal->theData[0];
c_startedNodes.set(nodeId);
c_start.m_starting.clear(nodeId);
/**
* Inform all interested blocks that node has started
*/
for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
sendSignal(ALL_BLOCKS[i].Ref, GSN_NODE_START_REP, signal, 1, JBB);
}
if(!c_start.m_starting.isclear()){
jam();

15
ndb/src/kernel/vm/SimulatedBlock.cpp
View File

@ -148,6 +148,7 @@ SimulatedBlock::installSimulatedBlockFunctions(){
a[GSN_FSREMOVEREF] = &SimulatedBlock::execFSREMOVEREF;
a[GSN_FSSYNCREF] = &SimulatedBlock::execFSSYNCREF;
a[GSN_FSAPPENDREF] = &SimulatedBlock::execFSAPPENDREF;
a[GSN_NODE_START_REP] = &SimulatedBlock::execNODE_START_REP;
}
void
@ -913,6 +914,20 @@ SimulatedBlock::execCONTINUE_FRAGMENTED(Signal * signal){
sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
}
void
SimulatedBlock::execNODE_START_REP(Signal* signal)
{
// common stuff for all blocks
// block specific stuff by virtual method override (default empty)
exec_node_start_rep(signal);
}
void
SimulatedBlock::exec_node_start_rep(Signal* signal)
{
}
#ifdef VM_TRACE_TIME
void
SimulatedBlock::clearTimes() {

2
ndb/src/kernel/vm/SimulatedBlock.hpp
View File

@ -423,6 +423,8 @@ private:
void execSIGNAL_DROPPED_REP(Signal* signal);
void execCONTINUE_FRAGMENTED(Signal* signal);
void execNODE_START_REP(Signal* signal);
virtual void exec_node_start_rep(Signal* signal);
Uint32 c_fragmentIdCounter;
ArrayPool<FragmentInfo> c_fragmentInfoPool;

101
ndb/test/ndbapi/testDict.cpp
View File

@ -233,6 +233,101 @@ int runCreateAndDrop(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
int runCreateAndDropAtRandom(NDBT_Context* ctx, NDBT_Step* step)
{
myRandom48Init(NdbTick_CurrentMillisecond());
Ndb* pNdb = GETNDB(step);
NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
int loops = ctx->getNumLoops();
int numTables = NDBT_Tables::getNumTables();
bool* tabList = new bool [ numTables ];
int tabCount;
{
for (int num = 0; num < numTables; num++) {
(void)pDic->dropTable(NDBT_Tables::getTable(num)->getName());
tabList[num] = false;
}
tabCount = 0;
}
NdbRestarter restarter;
int result = NDBT_OK;
int bias = 1; // 0-less 1-more
int i = 0;
while (i < loops) {
g_info << "loop " << i << " tabs " << tabCount << "/" << numTables << endl;
int num = myRandom48(numTables);
const NdbDictionary::Table* pTab = NDBT_Tables::getTable(num);
char tabName[200];
strcpy(tabName, pTab->getName());
if (tabList[num] == false) {
if (bias == 0 && myRandom48(100) < 80)
continue;
g_info << tabName << ": create" << endl;
if (pDic->createTable(*pTab) != 0) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": create failed: " << err << endl;
result = NDBT_FAILED;
break;
}
const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
if (pTab2 == NULL) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": verify create: " << err << endl;
result = NDBT_FAILED;
break;
}
tabList[num] = true;
assert(tabCount < numTables);
tabCount++;
if (tabCount == numTables)
bias = 0;
}
else {
if (bias == 1 && myRandom48(100) < 80)
continue;
g_info << tabName << ": drop" << endl;
if (restarter.insertErrorInAllNodes(4013) != 0) {
g_err << "error insert failed" << endl;
result = NDBT_FAILED;
break;
}
if (pDic->dropTable(tabName) != 0) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": drop failed: " << err << endl;
result = NDBT_FAILED;
break;
}
const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
if (pTab2 != NULL) {
g_err << tabName << ": verify drop: table exists" << endl;
result = NDBT_FAILED;
break;
}
if (pDic->getNdbError().code != 709 &&
pDic->getNdbError().code != 723) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": verify drop: " << err << endl;
result = NDBT_FAILED;
break;
}
tabList[num] = false;
assert(tabCount > 0);
tabCount--;
if (tabCount == 0)
bias = 1;
}
i++;
}
delete [] tabList;
return result;
}
int runCreateAndDropWithData(NDBT_Context* ctx, NDBT_Step* step){
Ndb* pNdb = GETNDB(step);
int loops = ctx->getNumLoops();
@ -1849,6 +1944,12 @@ TESTCASE("CreateAndDrop",
"Try to create and drop the table loop number of times\n"){
INITIALIZER(runCreateAndDrop);
}
TESTCASE("CreateAndDropAtRandom",
"Try to create and drop table at random loop number of times\n"
"Uses all available tables\n"
"Uses error insert 4013 to make TUP verify table descriptor"){
INITIALIZER(runCreateAndDropAtRandom);
}
TESTCASE("CreateAndDropWithData",
"Try to create and drop the table when it's filled with data\n"
"do this loop number of times\n"){

8
ndb/test/run-test/daily-basic-tests.txt
View File

@ -464,6 +464,10 @@ max-time: 1500
cmd: testDict
args: -n CreateAndDrop
max-time: 1500
cmd: testDict
args: -n CreateAndDropAtRandom -l 200 T1
max-time: 1500
cmd: testDict
args: -n CreateAndDropWithData
@ -500,6 +504,10 @@ max-time: 1500
cmd: testDict
args: -n TemporaryTables T1 T6 T7 T8
max-time: 1500
cmd: testDict
args: -n Restart_NR2 T1
#
# TEST NDBAPI
#

13
support-files/mysql.spec.sh
View File

@ -342,7 +342,7 @@ then
cp -fp config.log "$MYSQL_MAXCONFLOG_DEST"
fi
make -i test-force || true
make -i test-force-pl || true
# Save mysqld-max
./libtool --mode=execute cp sql/mysqld sql/mysqld-max
@ -401,7 +401,7 @@ then
cp -fp config.log "$MYSQL_CONFLOG_DEST"
fi
make -i test-force || true
make -i test-force-pl || true
%install
RBR=$RPM_BUILD_ROOT
@ -740,6 +740,15 @@ fi
# itself - note that they must be ordered by date (important when
# merging BK trees)
%changelog
* Mon Jul 10 2006 Joerg Bruehe <joerg@mysql.com>
- Fix a typing error in the "make" target for the Perl script to run the tests.
* Tue Jul 04 2006 Joerg Bruehe <joerg@mysql.com>
- Use the Perl script to run the tests, because it will automatically check
whether the server is configured with SSL.
* Tue Jun 27 2006 Joerg Bruehe <joerg@mysql.com>
- move "mysqldumpslow" from the client RPM to the server RPM (bug#20216)