bzr push into mysql-5.1 branch (pekka:2737 to 2738) WL#4391

[Pekka Nousiainen]

 2738 Pekka Nousiainen	2008-08-27
      wl#4391 19.diff
      SUMA (subscription triggers).
modified:
  storage/ndb/src/kernel/blocks/LocalProxy.cpp
  storage/ndb/src/kernel/blocks/LocalProxy.hpp
  storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
  storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
  storage/ndb/src/kernel/blocks/suma/Suma.cpp

 2737 Pekka Nousiainen	2008-08-27
      wl#4391 18.diff
      Indexes (triggers and build).
modified:
  storage/ndb/src/kernel/blocks/LocalProxy.cpp
  storage/ndb/src/kernel/blocks/LocalProxy.hpp
  storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
  storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp
  storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp
  storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp
  storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp
  storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp
  storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
  storage/ndb/src/kernel/blocks/suma/Suma.cpp
  storage/ndb/src/kernel/blocks/suma/Suma.hpp

=== modified file 'storage/ndb/src/kernel/blocks/LocalProxy.cpp'
--- a/storage/ndb/src/kernel/blocks/LocalProxy.cpp	2008-08-23 06:11:28 +0000
+++ b/storage/ndb/src/kernel/blocks/LocalProxy.cpp	2008-08-27 08:00:52 +0000
@@ -66,6 +66,16 @@ LocalProxy::LocalProxy(BlockNumber block
 
   // GSN_TIME_SIGNAL
   addRecSignal(GSN_TIME_SIGNAL, &LocalProxy::execTIME_SIGNAL);
+
+  // GSN_CREATE_TRIG_IMPL_REQ
+  addRecSignal(GSN_CREATE_TRIG_IMPL_REQ, &LocalProxy::execCREATE_TRIG_IMPL_REQ);
+  addRecSignal(GSN_CREATE_TRIG_IMPL_CONF, &LocalProxy::execCREATE_TRIG_IMPL_CONF);
+  addRecSignal(GSN_CREATE_TRIG_IMPL_REF, &LocalProxy::execCREATE_TRIG_IMPL_REF);
+
+  // GSN_DROP_TRIG_IMPL_REQ
+  addRecSignal(GSN_DROP_TRIG_IMPL_REQ, &LocalProxy::execDROP_TRIG_IMPL_REQ);
+  addRecSignal(GSN_DROP_TRIG_IMPL_CONF, &LocalProxy::execDROP_TRIG_IMPL_CONF);
+  addRecSignal(GSN_DROP_TRIG_IMPL_REF, &LocalProxy::execDROP_TRIG_IMPL_REF);
 }
 
 LocalProxy::~LocalProxy()
@@ -730,4 +740,160 @@ LocalProxy::sendTIME_SIGNAL(Signal* sign
              signal, 1, JBB);
 }
 
+// GSN_CREATE_TRIG_IMPL_REQ
+
+void
+LocalProxy::execCREATE_TRIG_IMPL_REQ(Signal* signal)
+{
+  if (ssQueue<Ss_CREATE_TRIG_IMPL_REQ>(signal))
+    return;
+  const CreateTrigImplReq* req = (const CreateTrigImplReq*)signal->getDataPtr();
+  Ss_CREATE_TRIG_IMPL_REQ& ss = ssSeize<Ss_CREATE_TRIG_IMPL_REQ>();
+  ss.m_req = *req;
+  ndbrequire(signal->getLength() == CreateTrigImplReq::SignalLength);
+  sendREQ(signal, ss);
+}
+
+void
+LocalProxy::sendCREATE_TRIG_IMPL_REQ(Signal* signal, Uint32 ssId)
+{
+  Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind<Ss_CREATE_TRIG_IMPL_REQ>(ssId);
+
+  CreateTrigImplReq* req = (CreateTrigImplReq*)signal->getDataPtrSend();
+  *req = ss.m_req;
+  req->senderRef = reference();
+  req->senderData = ssId;
+  sendSignal(workerRef(ss.m_worker), GSN_CREATE_TRIG_IMPL_REQ,
+             signal, CreateTrigImplReq::SignalLength, JBB);
+}
+
+void
+LocalProxy::execCREATE_TRIG_IMPL_CONF(Signal* signal)
+{
+  const CreateTrigImplConf* conf = (const CreateTrigImplConf*)signal->getDataPtr();
+  Uint32 ssId = conf->senderData;
+  Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind<Ss_CREATE_TRIG_IMPL_REQ>(ssId);
+  recvCONF(signal, ss);
+}
+
+void
+LocalProxy::execCREATE_TRIG_IMPL_REF(Signal* signal)
+{
+  const CreateTrigImplRef* ref = (const CreateTrigImplRef*)signal->getDataPtr();
+  Uint32 ssId = ref->senderData;
+  Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind<Ss_CREATE_TRIG_IMPL_REQ>(ssId);
+  recvREF(signal, ss, ref->errorCode);
+}
+
+void
+LocalProxy::sendCREATE_TRIG_IMPL_CONF(Signal* signal, Uint32 ssId)
+{
+  Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind<Ss_CREATE_TRIG_IMPL_REQ>(ssId);
+  BlockReference dictRef = ss.m_req.senderRef;
+
+  if (!lastReply(ss))
+    return;
+
+  if (ss.m_error == 0) {
+    jam();
+    CreateTrigImplConf* conf = (CreateTrigImplConf*)signal->getDataPtrSend();
+    conf->senderRef = reference();
+    conf->senderData = ss.m_req.senderData;
+    conf->tableId = ss.m_req.tableId;
+    conf->triggerId = ss.m_req.triggerId;
+    conf->triggerInfo = ss.m_req.triggerInfo;
+    sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_CONF,
+               signal, CreateTrigImplConf::SignalLength, JBB);
+  } else {
+    CreateTrigImplRef* ref = (CreateTrigImplRef*)signal->getDataPtrSend();
+    ref->senderRef = reference();
+    ref->senderData = ss.m_req.senderData;
+    ref->tableId = ss.m_req.tableId;
+    ref->triggerId = ss.m_req.triggerId;
+    ref->triggerInfo = ss.m_req.triggerInfo;
+    ref->errorCode = ss.m_error;
+    sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_REF,
+               signal, CreateTrigImplRef::SignalLength, JBB);
+  }
+
+  ssRelease<Ss_CREATE_TRIG_IMPL_REQ>(ssId);
+}
+
+// GSN_DROP_TRIG_IMPL_REQ
+
+void
+LocalProxy::execDROP_TRIG_IMPL_REQ(Signal* signal)
+{
+  if (ssQueue<Ss_DROP_TRIG_IMPL_REQ>(signal))
+    return;
+  const DropTrigImplReq* req = (const DropTrigImplReq*)signal->getDataPtr();
+  Ss_DROP_TRIG_IMPL_REQ& ss = ssSeize<Ss_DROP_TRIG_IMPL_REQ>();
+  ss.m_req = *req;
+  ndbrequire(signal->getLength() == DropTrigImplReq::SignalLength);
+  sendREQ(signal, ss);
+}
+
+void
+LocalProxy::sendDROP_TRIG_IMPL_REQ(Signal* signal, Uint32 ssId)
+{
+  Ss_DROP_TRIG_IMPL_REQ& ss = ssFind<Ss_DROP_TRIG_IMPL_REQ>(ssId);
+
+  DropTrigImplReq* req = (DropTrigImplReq*)signal->getDataPtrSend();
+  *req = ss.m_req;
+  req->senderRef = reference();
+  req->senderData = ssId;
+  sendSignal(workerRef(ss.m_worker), GSN_DROP_TRIG_IMPL_REQ,
+             signal, DropTrigImplReq::SignalLength, JBB);
+}
+
+void
+LocalProxy::execDROP_TRIG_IMPL_CONF(Signal* signal)
+{
+  const DropTrigImplConf* conf = (const DropTrigImplConf*)signal->getDataPtr();
+  Uint32 ssId = conf->senderData;
+  Ss_DROP_TRIG_IMPL_REQ& ss = ssFind<Ss_DROP_TRIG_IMPL_REQ>(ssId);
+  recvCONF(signal, ss);
+}
+
+void
+LocalProxy::execDROP_TRIG_IMPL_REF(Signal* signal)
+{
+  const DropTrigImplRef* ref = (const DropTrigImplRef*)signal->getDataPtr();
+  Uint32 ssId = ref->senderData;
+  Ss_DROP_TRIG_IMPL_REQ& ss = ssFind<Ss_DROP_TRIG_IMPL_REQ>(ssId);
+  recvREF(signal, ss, ref->errorCode);
+}
+
+void
+LocalProxy::sendDROP_TRIG_IMPL_CONF(Signal* signal, Uint32 ssId)
+{
+  Ss_DROP_TRIG_IMPL_REQ& ss = ssFind<Ss_DROP_TRIG_IMPL_REQ>(ssId);
+  BlockReference dictRef = ss.m_req.senderRef;
+
+  if (!lastReply(ss))
+    return;
+
+  if (ss.m_error == 0) {
+    jam();
+    DropTrigImplConf* conf = (DropTrigImplConf*)signal->getDataPtrSend();
+    conf->senderRef = reference();
+    conf->senderData = ss.m_req.senderData;
+    conf->tableId = ss.m_req.tableId;
+    conf->triggerId = ss.m_req.triggerId;
+    sendSignal(dictRef, GSN_DROP_TRIG_IMPL_CONF,
+               signal, DropTrigImplConf::SignalLength, JBB);
+  } else {
+    DropTrigImplRef* ref = (DropTrigImplRef*)signal->getDataPtrSend();
+    ref->senderRef = reference();
+    ref->senderData = ss.m_req.senderData;
+    ref->tableId = ss.m_req.tableId;
+    ref->triggerId = ss.m_req.triggerId;
+    ref->errorCode = ss.m_error;
+    sendSignal(dictRef, GSN_DROP_TRIG_IMPL_REF,
+               signal, DropTrigImplRef::SignalLength, JBB);
+  }
+
+  ssRelease<Ss_DROP_TRIG_IMPL_REQ>(ssId);
+}
+
 BLOCK_FUNCTIONS(LocalProxy)

=== modified file 'storage/ndb/src/kernel/blocks/LocalProxy.hpp'
--- a/storage/ndb/src/kernel/blocks/LocalProxy.hpp	2008-08-23 06:11:28 +0000
+++ b/storage/ndb/src/kernel/blocks/LocalProxy.hpp	2008-08-27 08:00:52 +0000
@@ -25,6 +25,8 @@
 #include <signaldata/ReadNodesConf.hpp>
 #include <signaldata/NodeFailRep.hpp>
 #include <signaldata/NFCompleteRep.hpp>
+#include <signaldata/CreateTrigImpl.hpp>
+#include <signaldata/DropTrigImpl.hpp>
 
 /*
  * Proxy blocks for MT LQH.
@@ -126,6 +128,10 @@ protected:
   template <class Ss>
   struct SsPool {
     Ss m_pool[Ss::poolSize];
+    Uint32 m_usage;
+    SsPool() {
+      m_usage = 0;
+    }
   };
 
   Uint32 c_ssIdSeq;
@@ -146,6 +152,7 @@ protected:
   Ss& ssSeize(Uint32 ssId) {
     SsPool<Ss>& sp = Ss::pool(this);
     ndbrequire(ssId != 0);
+    ndbrequire(sp.m_usage < Ss::poolSize);
     Ss* ssptr = 0;
     for (Uint32 i = 0; i < Ss::poolSize; i++) {
       Ss& ss = sp.m_pool[i];
@@ -158,6 +165,7 @@ protected:
       }
     }
     ndbrequire(ssptr != 0);
+    sp.m_usage++;
     return *ssptr;
   }
 
@@ -180,6 +188,7 @@ protected:
   template <class Ss>
   void ssRelease(Uint32 ssId) {
     SsPool<Ss>& sp = Ss::pool(this);
+    ndbrequire(sp.m_usage != 0);
     ndbrequire(ssId != 0);
     Ss* ssptr = 0;
     for (Uint32 i = 0; i < Ss::poolSize; i++) {
@@ -191,6 +200,7 @@ protected:
       }
     }
     ndbrequire(ssptr != 0);
+    sp.m_usage--;
   }
 
   template <class Ss>
@@ -198,6 +208,22 @@ protected:
     ssRelease<Ss>(ss.m_ssId);
   }
 
+  /*
+   * In some cases handle pool full via delayed signal.
+   * wl4391_todo maybe use CONTINUEB and guard against infinite loop.
+   */
+  template <class Ss>
+  bool ssQueue(Signal* signal) {
+    SsPool<Ss>& sp = Ss::pool(this);
+    if (sp.m_usage < Ss::poolSize)
+      return false;
+    ndbrequire(signal->getNoOfSections() == 0);
+    GlobalSignalNumber gsn = signal->header.theVerId_signalNumber & 0xFFFF;
+    sendSignalWithDelay(reference(), gsn,
+                        signal, 10, signal->length());
+    return true;
+  }
+
   // system info
 
   Uint32 c_typeOfStart;
@@ -395,6 +421,44 @@ protected:
   SsPool<Ss_TIME_SIGNAL> c_ss_TIME_SIGNAL;
   void execTIME_SIGNAL(Signal*);
   void sendTIME_SIGNAL(Signal*, Uint32 ssId);
+
+  // GSN_CREATE_TRIG_IMPL_REQ
+  struct Ss_CREATE_TRIG_IMPL_REQ : SsParallel {
+    CreateTrigImplReq m_req;
+    Ss_CREATE_TRIG_IMPL_REQ() {
+      m_sendREQ = &LocalProxy::sendCREATE_TRIG_IMPL_REQ;
+      m_sendCONF = &LocalProxy::sendCREATE_TRIG_IMPL_CONF;
+    }
+    enum { poolSize = 3 };
+    static SsPool<Ss_CREATE_TRIG_IMPL_REQ>& pool(LocalProxy* proxy) {
+      return proxy->c_ss_CREATE_TRIG_IMPL_REQ;
+    }
+  };
+  SsPool<Ss_CREATE_TRIG_IMPL_REQ> c_ss_CREATE_TRIG_IMPL_REQ;
+  void execCREATE_TRIG_IMPL_REQ(Signal*);
+  void sendCREATE_TRIG_IMPL_REQ(Signal*, Uint32 ssId);
+  void execCREATE_TRIG_IMPL_CONF(Signal*);
+  void execCREATE_TRIG_IMPL_REF(Signal*);
+  void sendCREATE_TRIG_IMPL_CONF(Signal*, Uint32 ssId);
+
+  // GSN_DROP_TRIG_IMPL_REQ
+  struct Ss_DROP_TRIG_IMPL_REQ : SsParallel {
+    DropTrigImplReq m_req;
+    Ss_DROP_TRIG_IMPL_REQ() {
+      m_sendREQ = &LocalProxy::sendDROP_TRIG_IMPL_REQ;
+      m_sendCONF = &LocalProxy::sendDROP_TRIG_IMPL_CONF;
+    }
+    enum { poolSize = 3 };
+    static SsPool<Ss_DROP_TRIG_IMPL_REQ>& pool(LocalProxy* proxy) {
+      return proxy->c_ss_DROP_TRIG_IMPL_REQ;
+    }
+  };
+  SsPool<Ss_DROP_TRIG_IMPL_REQ> c_ss_DROP_TRIG_IMPL_REQ;
+  void execDROP_TRIG_IMPL_REQ(Signal*);
+  void sendDROP_TRIG_IMPL_REQ(Signal*, Uint32 ssId);
+  void execDROP_TRIG_IMPL_CONF(Signal*);
+  void execDROP_TRIG_IMPL_REF(Signal*);
+  void sendDROP_TRIG_IMPL_CONF(Signal*, Uint32 ssId);
 };
 
 #endif

=== modified file 'storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp'
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2008-08-23 06:32:32 +0000
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2008-08-27 07:54:42 +0000
@@ -20376,7 +20376,10 @@ Dblqh::execCREATE_TRIG_IMPL_REQ(Signal* 
 {
   jamEntry();
 
-  sendSignal(DBTUP_REF, GSN_CREATE_TRIG_IMPL_REQ, signal,
+  CreateTrigImplReq* req = (CreateTrigImplReq*)signal->getDataPtrSend();
+  req->senderRef = reference();
+  BlockReference tupRef = calcInstanceBlockRef(DBTUP);
+  sendSignal(tupRef, GSN_CREATE_TRIG_IMPL_REQ, signal,
              CreateTrigImplReq::SignalLength, JBB);
 }
 
@@ -20385,7 +20388,8 @@ Dblqh::execCREATE_TRIG_IMPL_CONF(Signal*
 {
   jamEntry();
 
-  sendSignal(DBDICT_REF, GSN_CREATE_TRIG_IMPL_CONF, signal,
+  BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF;
+  sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_CONF, signal,
              CreateTrigImplConf::SignalLength, JBB);
 }
 
@@ -20394,7 +20398,8 @@ Dblqh::execCREATE_TRIG_IMPL_REF(Signal* 
 {
   jamEntry();
 
-  sendSignal(DBDICT_REF, GSN_CREATE_TRIG_IMPL_REF, signal,
+  BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF;
+  sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_REF, signal,
              CreateTrigImplRef::SignalLength, JBB);
 }
 
@@ -20403,7 +20408,10 @@ Dblqh::execDROP_TRIG_IMPL_REQ(Signal* si
 {
   jamEntry();
 
-  sendSignal(DBTUP_REF, GSN_DROP_TRIG_IMPL_REQ, signal,
+  DropTrigImplReq* req = (DropTrigImplReq*)signal->getDataPtrSend();
+  req->senderRef = reference();
+  BlockReference tupRef = calcInstanceBlockRef(DBTUP);
+  sendSignal(tupRef, GSN_DROP_TRIG_IMPL_REQ, signal,
              DropTrigImplReq::SignalLength, JBB);
 }
 
@@ -20412,7 +20420,8 @@ Dblqh::execDROP_TRIG_IMPL_CONF(Signal* s
 {
   jamEntry();
 
-  sendSignal(DBDICT_REF, GSN_DROP_TRIG_IMPL_CONF, signal,
+  BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF;
+  sendSignal(dictRef, GSN_DROP_TRIG_IMPL_CONF, signal,
              DropTrigImplConf::SignalLength, JBB);
 }
 
@@ -20421,7 +20430,8 @@ Dblqh::execDROP_TRIG_IMPL_REF(Signal* si
 {
   jamEntry();
 
-  sendSignal(DBDICT_REF, GSN_DROP_TRIG_IMPL_REF, signal,
+  BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF;
+  sendSignal(dictRef, GSN_DROP_TRIG_IMPL_REF, signal,
              DropTrigImplRef::SignalLength, JBB);
 }
 

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2008-08-07 11:52:50 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2008-08-27 08:00:52 +0000
@@ -897,9 +897,9 @@ struct TupTriggerData {
   TriggerActionTime::Value triggerActionTime;
   TriggerEvent::Value triggerEvent;
   /**
-   * Receiver block
+   * Receiver block reference
    */
-  Uint32 m_receiverBlock;
+  Uint32 m_receiverRef;
   
   /**
    * Monitor all replicas, i.e. trigger will fire on all nodes where tuples

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp	2008-08-15 11:01:41 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp	2008-08-27 07:54:42 +0000
@@ -22,6 +22,11 @@ DbtupProxy::DbtupProxy(Block_context& ct
   // GSN_DROP_TAB_REQ
   addRecSignal(GSN_DROP_TAB_REQ, &DbtupProxy::execDROP_TAB_REQ);
   addRecSignal(GSN_DROP_TAB_CONF, &DbtupProxy::execDROP_TAB_CONF);
+
+  // GSN_BUILD_INDX_IMPL_REQ
+  addRecSignal(GSN_BUILD_INDX_IMPL_REQ, &DbtupProxy::execBUILD_INDX_IMPL_REQ);
+  addRecSignal(GSN_BUILD_INDX_IMPL_CONF, &DbtupProxy::execBUILD_INDX_IMPL_CONF);
+  addRecSignal(GSN_BUILD_INDX_IMPL_REF, &DbtupProxy::execBUILD_INDX_IMPL_REF);
 }
 
 DbtupProxy::~DbtupProxy()
@@ -93,4 +98,75 @@ DbtupProxy::sendDROP_TAB_CONF(Signal* si
   ssRelease<Ss_DROP_TAB_REQ>(ssId);
 }
 
+// GSN_BUILD_INDX_IMPL_REQ
+
+void
+DbtupProxy::execBUILD_INDX_IMPL_REQ(Signal* signal)
+{
+  const BuildIndxImplReq* req = (const BuildIndxImplReq*)signal->getDataPtr();
+  Ss_BUILD_INDX_IMPL_REQ& ss = ssSeize<Ss_BUILD_INDX_IMPL_REQ>();
+  ss.m_req = *req;
+  ndbrequire(signal->getLength() == BuildIndxImplReq::SignalLength);
+  sendREQ(signal, ss);
+}
+
+void
+DbtupProxy::sendBUILD_INDX_IMPL_REQ(Signal* signal, Uint32 ssId)
+{
+  Ss_BUILD_INDX_IMPL_REQ& ss = ssFind<Ss_BUILD_INDX_IMPL_REQ>(ssId);
+
+  BuildIndxImplReq* req = (BuildIndxImplReq*)signal->getDataPtrSend();
+  *req = ss.m_req;
+  req->senderRef = reference();
+  req->senderData = ssId;
+  sendSignal(workerRef(ss.m_worker), GSN_BUILD_INDX_IMPL_REQ,
+             signal, BuildIndxImplReq::SignalLength, JBB);
+}
+
+void
+DbtupProxy::execBUILD_INDX_IMPL_CONF(Signal* signal)
+{
+  const BuildIndxImplConf* conf = (const BuildIndxImplConf*)signal->getDataPtr();
+  Uint32 ssId = conf->senderData;
+  Ss_BUILD_INDX_IMPL_REQ& ss = ssFind<Ss_BUILD_INDX_IMPL_REQ>(ssId);
+  recvCONF(signal, ss);
+}
+
+void
+DbtupProxy::execBUILD_INDX_IMPL_REF(Signal* signal)
+{
+  const BuildIndxImplRef* ref = (const BuildIndxImplRef*)signal->getDataPtr();
+  Uint32 ssId = ref->senderData;
+  Ss_BUILD_INDX_IMPL_REQ& ss = ssFind<Ss_BUILD_INDX_IMPL_REQ>(ssId);
+  recvREF(signal, ss, ref->errorCode);
+}
+
+void
+DbtupProxy::sendBUILD_INDX_IMPL_CONF(Signal* signal, Uint32 ssId)
+{
+  Ss_BUILD_INDX_IMPL_REQ& ss = ssFind<Ss_BUILD_INDX_IMPL_REQ>(ssId);
+  BlockReference dictRef = ss.m_req.senderRef;
+
+  if (!lastReply(ss))
+    return;
+
+  if (ss.m_error == 0) {
+    jam();
+    BuildIndxImplConf* conf = (BuildIndxImplConf*)signal->getDataPtrSend();
+    conf->senderRef = reference();
+    conf->senderData = ss.m_req.senderData;
+    sendSignal(dictRef, GSN_BUILD_INDX_IMPL_CONF,
+               signal, BuildIndxImplConf::SignalLength, JBB);
+  } else {
+    BuildIndxImplRef* ref = (BuildIndxImplRef*)signal->getDataPtrSend();
+    ref->senderRef = reference();
+    ref->senderData = ss.m_req.senderData;
+    ref->errorCode = ss.m_error;
+    sendSignal(dictRef, GSN_BUILD_INDX_IMPL_REF,
+               signal, BuildIndxImplRef::SignalLength, JBB);
+  }
+
+  ssRelease<Ss_BUILD_INDX_IMPL_REQ>(ssId);
+}
+
 BLOCK_FUNCTIONS(DbtupProxy)

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp	2008-08-15 11:01:41 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp	2008-08-27 07:54:42 +0000
@@ -18,6 +18,7 @@
 
 #include <LocalProxy.hpp>
 #include <signaldata/DropTab.hpp>
+#include <signaldata/BuildIndxImpl.hpp>
 
 class DbtupProxy : public LocalProxy {
 public:
@@ -51,6 +52,25 @@ protected:
   void sendDROP_TAB_REQ(Signal*, Uint32 ssId);
   void execDROP_TAB_CONF(Signal*);
   void sendDROP_TAB_CONF(Signal*, Uint32 ssId);
+
+  // GSN_BUILD_INDX_IMPL_REQ
+  struct Ss_BUILD_INDX_IMPL_REQ : SsParallel {
+    BuildIndxImplReq m_req;
+    Ss_BUILD_INDX_IMPL_REQ() {
+      m_sendREQ = (SsFUNC)&DbtupProxy::sendBUILD_INDX_IMPL_REQ;
+      m_sendCONF = (SsFUNC)&DbtupProxy::sendBUILD_INDX_IMPL_CONF;
+    }
+    enum { poolSize = 1 };
+    static SsPool<Ss_BUILD_INDX_IMPL_REQ>& pool(LocalProxy* proxy) {
+      return ((DbtupProxy*)proxy)->c_ss_BUILD_INDX_IMPL_REQ;
+    }
+  };
+  SsPool<Ss_BUILD_INDX_IMPL_REQ> c_ss_BUILD_INDX_IMPL_REQ;
+  void execBUILD_INDX_IMPL_REQ(Signal*);
+  void sendBUILD_INDX_IMPL_REQ(Signal*, Uint32 ssId);
+  void execBUILD_INDX_IMPL_CONF(Signal*);
+  void execBUILD_INDX_IMPL_REF(Signal*);
+  void sendBUILD_INDX_IMPL_CONF(Signal*, Uint32 ssId);
 };
 
 #endif

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp	2008-06-05 20:34:20 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp	2008-08-27 08:00:52 +0000
@@ -318,7 +318,7 @@ Dbtup::createTrigger(Tablerec* table, co
 
     tptr.p->monitorAllAttributes = TriggerInfo::getMonitorAllAttributes(tinfo);
     tptr.p->monitorReplicas = TriggerInfo::getMonitorReplicas(tinfo);
-    tptr.p->m_receiverBlock = refToBlock(req->receiverRef);
+    tptr.p->m_receiverRef = req->receiverRef;
 
     if (tptr.p->monitorAllAttributes)
     {
@@ -420,7 +420,7 @@ Dbtup::dropTrigger(Tablerec* table, cons
       if (ptr.p->triggerId == triggerId)
       {
 	if(ttype==TriggerType::SUBSCRIPTION &&
-	   sender != ptr.p->m_receiverBlock)
+	   sender != refToBlock(ptr.p->m_receiverRef))
 	{
 	  /**
 	   * You can only drop your own triggers for subscription triggers.
@@ -874,7 +874,7 @@ void Dbtup::executeTrigger(KeyReqStruct 
       }
   */
   Signal* signal= req_struct->signal;
-  BlockReference ref = trigPtr->m_receiverBlock;
+  BlockReference ref = trigPtr->m_receiverRef;
   Uint32* const keyBuffer = &cinBuffer[0];
   Uint32* const afterBuffer = &coutBuffer[0];
   Uint32* const beforeBuffer = &clogMemBuffer[0];
@@ -886,7 +886,7 @@ void Dbtup::executeTrigger(KeyReqStruct 
   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
   Fragrecord::FragState fragstatus = regFragPtr.p->fragStatus;
 
-  if (ref == BACKUP) {
+  if (refToMain(ref) == BACKUP) {
     jam();
     /*
     In order for the implementation of BACKUP to work even when changing
@@ -953,8 +953,9 @@ void Dbtup::executeTrigger(KeyReqStruct 
   case (TriggerType::SUBSCRIPTION_BEFORE):
     jam();
     // Since only backup uses subscription triggers we send to backup directly for now
-    ref = trigPtr->m_receiverBlock;
-    executeDirect = true;
+    ref = trigPtr->m_receiverRef;
+    // executeDirect = !isNdbMtLqh() || (refToMain(ref) != SUMA);
+    executeDirect = refToInstance(ref) == instance();
     break;
   case (TriggerType::READ_ONLY_CONSTRAINT):
     terrorCode = ZREAD_ONLY_CONSTRAINT_VIOLATION;
@@ -1174,7 +1175,7 @@ bool Dbtup::readTriggerInfo(TupTriggerDa
     req_struct->m_tuple_ptr= save;
     ndbrequire(ret != -1);
     noBeforeWords = ret;
-    if (trigPtr->m_receiverBlock != SUMA &&
+    if (refToMain(trigPtr->m_receiverRef) != SUMA &&
         (noAfterWords == noBeforeWords) &&
         (memcmp(afterBuffer, beforeBuffer, noAfterWords << 2) == 0)) {
 //--------------------------------------------------------------------
@@ -1209,7 +1210,7 @@ void Dbtup::sendTrigAttrInfo(Signal* sig
                      sigLen);
     if (executeDirect) {
       jam();
-      EXECUTE_DIRECT(receiverReference, 
+      EXECUTE_DIRECT(refToMain(receiverReference), 
                      GSN_TRIG_ATTRINFO,
                      signal,
 		     TrigAttrInfo::StaticLength + sigLen);
@@ -1275,23 +1276,25 @@ void Dbtup::sendFireTrigOrd(Signal* sign
     break;
   case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma
     jam();
-    // Since only backup uses subscription triggers we 
-    // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci_hi);
     fireTrigOrd->setHashValue(req_struct->hash_value);
     fireTrigOrd->m_any_value = regOperPtr->m_any_value;
     fireTrigOrd->m_gci_lo = req_struct->gci_lo;
-    EXECUTE_DIRECT(trigPtr->m_receiverBlock,
-                   GSN_FIRE_TRIG_ORD,
-                   signal,
-		   FireTrigOrd::SignalLengthSuma);
+    if (refToInstance(trigPtr->m_receiverRef) == instance())
+      EXECUTE_DIRECT(refToMain(trigPtr->m_receiverRef),
+                     GSN_FIRE_TRIG_ORD,
+                     signal,
+                     FireTrigOrd::SignalLengthSuma);
+    else
+      sendSignal(trigPtr->m_receiverRef, GSN_FIRE_TRIG_ORD,
+                 signal, FireTrigOrd::SignalLengthSuma, JBB);
     break;
   case (TriggerType::SUBSCRIPTION):
     jam();
     // Since only backup uses subscription triggers we 
     // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci_hi);
-    EXECUTE_DIRECT(trigPtr->m_receiverBlock,
+    EXECUTE_DIRECT(refToMain(trigPtr->m_receiverRef),
                    GSN_FIRE_TRIG_ORD,
                    signal,
 		   FireTrigOrd::SignalWithGCILength);

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp	2008-08-11 11:37:57 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp	2008-08-27 07:54:42 +0000
@@ -132,7 +132,7 @@ Dbtux::execSTTOR(Signal* signal)
   case 1:
     jam();
     CLEAR_ERROR_INSERT_VALUE;
-    c_tup = (Dbtup*)globalData.getBlock(DBTUP);
+    c_tup = (Dbtup*)globalData.getBlock(DBTUP, instance());
     ndbrequire(c_tup != 0);
     break;
   case 3:

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp	2008-07-26 05:13:40 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp	2008-08-27 07:54:42 +0000
@@ -19,6 +19,14 @@
 DbtuxProxy::DbtuxProxy(Block_context& ctx) :
   LocalProxy(DBTUX, ctx)
 {
+  // GSN_ALTER_INDX_IMPL_REQ
+  addRecSignal(GSN_ALTER_INDX_IMPL_REQ, &DbtuxProxy::execALTER_INDX_IMPL_REQ);
+  addRecSignal(GSN_ALTER_INDX_IMPL_CONF, &DbtuxProxy::execALTER_INDX_IMPL_CONF);
+  addRecSignal(GSN_ALTER_INDX_IMPL_REF, &DbtuxProxy::execALTER_INDX_IMPL_REF);
+
+  // GSN_DROP_TAB_REQ
+  addRecSignal(GSN_DROP_TAB_REQ, &DbtuxProxy::execDROP_TAB_REQ);
+  addRecSignal(GSN_DROP_TAB_CONF, &DbtuxProxy::execDROP_TAB_CONF);
 }
 
 DbtuxProxy::~DbtuxProxy()
@@ -31,4 +39,134 @@ DbtuxProxy::newWorker(Uint32 instanceNo)
   return new Dbtux(m_ctx, instanceNo);
 }
 
+// GSN_ALTER_INDX_IMPL_REQ
+
+void
+DbtuxProxy::execALTER_INDX_IMPL_REQ(Signal* signal)
+{
+  const AlterIndxImplReq* req = (const AlterIndxImplReq*)signal->getDataPtr();
+  Ss_ALTER_INDX_IMPL_REQ& ss = ssSeize<Ss_ALTER_INDX_IMPL_REQ>();
+  ss.m_req = *req;
+  ndbrequire(signal->getLength() == AlterIndxImplReq::SignalLength);
+  sendREQ(signal, ss);
+}
+
+void
+DbtuxProxy::sendALTER_INDX_IMPL_REQ(Signal* signal, Uint32 ssId)
+{
+  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
+
+  AlterIndxImplReq* req = (AlterIndxImplReq*)signal->getDataPtrSend();
+  *req = ss.m_req;
+  req->senderRef = reference();
+  req->senderData = ssId;
+  sendSignal(workerRef(ss.m_worker), GSN_ALTER_INDX_IMPL_REQ,
+             signal, AlterIndxImplReq::SignalLength, JBB);
+}
+
+void
+DbtuxProxy::execALTER_INDX_IMPL_CONF(Signal* signal)
+{
+  const AlterIndxImplConf* conf = (const AlterIndxImplConf*)signal->getDataPtr();
+  Uint32 ssId = conf->senderData;
+  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
+  recvCONF(signal, ss);
+}
+
+void
+DbtuxProxy::execALTER_INDX_IMPL_REF(Signal* signal)
+{
+  const AlterIndxImplRef* ref = (const AlterIndxImplRef*)signal->getDataPtr();
+  Uint32 ssId = ref->senderData;
+  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
+  recvREF(signal, ss, ref->errorCode);
+}
+
+void
+DbtuxProxy::sendALTER_INDX_IMPL_CONF(Signal* signal, Uint32 ssId)
+{
+  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
+  BlockReference dictRef = ss.m_req.senderRef;
+
+  if (!lastReply(ss))
+    return;
+
+  if (ss.m_error == 0) {
+    jam();
+    AlterIndxImplConf* conf = (AlterIndxImplConf*)signal->getDataPtrSend();
+    conf->senderRef = reference();
+    conf->senderData = ss.m_req.senderData;
+    sendSignal(dictRef, GSN_ALTER_INDX_IMPL_CONF,
+               signal, AlterIndxImplConf::SignalLength, JBB);
+  } else {
+    AlterIndxImplRef* ref = (AlterIndxImplRef*)signal->getDataPtrSend();
+    ref->senderRef = reference();
+    ref->senderData = ss.m_req.senderData;
+    ref->errorCode = ss.m_error;
+    sendSignal(dictRef, GSN_ALTER_INDX_IMPL_REF,
+               signal, AlterIndxImplRef::SignalLength, JBB);
+  }
+
+  ssRelease<Ss_ALTER_INDX_IMPL_REQ>(ssId);
+}
+
+// GSN_DROP_TAB_REQ
+
+void
+DbtuxProxy::execDROP_TAB_REQ(Signal* signal)
+{
+  const DropTabReq* req = (const DropTabReq*)signal->getDataPtr();
+  Uint32 ssId = getSsId(req);
+  Ss_DROP_TAB_REQ& ss = ssSeize<Ss_DROP_TAB_REQ>(ssId);
+  ss.m_req = *req;
+  ndbrequire(signal->getLength() == DropTabReq::SignalLength);
+  sendREQ(signal, ss);
+}
+
+void
+DbtuxProxy::sendDROP_TAB_REQ(Signal* signal, Uint32 ssId)
+{
+  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
+
+  DropTabReq* req = (DropTabReq*)signal->getDataPtrSend();
+  *req = ss.m_req;
+  req->senderRef = reference();
+  req->senderData = ssId; // redundant since tableId is used
+  sendSignal(workerRef(ss.m_worker), GSN_DROP_TAB_REQ,
+             signal, DropTabReq::SignalLength, JBB);
+}
+
+void
+DbtuxProxy::execDROP_TAB_CONF(Signal* signal)
+{
+  const DropTabConf* conf = (const DropTabConf*)signal->getDataPtr();
+  Uint32 ssId = getSsId(conf);
+  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
+  recvCONF(signal, ss);
+}
+
+void
+DbtuxProxy::sendDROP_TAB_CONF(Signal* signal, Uint32 ssId)
+{
+  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
+  BlockReference dictRef = ss.m_req.senderRef;
+
+  if (!lastReply(ss))
+    return;
+
+  if (ss.m_error == 0) {
+    jam();
+    DropTabConf* conf = (DropTabConf*)signal->getDataPtrSend();
+    conf->senderRef = reference();
+    conf->senderData = ss.m_req.senderData;
+    conf->tableId = ss.m_req.tableId;
+    sendSignal(dictRef, GSN_DROP_TAB_CONF,
+               signal, DropTabConf::SignalLength, JBB);
+  } else {
+    ndbrequire(false);
+  }
+
+  ssRelease<Ss_DROP_TAB_REQ>(ssId);
+}
+
 BLOCK_FUNCTIONS(DbtuxProxy)

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp	2008-07-26 05:13:40 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp	2008-08-27 07:54:42 +0000
@@ -17,6 +17,8 @@
 #define NDB_DBTUX_PROXY_HPP
 
 #include <LocalProxy.hpp>
+#include <signaldata/AlterIndxImpl.hpp>
+#include <signaldata/DropTab.hpp>
 
 class DbtuxProxy : public LocalProxy {
 public:
@@ -26,6 +28,49 @@ public:
 
 protected:
   virtual SimulatedBlock* newWorker(Uint32 instanceNo);
+
+  // GSN_ALTER_INDX_IMPL_REQ
+  struct Ss_ALTER_INDX_IMPL_REQ : SsParallel {
+    AlterIndxImplReq m_req;
+    Ss_ALTER_INDX_IMPL_REQ() {
+      m_sendREQ = (SsFUNC)&DbtuxProxy::sendALTER_INDX_IMPL_REQ;
+      m_sendCONF = (SsFUNC)&DbtuxProxy::sendALTER_INDX_IMPL_CONF;
+    }
+    enum { poolSize = 1 };
+    static SsPool<Ss_ALTER_INDX_IMPL_REQ>& pool(LocalProxy* proxy) {
+      return ((DbtuxProxy*)proxy)->c_ss_ALTER_INDX_IMPL_REQ;
+    }
+  };
+  SsPool<Ss_ALTER_INDX_IMPL_REQ> c_ss_ALTER_INDX_IMPL_REQ;
+  void execALTER_INDX_IMPL_REQ(Signal*);
+  void sendALTER_INDX_IMPL_REQ(Signal*, Uint32 ssId);
+  void execALTER_INDX_IMPL_CONF(Signal*);
+  void execALTER_INDX_IMPL_REF(Signal*);
+  void sendALTER_INDX_IMPL_CONF(Signal*, Uint32 ssId);
+
+  // GSN_DROP_TAB_REQ
+  struct Ss_DROP_TAB_REQ : SsParallel {
+    DropTabReq m_req;
+    Ss_DROP_TAB_REQ() {
+      m_sendREQ = (SsFUNC)&DbtuxProxy::sendDROP_TAB_REQ;
+      m_sendCONF = (SsFUNC)&DbtuxProxy::sendDROP_TAB_CONF;
+    }
+    enum { poolSize = 1 };
+    static SsPool<Ss_DROP_TAB_REQ>& pool(LocalProxy* proxy) {
+      return ((DbtuxProxy*)proxy)->c_ss_DROP_TAB_REQ;
+    }
+  };
+  SsPool<Ss_DROP_TAB_REQ> c_ss_DROP_TAB_REQ;
+  Uint32 getSsId(const DropTabReq* req) {
+    return SsIdBase | req->tableId;
+  }
+  Uint32 getSsId(const DropTabConf* conf) {
+    return SsIdBase | conf->tableId;
+  }
+  void execDROP_TAB_REQ(Signal*);
+  void sendDROP_TAB_REQ(Signal*, Uint32 ssId);
+  void execDROP_TAB_CONF(Signal*);
+  void sendDROP_TAB_CONF(Signal*, Uint32 ssId);
 };
 
 #endif

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp	2008-04-08 13:40:43 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp	2008-08-27 07:54:42 +0000
@@ -558,7 +558,7 @@ Dbtux::execACC_CHECK_SCAN(Signal* signal
       sendSignal(scan.m_userRef, GSN_NEXT_SCANCONF,
           signal, signalLength, JBB);
     } else {
-      Uint32 blockNo = refToBlock(scan.m_userRef);
+      Uint32 blockNo = refToMain(scan.m_userRef);
       EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, signalLength);
     }
     // next time look for next entry

=== modified file 'storage/ndb/src/kernel/blocks/suma/Suma.cpp'
--- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp	2008-08-13 12:47:22 +0000
+++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp	2008-08-27 08:00:52 +0000
@@ -233,7 +233,9 @@ Suma::execSTTOR(Signal* signal) {
   if(m_startphase == 3)
   {
     jam();
-    ndbrequire((m_tup = (Dbtup*)globalData.getBlock(DBTUP)) != 0);
+    // wl4391_todo something
+    Uint32 instanceNo = !isNdbMtLqh() ? 0 : 1;
+    ndbrequire((m_tup = (Dbtup*)globalData.getBlock(DBTUP, instanceNo)) != 0);
   }
 
   if(m_startphase == 5)
@@ -1890,6 +1892,7 @@ Suma::execDIH_SCAN_GET_NODES_CONF(Signal
     FragmentDescriptor fd;
     fd.m_fragDesc.m_nodeId = conf->nodes[0];
     fd.m_fragDesc.m_fragmentNo = fragNo;
+    fd.m_fragDesc.m_lqhInstanceKey = conf->instanceKey;
     signal->theData[2] = fd.m_dummy;
     fragBuf.append(&signal->theData[2], 1);
   }
@@ -2139,6 +2142,9 @@ Suma::SyncRecord::nextScan(Signal* signa
  
   DataBuffer<15>::Head head = m_attributeList;
   LocalDataBuffer<15> attrBuf(suma.c_dataBufferPool, head);
+
+  Uint32 instanceKey = fd.m_fragDesc.m_lqhInstanceKey;
+  BlockReference lqhRef = numberToRef(DBLQH, instanceKey, suma.getOwnNodeId());
   
   ScanFragReq * req = (ScanFragReq *)signal->getDataPtrSend();
   const Uint32 parallelism = 16;
@@ -2173,7 +2179,7 @@ Suma::SyncRecord::nextScan(Signal* signa
   req->batch_size_rows= parallelism;
 
   req->batch_size_bytes= 0;
-  suma.sendSignal(DBLQH_REF, GSN_SCAN_FRAGREQ, signal, 
+  suma.sendSignal(lqhRef, GSN_SCAN_FRAGREQ, signal, 
 		  ScanFragReq::SignalLength, JBB);
   
   signal->theData[0] = ptrI;
@@ -2192,12 +2198,12 @@ Suma::SyncRecord::nextScan(Signal* signa
   for(attrBuf.first(it); !it.curr.isNull(); attrBuf.next(it)){
     AttributeHeader::init(&signal->theData[dataPos++], * it.data, 0);
     if(dataPos == 25){
-      suma.sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, 25, JBB);
+      suma.sendSignal(lqhRef, GSN_ATTRINFO, signal, 25, JBB);
       dataPos = 3;
     }
   }
   if(dataPos != 3){
-    suma.sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, dataPos, JBB);
+    suma.sendSignal(lqhRef, GSN_ATTRINFO, signal, dataPos, JBB);
   }
   
   m_currentNoOfAttributes = attrBuf.getSize();        
@@ -2230,7 +2236,7 @@ Suma::execSCAN_FRAGCONF(Signal* signal){
   Ptr<SyncRecord> syncPtr;
   c_syncPool.getPtr(syncPtr, senderData);
   
-  if(completed != 2){
+  if(completed != 2){ // 2==ZSCAN_FRAG_CLOSED
     jam();
     
 #if PRINT_ONLY
@@ -2275,6 +2281,20 @@ Suma::execSUB_SYNC_CONTINUE_CONF(Signal*
 
   ndbrequire(c_subscriptions.find(subPtr, key));
 
+  Uint32 instanceKey;
+  {
+    Ptr<SyncRecord> syncPtr;
+    c_syncPool.getPtr(syncPtr, syncPtrI);
+    LocalDataBuffer<15> fragBuf(c_dataBufferPool, syncPtr.p->m_fragments);
+    DataBuffer<15>::DataBufferIterator fragIt;
+    bool ok = fragBuf.position(fragIt, syncPtr.p->m_currentFragment);
+    ndbrequire(ok);
+    FragmentDescriptor tmp;
+    tmp.m_dummy = * fragIt.data;
+    instanceKey = tmp.m_fragDesc.m_lqhInstanceKey;
+  }
+  BlockReference lqhRef = numberToRef(DBLQH, instanceKey, getOwnNodeId());
+
   ScanFragNextReq * req = (ScanFragNextReq *)signal->getDataPtrSend();
   req->senderData = syncPtrI;
   req->closeFlag = 0;
@@ -2282,7 +2302,7 @@ Suma::execSUB_SYNC_CONTINUE_CONF(Signal*
   req->transId2 = (SUMA << 20) + (getOwnNodeId() << 8);
   req->batch_size_rows = 16;
   req->batch_size_bytes = 0;
-  sendSignal(DBLQH_REF, GSN_SCAN_NEXTREQ, signal, 
+  sendSignal(lqhRef, GSN_SCAN_NEXTREQ, signal, 
 	     ScanFragNextReq::SignalLength, JBB);
 }
 

=== modified file 'storage/ndb/src/kernel/blocks/suma/Suma.hpp'
--- a/storage/ndb/src/kernel/blocks/suma/Suma.hpp	2008-06-25 13:06:41 +0000
+++ b/storage/ndb/src/kernel/blocks/suma/Suma.hpp	2008-08-27 07:54:42 +0000
@@ -113,9 +113,11 @@ public:
 
   void suma_ndbrequire(bool v);
 
+  // wl4391_todo big enough for now
   union FragmentDescriptor { 
     struct  {
-      Uint16 m_fragmentNo;
+      Uint8 m_fragmentNo;
+      Uint8 m_lqhInstanceKey;
       Uint16 m_nodeId;
     } m_fragDesc;
     Uint32 m_dummy;