2765 Pekka Nousiainen 2008-09-16
wl#4391 21.diff
Alter table.
modified:
storage/ndb/src/common/debugger/signaldata/AlterTab.cpp
storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.cpp
storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.hpp
storage/ndb/src/kernel/vm/mt.cpp
2764 Pekka Nousiainen 2008-09-16
wl#4391 20.diff
User-BACKUP. Single-worker version.
modified:
storage/ndb/src/kernel/blocks/backup/Backup.cpp
storage/ndb/src/kernel/blocks/backup/Backup.hpp
storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
storage/ndb/src/mgmsrv/MgmtSrvr.cpp
=== modified file 'storage/ndb/src/common/debugger/signaldata/AlterTab.cpp'
--- a/storage/ndb/src/common/debugger/signaldata/AlterTab.cpp 2007-12-25 16:15:08 +0000
+++ b/storage/ndb/src/common/debugger/signaldata/AlterTab.cpp 2008-09-16 18:33:52 +0000
@@ -29,10 +29,10 @@ printALTER_TAB_REQ(FILE* output, const U
fprintf(output, " gci: %u", sig->gci);
fprintf(output, " changeMask: 0x%x", sig->changeMask);
fprintf(output, "\n");
- fprintf(output, "connectPtr: %u", sig->connectPtr);
- fprintf(output, "noOfNewAttr: %u", sig->noOfNewAttr);
- fprintf(output, "newNoOfCharsets: %u", sig->newNoOfCharsets);
- fprintf(output, "newNoOfKeyAttrs: %u", sig->newNoOfKeyAttrs);
+ fprintf(output, " connectPtr: %u", sig->connectPtr);
+ fprintf(output, " noOfNewAttr: %u", sig->noOfNewAttr);
+ fprintf(output, " newNoOfCharsets: %u", sig->newNoOfCharsets);
+ fprintf(output, " newNoOfKeyAttrs: %u", sig->newNoOfKeyAttrs);
fprintf(output, "\n");
return true;
}
@@ -43,7 +43,7 @@ printALTER_TAB_CONF(FILE* output, const
const AlterTabConf* sig = (const AlterTabConf*)theData;
fprintf(output, " senderRef: 0x%x", sig->senderRef);
fprintf(output, " senderData: %u", sig->senderData);
- fprintf(output, "connectPtr: %u", sig->connectPtr);
+ fprintf(output, " connectPtr: %u", sig->connectPtr);
fprintf(output, "\n");
return true;
}
=== modified file 'storage/ndb/src/kernel/blocks/backup/Backup.cpp'
--- a/storage/ndb/src/kernel/blocks/backup/Backup.cpp 2008-09-12 12:55:29 +0000
+++ b/storage/ndb/src/kernel/blocks/backup/Backup.cpp 2008-09-16 18:29:47 +0000
@@ -250,7 +250,7 @@ Backup::execCONTINUEB(Signal* signal)
Uint32 * dst;
if (!filePtr.p->operation.dataBuffer.getWritePtr(&dst, sz))
{
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 4);
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 4);
return;
}
@@ -288,7 +288,7 @@ Backup::execCONTINUEB(Signal* signal)
signal->theData[1] = ptr_I;
signal->theData[2] = tabPtr_I;
signal->theData[3] = fragPtr_I;
- sendSignal(BACKUP_REF, GSN_CONTINUEB, signal, 4, JBB);
+ sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
return;
}
case BackupContinueB::START_FILE_THREAD:
@@ -365,7 +365,7 @@ Backup::execCONTINUEB(Signal* signal)
if (ERROR_INSERTED(10039))
{
jam();
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 300,
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 300,
signal->getLength());
return;
}
@@ -374,9 +374,29 @@ Backup::execCONTINUEB(Signal* signal)
jam();
CLEAR_ERROR_INSERT_VALUE;
ndbout_c("Resuming backup");
- memmove(signal->theData, signal->theData + 1,
+
+ Uint32 filePtr_I = Tdata1;
+ BackupFilePtr filePtr;
+ c_backupFilePool.getPtr(filePtr, filePtr_I);
+ BackupRecordPtr ptr;
+ c_backupPool.getPtr(ptr, filePtr.p->backupPtr);
+ TablePtr tabPtr;
+ findTable(ptr, tabPtr, filePtr.p->tableId);
+ FragmentPtr fragPtr;
+ tabPtr.p->fragments.getPtr(fragPtr, filePtr.p->fragmentNo);
+
+ BlockReference lqhRef = 0;
+ if (ptr.p->is_lcp()) {
+ lqhRef = calcInstanceBlockRef(DBLQH);
+ } else {
+ const Uint32 instanceKey = fragPtr.p->lqhInstanceKey;
+ ndbrequire(instanceKey != 0);
+ lqhRef = numberToRef(DBLQH, instanceKey, getOwnNodeId());
+ }
+
+ memmove(signal->theData, signal->theData + 2,
4*ScanFragNextReq::SignalLength);
- BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
+
sendSignal(lqhRef, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
return ;
@@ -412,7 +432,7 @@ Backup::execBACKUP_LOCK_TAB_CONF(Signal
signal->theData[1] = ptr.i;
signal->theData[2] = tabPtr.i;
signal->theData[3] = 0; // Start from first fragment of next table
- sendSignal(BACKUP_REF, GSN_CONTINUEB, signal, 4, JBB);
+ sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
return;
}
case BackupLockTab::GET_TABINFO_CONF:
@@ -496,7 +516,7 @@ Backup::execDUMP_STATE_ORD(Signal* signa
BackupReq * req = (BackupReq*)signal->getDataPtrSend();
req->senderData = 23;
req->backupDataLen = 0;
- sendSignal(BACKUP_REF, GSN_BACKUP_REQ,signal,BackupReq::SignalLength, JBB);
+ sendSignal(reference(), GSN_BACKUP_REQ,signal,BackupReq::SignalLength, JBB);
startTime = NdbTick_CurrentMillisecond();
return;
}
@@ -1415,7 +1435,8 @@ Backup::sendDefineBackupReq(Signal *sign
ptr.p->masterData.gsn = GSN_DEFINE_BACKUP_REQ;
ptr.p->masterData.sendCounter = ptr.p->nodes;
- NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, instance());
+ NodeReceiverGroup rg(backupBlockNo, ptr.p->nodes);
sendSignal(rg, GSN_DEFINE_BACKUP_REQ, signal,
DefineBackupReq::SignalLength, JBB);
@@ -1774,7 +1795,8 @@ Backup::sendStartBackup(Signal* signal,
*/
ptr.p->masterData.gsn = GSN_START_BACKUP_REQ;
ptr.p->masterData.sendCounter = ptr.p->nodes;
- NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, instance());
+ NodeReceiverGroup rg(backupBlockNo, ptr.p->nodes);
sendSignal(rg, GSN_START_BACKUP_REQ, signal,
StartBackupReq::SignalLength, JBB);
}
@@ -1977,7 +1999,7 @@ Backup::nextFragment(Signal* signal, Bac
req->count = 0;
ptr.p->masterData.sendCounter++;
- const BlockReference ref = numberToRef(BACKUP, nodeId);
+ const BlockReference ref = numberToRef(BACKUP, instance(), nodeId);
sendSignal(ref, GSN_BACKUP_FRAGMENT_REQ, signal,
BackupFragmentReq::SignalLength, JBB);
}//if
@@ -2077,7 +2099,8 @@ Backup::execBACKUP_FRAGMENT_CONF(Signal*
rep->noOfTableRowsHigh = (Uint32)(tabPtr.p->noOfRecords >> 32);
rep->noOfFragmentRowsLow = (Uint32)(noOfRecords & 0xFFFFFFFF);
rep->noOfFragmentRowsHigh = (Uint32)(noOfRecords >> 32);
- NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, instance());
+ NodeReceiverGroup rg(backupBlockNo, ptr.p->nodes);
sendSignal(rg, GSN_BACKUP_FRAGMENT_COMPLETE_REP, signal,
BackupFragmentCompleteRep::SignalLength, JBB);
}
@@ -2248,7 +2271,7 @@ Backup::sendDropTrig(Signal* signal, Bac
signal->theData[1] = ptr.i;
signal->theData[2] = tabPtr.i;
signal->theData[3] = 0;
- sendSignal(BACKUP_REF, GSN_CONTINUEB, signal, 4, JBB);
+ sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
}
else
{
@@ -2387,7 +2410,8 @@ Backup::sendStopBackup(Signal* signal, B
ptr.p->masterData.gsn = GSN_STOP_BACKUP_REQ;
ptr.p->masterData.sendCounter = ptr.p->nodes;
- NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, instance());
+ NodeReceiverGroup rg(backupBlockNo, ptr.p->nodes);
sendSignal(rg, GSN_STOP_BACKUP_REQ, signal,
StopBackupReq::SignalLength, JBB);
}
@@ -2577,7 +2601,8 @@ Backup::masterAbort(Signal* signal, Back
ord->backupId = ptr.p->backupId;
ord->backupPtr = ptr.i;
ord->senderData= ptr.i;
- NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, instance());
+ NodeReceiverGroup rg(backupBlockNo, ptr.p->nodes);
switch(ptr.p->masterData.gsn){
case GSN_DEFINE_BACKUP_REQ:
@@ -2628,7 +2653,7 @@ Backup::abort_scan(Signal * signal, Back
if(fragPtr.p->scanning != 0 && ptr.p->nodes.get(nodeId)) {
jam();
- const BlockReference ref = numberToRef(BACKUP, nodeId);
+ const BlockReference ref = calcInstanceBlockRef(BACKUP, nodeId);
sendSignal(ref, GSN_ABORT_BACKUP_ORD, signal,
AbortBackupOrd::SignalLength, JBB);
@@ -3184,7 +3209,7 @@ Backup::openFilesReply(Signal* signal,
signal->theData[0] = BackupContinueB::START_FILE_THREAD;
signal->theData[1] = filePtr.i;
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 2);
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2);
}
else
{
@@ -3581,6 +3606,7 @@ Backup::execDIH_SCAN_TAB_CONF(Signal* si
fragPtr.p->scanning = 0;
fragPtr.p->tableId = tableId;
fragPtr.p->fragmentId = i;
+ fragPtr.p->lqhInstanceKey = 0;
fragPtr.p->node = 0;
}//for
@@ -3654,6 +3680,7 @@ Backup::execDIH_SCAN_GET_NODES_CONF(Sign
const Uint32 nodeCount = conf->count;
const Uint32 tableId = conf->tableId;
const Uint32 fragNo = conf->fragId;
+ const Uint32 instanceKey = conf->instanceKey;
ndbrequire(nodeCount > 0 && nodeCount <= MAX_REPLICAS);
@@ -3665,6 +3692,7 @@ Backup::execDIH_SCAN_GET_NODES_CONF(Sign
FragmentPtr fragPtr;
tabPtr.p->fragments.getPtr(fragPtr, fragNo);
+ fragPtr.p->lqhInstanceKey = instanceKey;
fragPtr.p->node = conf->nodes[0];
@@ -3718,7 +3746,7 @@ Backup::execSTART_BACKUP_REQ(Signal* sig
filePtr.p->m_flags |= BackupFile::BF_FILE_THREAD;
signal->theData[0] = BackupContinueB::START_FILE_THREAD;
signal->theData[1] = filePtr.i;
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 2);
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2);
}//if
}//for
@@ -3799,7 +3827,7 @@ Backup::execBACKUP_FRAGMENT_REQ(Signal*
if(!filePtr.p->operation.newFragment(tableId, fragPtr.p->fragmentId)) {
jam();
req->count = count + 1;
- sendSignalWithDelay(BACKUP_REF, GSN_BACKUP_FRAGMENT_REQ, signal, 50,
+ sendSignalWithDelay(reference(), GSN_BACKUP_FRAGMENT_REQ, signal, 50,
signal->length());
ptr.p->slaveState.setState(STARTED);
return;
@@ -3846,7 +3874,14 @@ Backup::execBACKUP_FRAGMENT_REQ(Signal*
req->clientOpPtr= filePtr.i;
req->batch_size_rows= parallelism;
req->batch_size_bytes= 0;
- BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
+ BlockReference lqhRef = 0;
+ if (ptr.p->is_lcp()) {
+ lqhRef = calcInstanceBlockRef(DBLQH);
+ } else {
+ const Uint32 instanceKey = fragPtr.p->lqhInstanceKey;
+ ndbrequire(instanceKey != 0);
+ lqhRef = numberToRef(DBLQH, instanceKey, getOwnNodeId());
+ }
sendSignal(lqhRef, GSN_SCAN_FRAGREQ, signal,
ScanFragReq::SignalLength, JBB);
@@ -4105,7 +4140,7 @@ Backup::fragmentCompleted(Signal* signal
jam();
signal->theData[0] = BackupContinueB::BUFFER_FULL_FRAG_COMPLETE;
signal->theData[1] = filePtr.i;
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2);
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 50, 2);
return;
}//if
@@ -4157,7 +4192,21 @@ void
Backup::checkScan(Signal* signal, BackupFilePtr filePtr)
{
OperationRecord & op = filePtr.p->operation;
- BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
+ BlockReference lqhRef = 0;
+ {
+ BackupRecordPtr ptr LINT_SET_PTR;
+ c_backupPool.getPtr(ptr, filePtr.p->backupPtr);
+ if (ptr.p->is_lcp()) {
+ lqhRef = calcInstanceBlockRef(DBLQH);
+ } else {
+ TablePtr tabPtr;
+ ndbrequire(findTable(ptr, tabPtr, filePtr.p->tableId));
+ FragmentPtr fragPtr;
+ tabPtr.p->fragments.getPtr(fragPtr, filePtr.p->fragmentNo);
+ const Uint32 instanceKey = fragPtr.p->lqhInstanceKey;
+ lqhRef = numberToRef(DBLQH, instanceKey, getOwnNodeId());
+ }
+ }
if(filePtr.p->errorCode != 0)
{
@@ -4196,11 +4245,12 @@ Backup::checkScan(Signal* signal, Backup
filePtr.p->tableId,
filePtr.p->fragmentNo,
filePtr.p->operation.noOfRecords);
- memmove(signal->theData+1, signal->theData,
+ memmove(signal->theData+2, signal->theData,
4*ScanFragNextReq::SignalLength);
signal->theData[0] = BackupContinueB::ZDELAY_SCAN_NEXT;
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal,
- 300, 1+ScanFragNextReq::SignalLength);
+ signal->theData[1] = filePtr.i;
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal,
+ 300, 2+ScanFragNextReq::SignalLength);
return;
}
if(ERROR_INSERTED(10032))
@@ -4240,7 +4290,7 @@ Backup::checkScan(Signal* signal, Backup
signal->theData[0] = BackupContinueB::BUFFER_FULL_SCAN;
signal->theData[1] = filePtr.i;
- sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2);
+ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 50, 2);
}
void
@@ -4612,7 +4662,8 @@ Backup::sendAbortBackupOrd(Signal* signa
const Uint32 nodeId = node.p->nodeId;
if(node.p->alive && ptr.p->nodes.get(nodeId)) {
jam();
- sendSignal(numberToRef(BACKUP, nodeId), GSN_ABORT_BACKUP_ORD, signal,
+ BlockReference ref = calcInstanceBlockRef(BACKUP, nodeId);
+ sendSignal(ref, GSN_ABORT_BACKUP_ORD, signal,
AbortBackupOrd::SignalLength, JBB);
}//if
}//for
@@ -4868,7 +4919,8 @@ Backup::execABORT_BACKUP_ORD(Signal* sig
#ifdef DEBUG_ABORT
ndbout_c("---- Forward to master nodeId = %u", getMasterNodeId());
#endif
- sendSignal(calcBackupBlockRef(getMasterNodeId()), GSN_ABORT_BACKUP_ORD,
+ BlockReference ref = calcInstanceBlockRef(BACKUP, getMasterNodeId());
+ sendSignal(ref, GSN_ABORT_BACKUP_ORD,
signal, AbortBackupOrd::SignalLength, JBB);
return;
}
=== modified file 'storage/ndb/src/kernel/blocks/backup/Backup.hpp'
--- a/storage/ndb/src/kernel/blocks/backup/Backup.hpp 2008-07-26 05:13:40 +0000
+++ b/storage/ndb/src/kernel/blocks/backup/Backup.hpp 2008-09-16 18:29:47 +0000
@@ -180,6 +180,7 @@ public:
Uint32 tableId;
Uint16 node;
Uint16 fragmentId;
+ Uint8 lqhInstanceKey;
Uint8 scanned; // 0 = not scanned x = scanned by node x
Uint8 scanning; // 0 = not scanning x = scanning on node x
Uint8 lcp_no;
=== modified file 'storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.cpp'
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.cpp 2008-08-23 06:32:32 +0000
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.cpp 2008-09-16 18:33:52 +0000
@@ -59,6 +59,11 @@ DblqhProxy::DblqhProxy(Block_context& ct
addRecSignal(GSN_DROP_TAB_CONF, &DblqhProxy::execDROP_TAB_CONF);
addRecSignal(GSN_DROP_TAB_REF, &DblqhProxy::execDROP_TAB_REF);
+ // GSN_ALTER_TAB_REQ
+ addRecSignal(GSN_ALTER_TAB_REQ, &DblqhProxy::execALTER_TAB_REQ);
+ addRecSignal(GSN_ALTER_TAB_CONF, &DblqhProxy::execALTER_TAB_CONF);
+ addRecSignal(GSN_ALTER_TAB_REF, &DblqhProxy::execALTER_TAB_REF);
+
// GSN_START_RECREQ
addRecSignal(GSN_START_RECREQ, &DblqhProxy::execSTART_RECREQ);
addRecSignal(GSN_START_RECCONF, &DblqhProxy::execSTART_RECCONF);
@@ -726,13 +731,109 @@ DblqhProxy::sendDROP_TAB_CONF(Signal* si
ref->senderData = ss.m_req.senderData;
ref->tableId = ss.m_req.tableId;
ref->errorCode = ss.m_error;
- sendSignal(dictRef, GSN_DROP_TAB_CONF,
+ sendSignal(dictRef, GSN_DROP_TAB_REF,
signal, DropTabConf::SignalLength, JBB);
}
ssRelease<Ss_DROP_TAB_REQ>(ssId);
}
+// GSN_ALTER_TAB_REQ
+
+void
+DblqhProxy::execALTER_TAB_REQ(Signal* signal)
+{
+ const AlterTabReq* req = (const AlterTabReq*)signal->getDataPtr();
+ Uint32 ssId = getSsId(req);
+ Ss_ALTER_TAB_REQ& ss = ssSeize<Ss_ALTER_TAB_REQ>(ssId);
+ ss.m_req = *req;
+ ndbrequire(signal->getLength() == AlterTabReq::SignalLength);
+
+ {
+ SectionHandle handle(this, signal);
+ ss.m_sections = handle.m_cnt;
+ ndbrequire(ss.m_sections <= 1);
+ if (ss.m_sections >= 1) {
+ ss.m_sz0 = handle.m_ptr[0].p->m_sz;
+ ndbrequire(ss.m_sz0 <= ss.MaxSection0);
+ ::copy(ss.m_section0, handle.m_ptr[0]);
+ }
+ releaseSections(handle);
+ }
+
+ sendREQ(signal, ss);
+}
+
+void
+DblqhProxy::sendALTER_TAB_REQ(Signal* signal, Uint32 ssId)
+{
+ Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
+
+ AlterTabReq* req = (AlterTabReq*)signal->getDataPtrSend();
+ *req = ss.m_req;
+ req->senderRef = reference();
+ req->senderData = ssId;
+ if (ss.m_sections == 0) {
+ jam();
+ sendSignal(workerRef(ss.m_worker), GSN_ALTER_TAB_REQ,
+ signal, AlterTabReq::SignalLength, JBB);
+ } else {
+ jam();
+ LinearSectionPtr ptr[3];
+ ptr[0].sz = ss.m_sz0;
+ ptr[0].p = ss.m_section0;
+ sendSignal(workerRef(ss.m_worker), GSN_ALTER_TAB_REQ,
+ signal, AlterTabReq::SignalLength, JBB, ptr, 1);
+ }
+}
+
+void
+DblqhProxy::execALTER_TAB_CONF(Signal* signal)
+{
+ const AlterTabConf* conf = (const AlterTabConf*)signal->getDataPtr();
+ Uint32 ssId = getSsId(conf);
+ Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
+ recvCONF(signal, ss);
+}
+
+void
+DblqhProxy::execALTER_TAB_REF(Signal* signal)
+{
+ const AlterTabRef* ref = (const AlterTabRef*)signal->getDataPtr();
+ Uint32 ssId = getSsId(ref);
+ Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
+ recvREF(signal, ss, ref->errorCode);
+}
+
+void
+DblqhProxy::sendALTER_TAB_CONF(Signal* signal, Uint32 ssId)
+{
+ Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
+ BlockReference dictRef = ss.m_req.senderRef;
+
+ if (!lastReply(ss))
+ return;
+
+ if (ss.m_error == 0) {
+ jam();
+ AlterTabConf* conf = (AlterTabConf*)signal->getDataPtrSend();
+ conf->senderRef = reference();
+ conf->senderData = ss.m_req.senderData;
+ sendSignal(dictRef, GSN_ALTER_TAB_CONF,
+ signal, AlterTabConf::SignalLength, JBB);
+ } else {
+ jam();
+ AlterTabRef* ref = (AlterTabRef*)signal->getDataPtrSend();
+ ref->senderRef = reference();
+ ref->senderData = ss.m_req.senderData;
+ ref->errorCode = ss.m_error;
+ sendSignal(dictRef, GSN_ALTER_TAB_REF,
+ signal, AlterTabConf::SignalLength, JBB);
+ }
+
+ ssRelease<Ss_ALTER_TAB_REQ>(ssId);
+}
+
// GSN_START_RECREQ
void
=== modified file 'storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.hpp'
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.hpp 2008-08-23 06:32:32 +0000
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhProxy.hpp 2008-09-16 18:33:52 +0000
@@ -24,6 +24,7 @@
#include <signaldata/GCP.hpp>
#include <signaldata/PrepDropTab.hpp>
#include <signaldata/DropTab.hpp>
+#include <signaldata/AlterTab.hpp>
#include <signaldata/StartRec.hpp>
#include <signaldata/LqhTransReq.hpp>
#include <signaldata/LqhTransConf.hpp>
@@ -230,6 +231,41 @@ protected:
void execDROP_TAB_REF(Signal*);
void sendDROP_TAB_CONF(Signal*, Uint32 ssId);
+ // GSN_ALTER_TAB_REQ
+ struct Ss_ALTER_TAB_REQ : SsParallel {
+ AlterTabReq m_req;
+ Uint32 m_sections;
+ // wl4391_todo check max length in various cases
+ enum { MaxSection0 = 2 * MAX_ATTRIBUTES_IN_TABLE };
+ Uint32 m_sz0;
+ Uint32 m_section0[MaxSection0];
+ Ss_ALTER_TAB_REQ() {
+ m_sendREQ = (SsFUNC)&DblqhProxy::sendALTER_TAB_REQ;
+ m_sendCONF = (SsFUNC)&DblqhProxy::sendALTER_TAB_CONF;
+ m_sections = 0;
+ m_sz0 = 0;
+ }
+ enum { poolSize = 1 };
+ static SsPool<Ss_ALTER_TAB_REQ>& pool(LocalProxy* proxy) {
+ return ((DblqhProxy*)proxy)->c_ss_ALTER_TAB_REQ;
+ }
+ };
+ SsPool<Ss_ALTER_TAB_REQ> c_ss_ALTER_TAB_REQ;
+ Uint32 getSsId(const AlterTabReq* req) {
+ return SsIdBase | req->tableId;
+ }
+ Uint32 getSsId(const AlterTabConf* conf) {
+ return conf->senderData;
+ }
+ Uint32 getSsId(const AlterTabRef* ref) {
+ return ref->senderData;
+ }
+ void execALTER_TAB_REQ(Signal*);
+ void sendALTER_TAB_REQ(Signal*, Uint32 ssId);
+ void execALTER_TAB_CONF(Signal*);
+ void execALTER_TAB_REF(Signal*);
+ void sendALTER_TAB_CONF(Signal*, Uint32 ssId);
+
// GSN_START_RECREQ
struct Ss_START_RECREQ : SsParallel {
StartRecReq m_req;
=== modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp 2008-08-11 11:48:10 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp 2008-09-16 18:29:47 +0000
@@ -246,10 +246,11 @@ void Dbtup::sendReadAttrinfo(Signal* sig
* The UTIL/TC blocks are in another thread (in multi-threaded ndbd), so
* must use sendSignal().
*
- * In MT LQH only LQH and BACKUP are in same thread.
+ * In MT LQH only LQH and BACKUP are in same thread, and BACKUP only
+ * in LCP case since user-backup uses single worker.
*/
BlockNumber blockMain = blockToMain(block);
- if (blockMain == DBLQH || blockMain == BACKUP)
+ if (blockMain == DBLQH)
{
EXECUTE_DIRECT(blockMain, GSN_TRANSID_AI, signal, 3 + ToutBufIndex);
jamEntry();
@@ -260,6 +261,13 @@ void Dbtup::sendReadAttrinfo(Signal* sig
EXECUTE_DIRECT(blockMain, GSN_TRANSID_AI, signal, 3 + ToutBufIndex, 0);
jamEntry();
}
+ else if (blockMain == BACKUP)
+ {
+ Uint32 iNo = blockToInstance(block);
+ // wl4391_todo maybe not MT safe in non-LCP case
+ EXECUTE_DIRECT(blockMain, GSN_TRANSID_AI, signal, 3 + ToutBufIndex, iNo);
+ jamEntry();
+ }
else
{
jam();
=== modified file 'storage/ndb/src/kernel/vm/mt.cpp'
--- a/storage/ndb/src/kernel/vm/mt.cpp 2008-08-27 20:27:20 +0000
+++ b/storage/ndb/src/kernel/vm/mt.cpp 2008-09-16 18:33:52 +0000
@@ -1823,11 +1823,16 @@ execute_signals(thr_data *selfptr, thr_j
#ifdef VM_TRACE
if (globalData.testOn) { //wl4391_todo segments
+ SegmentedSectionPtr ptr[3];
+ ptr[0].i = sig->m_sectionPtrI[0];
+ ptr[1].i = sig->m_sectionPtrI[1];
+ ptr[2].i = sig->m_sectionPtrI[2];
+ ::getSections(seccnt, ptr);
globalSignalLoggers.executeSignal(*s,
0,
&sig->theData[0],
- globalData.ownId);
-
+ globalData.ownId,
+ ptr, seccnt);
}
#endif
=== modified file 'storage/ndb/src/mgmsrv/MgmtSrvr.cpp'
--- a/storage/ndb/src/mgmsrv/MgmtSrvr.cpp 2008-09-12 12:55:29 +0000
+++ b/storage/ndb/src/mgmsrv/MgmtSrvr.cpp 2008-09-16 18:29:47 +0000
@@ -2900,14 +2900,19 @@ MgmtSrvr::startBackup(Uint32& backupId,
SimpleSignal ssig;
BackupReq* req = CAST_PTR(BackupReq, ssig.getDataPtrSend());
+ /*
+ * Single-threaded backup. Set instance key 1. In the kernel
+ * this maps to main instance 0 or worker instance 1 (if MT LQH).
+ */
+ BlockNumber backupBlockNo = numberToBlock(BACKUP, 1);
if(input_backupId > 0)
{
- ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ,
+ ssig.set(ss, TestOrd::TraceAPI, backupBlockNo, GSN_BACKUP_REQ,
BackupReq::SignalLength);
req->inputBackupId = input_backupId;
}
else
- ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ,
+ ssig.set(ss, TestOrd::TraceAPI, backupBlockNo, GSN_BACKUP_REQ,
BackupReq::SignalLength - 1);
req->senderData = 19;
| Thread |
|---|
| • bzr push into mysql-5.1 branch (pekka:2764 to 2765) WL#4391 | Pekka Nousiainen | 16 Sep |
