List:Commits« Previous MessageNext Message »
From:Jonas Oreland Date:September 6 2010 5:32am
Subject:bzr push into mysql-5.1-telco-7.0-spj-scan-vs-scan branch (jonas:3266 to
3269)
View as plain text  
 3269 Jonas Oreland	2010-09-06
      ndb spj svs - This patch implements scanIndex_execNODE_FAILREP...No tests from mtr..quite a lot of manual testing performed

    modified:
      storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp
      storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp
 3268 Jonas Oreland	2010-09-04
      ndb spj svs - This implements scanIndex_abort() and scanIndex_execSCAN_FRAGREF...No tests from mtr (will be added to hugoQuery)

    modified:
      storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp
 3267 Jonas Oreland	2010-09-04
      ndb spj svs - Introduce real names for ScanFragHandle::m_state (prepare for abort handling)

    modified:
      storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp
      storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp
 3266 Jonas Oreland	2010-09-03
      ndb spj svs - guess alignment problem on sol10-sparc-a

    modified:
      storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp
=== modified file 'storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp'
--- a/storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp	2010-09-03 21:55:26 +0000
+++ b/storage/ndb/src/kernel/blocks/dbspj/Dbspj.hpp	2010-09-06 05:20:23 +0000
@@ -455,12 +455,22 @@ public:
 
   struct ScanFragHandle
   {
+    enum SFH_State
+    {
+      SFH_NOT_STARTED  = 0,
+      SFH_SCANNING     = 1, // in LQH
+      SFH_WAIT_NEXTREQ = 2,
+      SFH_COMPLETE     = 3,
+      SFH_WAIT_CLOSE   = 4
+    };
+
     void init(Uint32 fid) { 
       m_ref = 0; 
       m_fragId = fid; 
-      m_state = Uint16(~0);
+      m_state = SFH_NOT_STARTED;
       reset_ranges();
     }
+
     Uint32 m_magic;
     Uint32 m_treeNodePtrI;
     Uint16 m_fragId;
@@ -546,24 +556,24 @@ public:
       TN_BUILDING = 1,
 
       /**
-       * Tree node is build, but not active
+       * Tree node is preparing
        */
-      TN_INACTIVE = 2,
+      TN_PREPARING = 2,
 
       /**
-       * Tree node is active (i.e has outstanding request(s))
+       * Tree node is build and prepared, but not active
        */
-      TN_ACTIVE = 3,
+      TN_INACTIVE = 3,
 
       /**
-       * Tree node is "finishing" (after TN_INACTIVE)
+       * Tree node is active (i.e has outstanding request(s))
        */
-      TN_COMPLETING = 5,
+      TN_ACTIVE = 4,
 
       /**
-       * Tree node is aborting
+       * Tree node is "finishing" (after TN_INACTIVE)
        */
-      TN_ABORTING = 6,
+      TN_COMPLETING = 5,
 
       /**
        * end-marker, not a valid state
@@ -731,8 +741,11 @@ public:
       RS_PREPARING  = 0x2,
       RS_RUNNING    = 0x3,
       RS_COMPLETING = 0x4,
+
       RS_ABORTING   = 0x1000, // Or:ed together with other states
+      RS_WAITING    = 0x2000, // Waiting for SCAN_NEXTREQ
 
+      RS_ABORTED    = 0x2008, // Aborted and waiting for SCAN_NEXTREQ
       RS_END = 0
     };
 

=== modified file 'storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp'
--- a/storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp	2010-09-03 18:56:24 +0000
+++ b/storage/ndb/src/kernel/blocks/dbspj/DbspjMain.cpp	2010-09-06 05:20:23 +0000
@@ -293,6 +293,7 @@ Dbspj::execAPI_FAILREQ(Signal* signal)
 void
 Dbspj::execCONTINUEB(Signal* signal)
 {
+  jamEntry();
   switch(signal->theData[0]) {
   case 0:
     releaseGlobal(signal);
@@ -1044,6 +1045,15 @@ Dbspj::checkPrepareComplete(Signal * sig
   if (requestPtr.p->m_outstanding == 0)
   {
     jam();
+
+    if (unlikely((requestPtr.p->m_state & Request::RS_ABORTING) != 0))
+    {
+      jam();
+      batchComplete(signal, requestPtr);
+      return;
+    }
+
+    requestPtr.p->m_state = Request::RS_RUNNING;
     Ptr<TreeNode> nodePtr;
     {
       Local_TreeNode_list list(m_treenode_pool, requestPtr.p->m_nodes);
@@ -1138,6 +1148,18 @@ Dbspj::sendConf(Signal* signal, Ptr<Requ
 {
   if (requestPtr.p->isScan())
   {
+    if (unlikely((requestPtr.p->m_state & Request::RS_WAITING) != 0))
+    {
+      jam();
+      /**
+       * We aborted request ourselves (due to node-failure ?)
+       *   but TC haven't contacted us...so we can't reply yet...
+       */
+      ndbrequire(is_complete);
+      ndbrequire((requestPtr.p->m_state & Request::RS_ABORTING) != 0);
+      return;
+    }
+
     if (requestPtr.p->m_errCode == 0)
     {
       jam();
@@ -1157,6 +1179,11 @@ Dbspj::sendConf(Signal* signal, Ptr<Requ
        * reset for next batch
        */
       requestPtr.p->m_rows = 0;
+      if (!is_complete)
+      {
+        jam();
+        requestPtr.p->m_state |= Request::RS_WAITING;
+      }
 #ifdef DEBUG_SCAN_FRAGREQ
   ndbout_c("Dbspj::sendConf() sending SCAN_FRAGCONF ");
   printSCAN_FRAGCONF(stdout, signal->getDataPtrSend(),
@@ -1571,8 +1598,10 @@ Dbspj::complete(Signal* signal, Ptr<Requ
   /**
    * we need to run complete-phase before sending last SCAN_FRAGCONF
    */
-  Uint32 is_abort = requestPtr.p->m_state & Request::RS_ABORTING;
-  requestPtr.p->m_state = Request::RS_COMPLETING | is_abort;
+  Uint32 flags = requestPtr.p->m_state &
+    (Request::RS_ABORTING | Request::RS_WAITING);
+
+  requestPtr.p->m_state = Request::RS_COMPLETING | flags;
   
   // clear bit so that next batchComplete()
   // will continue to cleanup
@@ -1623,10 +1652,19 @@ Dbspj::cleanup(Ptr<Request> requestPtr)
       list.next(nodePtr);
       m_treenode_pool.release(tmp);
     }
+    list.remove();
   }
   if (requestPtr.p->isScan())
   {
     jam();
+
+    if (unlikely((requestPtr.p->m_state & Request::RS_WAITING) != 0))
+    {
+      jam();
+      requestPtr.p->m_state = Request::RS_ABORTED;
+      return;
+    }
+
 #ifdef VM_TRACE
     {
       Request key;
@@ -1833,6 +1871,26 @@ Dbspj::execSCAN_NEXTREQ(Signal* signal)
     return;
   }
 
+  Uint32 state = requestPtr.p->m_state;
+  requestPtr.p->m_state = state & ~Uint32(Request::RS_WAITING);
+
+  if (unlikely(state == Request::RS_ABORTED))
+  {
+    jam();
+    batchComplete(signal, requestPtr);
+    return;
+  }
+
+  if (unlikely((state & Request::RS_ABORTING) != 0))
+  {
+    jam();
+    /**
+     * abort is already in progress...
+     *   since RS_WAITING is cleared...it will end this request
+     */
+    return;
+  }
+
   if (req->closeFlag == ZTRUE)  // Requested close scan
   {
     jam();
@@ -1840,6 +1898,7 @@ Dbspj::execSCAN_NEXTREQ(Signal* signal)
     return;
   }
 
+  ndbrequire((state & Request::RS_WAITING) != 0);
   ndbrequire(requestPtr.p->m_outstanding == 0);
 
   {
@@ -3274,7 +3333,6 @@ Dbspj::lookup_execNODE_FAILREP(Signal* s
   {
     Uint32 cnt = requestPtr.p->m_lookup_node_data[node];
     sum += cnt;
-    ndbassert(requestPtr.p->m_outstanding >= sum);
     requestPtr.p->m_lookup_node_data[node] = 0;
   }
 
@@ -3681,7 +3739,7 @@ Dbspj::scanFrag_send(Signal* signal,
   jam();
 
   requestPtr.p->m_outstanding++;
-  requestPtr.p->m_cnt_active ++;
+  requestPtr.p->m_cnt_active++;
   mark_active(requestPtr, treeNodePtr, true);
   treeNodePtr.p->m_state = TreeNode::TN_ACTIVE;
 
@@ -3807,9 +3865,9 @@ Dbspj::scanFrag_execSCAN_FRAGREF(Signal*
 
   ndbrequire(treeNodePtr.p->m_state == TreeNode::TN_ACTIVE);
   ndbrequire(requestPtr.p->m_cnt_active);
-  requestPtr.p->m_cnt_active --;
+  requestPtr.p->m_cnt_active--;
   ndbrequire(requestPtr.p->m_outstanding);
-  requestPtr.p->m_outstanding --;
+  requestPtr.p->m_outstanding--;
   treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
 
   abort(signal, requestPtr, errCode);
@@ -3846,7 +3904,7 @@ Dbspj::scanFrag_execSCAN_FRAGCONF(Signal
     jam();
 
     ndbrequire(requestPtr.p->m_cnt_active);
-    requestPtr.p->m_cnt_active --;
+    requestPtr.p->m_cnt_active--;
     treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
     mark_active(requestPtr, treeNodePtr, false);
   }
@@ -4246,6 +4304,7 @@ Dbspj::scanIndex_prepare(Signal * signal
 {
   jam();
 
+  treeNodePtr.p->m_state = TreeNode::TN_PREPARING;
   ScanFragReq*dst=(ScanFragReq*)treeNodePtr.p->m_scanindex_data.m_scanFragReq;
 
   DihScanTabReq * req = (DihScanTabReq*)signal->getDataPtrSend();
@@ -4394,9 +4453,14 @@ Dbspj::execDIH_SCAN_TAB_CONF(Signal* sig
                  DihScanGetNodesReq::SignalLength, JBB);
       cnt++;
     }
-    requestPtr.p->m_outstanding += cnt;
+    data.m_frags_not_complete = cnt;
+    requestPtr.p->m_outstanding++;
+  }
+  else
+  {
+    jam();
+    treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
   }
-
   checkPrepareComplete(signal, requestPtr, 1);
 
   return;
@@ -4424,18 +4488,27 @@ Dbspj::execDIH_SCAN_GET_NODES_CONF(Signa
   Uint32 node = conf->nodes[0];
   Uint32 instanceKey = conf->instanceKey;
 
-
   Ptr<ScanFragHandle> fragPtr;
   m_scanfraghandle_pool.getPtr(fragPtr, senderData);
   Ptr<TreeNode> treeNodePtr;
   m_treenode_pool.getPtr(treeNodePtr, fragPtr.p->m_treeNodePtrI);
   ndbrequire(treeNodePtr.p->m_info == &g_ScanIndexOpInfo);
+  ScanIndexData& data = treeNodePtr.p->m_scanindex_data;
+  ndbrequire(data.m_frags_not_complete > 0);
+  data.m_frags_not_complete--;
 
   fragPtr.p->m_ref = numberToRef(DBLQH, instanceKey, node);
 
-  Ptr<Request> requestPtr;
-  m_request_pool.getPtr(requestPtr, treeNodePtr.p->m_requestPtrI);
-  checkPrepareComplete(signal, requestPtr, 1);
+  if (data.m_frags_not_complete == 0)
+  {
+    jam();
+
+    treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
+
+    Ptr<Request> requestPtr;
+    m_request_pool.getPtr(requestPtr, treeNodePtr.p->m_requestPtrI);
+    checkPrepareComplete(signal, requestPtr, 1);
+  }
 }
 
 Uint32
@@ -4726,7 +4799,7 @@ Dbspj::scanIndex_send(Signal* signal,
       if (keyInfoPtrI == RNIL)
       {
         jam();
-        fragPtr.p->m_state = 1; // complete
+        fragPtr.p->m_state = ScanFragHandle::SFH_COMPLETE;
         continue;
       }
 
@@ -4781,7 +4854,7 @@ Dbspj::scanIndex_send(Signal* signal,
     handle.clear();
 
     i++;
-    fragPtr.p->m_state = 0; // running
+    fragPtr.p->m_state = ScanFragHandle::SFH_SCANNING; // running
     data.m_frags_outstanding++;
     data.m_frags_not_complete++;
   }
@@ -4800,7 +4873,7 @@ Dbspj::scanIndex_send(Signal* signal,
     return;
   }
 
-  requestPtr.p->m_cnt_active ++;
+  requestPtr.p->m_cnt_active++;
   requestPtr.p->m_outstanding++;
   mark_active(requestPtr, treeNodePtr, true);
   treeNodePtr.p->m_state = TreeNode::TN_ACTIVE;
@@ -4864,23 +4937,36 @@ Dbspj::scanIndex_execSCAN_FRAGCONF(Signa
   Uint32 rows = conf->completedOps;
   Uint32 done = conf->fragmentCompleted;
 
-  requestPtr.p->m_rows += rows;
-
+  Uint32 state = fragPtr.p->m_state;
   ScanIndexData& data = treeNodePtr.p->m_scanindex_data;
 
+  if (state == ScanFragHandle::SFH_WAIT_CLOSE && done == 0)
+  {
+    jam();
+    /**
+     * We sent an explicit close request...ignore this...a close will come later
+     */
+    return;
+  }
+
+  requestPtr.p->m_rows += rows;
+
   if (!treeNodePtr.p->isLeaf())
   {
     jam();
     data.m_rows_expecting += rows;
   }
   ndbrequire(data.m_frags_outstanding);
+  ndbrequire(state == ScanFragHandle::SFH_SCANNING ||
+             state == ScanFragHandle::SFH_WAIT_CLOSE);
+
   data.m_frags_outstanding--;
+  fragPtr.p->m_state = ScanFragHandle::SFH_WAIT_NEXTREQ;
 
   if (done)
   {
     jam();
-    ndbrequire(fragPtr.p->m_state == 0);
-    fragPtr.p->m_state = done;
+    fragPtr.p->m_state = ScanFragHandle::SFH_COMPLETE;
     ndbrequire(data.m_frags_not_complete>0)
     data.m_frags_not_complete--;
 
@@ -4888,23 +4974,35 @@ Dbspj::scanIndex_execSCAN_FRAGCONF(Signa
     {
       jam();
       ndbrequire(requestPtr.p->m_cnt_active);
-      requestPtr.p->m_cnt_active --;
+      requestPtr.p->m_cnt_active--;
       treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
       mark_active(requestPtr, treeNodePtr, false);
     }
   }
 
-  if (data.m_frags_outstanding == 0 && 
-      data.m_rows_received == data.m_rows_expecting)
+
+  if (data.m_frags_outstanding == 0)
   {
-    jam();
     /**
-     * Finished...
+     * Don't reportBatchComplete to children if we're aborting...
      */
-    if (treeNodePtr.p->m_bits & TreeNode::T_REPORT_BATCH_COMPLETE)
+    if (state == ScanFragHandle::SFH_WAIT_CLOSE)
     {
       jam();
-      reportBatchComplete(signal, requestPtr, treeNodePtr);
+      ndbrequire((requestPtr.p->m_state & Request::RS_ABORTING) != 0);
+    }
+    else if (! (data.m_rows_received == data.m_rows_expecting))
+    {
+      jam();
+      return;
+    }
+    else
+    {
+      if (treeNodePtr.p->m_bits & TreeNode::T_REPORT_BATCH_COMPLETE)
+      {
+        jam();
+        reportBatchComplete(signal, requestPtr, treeNodePtr);
+      }
     }
     
     checkBatchComplete(signal, requestPtr, 1);
@@ -4920,7 +5018,38 @@ Dbspj::scanIndex_execSCAN_FRAGREF(Signal
 {
   jam();
 
-  ndbrequire(false);
+  const ScanFragRef * rep = CAST_CONSTPTR(ScanFragRef, signal->getDataPtr());
+  const Uint32 errCode = rep->errorCode;
+
+  Uint32 state = fragPtr.p->m_state;
+  ndbrequire(state == ScanFragHandle::SFH_SCANNING ||
+             state == ScanFragHandle::SFH_WAIT_CLOSE);
+
+  fragPtr.p->m_state = ScanFragHandle::SFH_COMPLETE;
+
+  ScanIndexData& data = treeNodePtr.p->m_scanindex_data;
+  ndbrequire(data.m_frags_not_complete > 0);
+  data.m_frags_not_complete--;
+  ndbrequire(data.m_frags_outstanding > 0);
+  data.m_frags_outstanding--;
+
+  if (data.m_frags_not_complete == 0)
+  {
+    jam();
+    ndbrequire(requestPtr.p->m_cnt_active);
+    requestPtr.p->m_cnt_active--;
+    treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
+    mark_active(requestPtr, treeNodePtr, false);
+  }
+
+  if (data.m_frags_outstanding == 0)
+  {
+    jam();
+    ndbrequire(requestPtr.p->m_outstanding);
+    requestPtr.p->m_outstanding--;
+  }
+
+  abort(signal, requestPtr, errCode);
 }  
 
 void
@@ -4959,12 +5088,13 @@ Dbspj::scanIndex_execSCAN_NEXTREQ(Signal
   for (Uint32 i = 0; i < cnt && !fragPtr.isNull(); list.next(fragPtr))
   {
     jam();
-    if (fragPtr.p->m_state == 0)
+    if (fragPtr.p->m_state == ScanFragHandle::SFH_WAIT_NEXTREQ)
     {
       jam();
 
       i++;
       data.m_frags_outstanding++;
+      fragPtr.p->m_state = ScanFragHandle::SFH_SCANNING;
 
       DEBUG("scanIndex_execSCAN_NEXTREQ to: " << hex 
             << treeNodePtr.p->m_send.m_ref
@@ -4980,15 +5110,6 @@ Dbspj::scanIndex_execSCAN_NEXTREQ(Signal
                  ScanFragNextReq::SignalLength, 
                  JBB);
     }
-    else if (fragPtr.p->m_state == Uint16(~0))
-    {
-      jam();
-      /**
-       * not sent...this should only be possible with ! T_SCAN_PARALLEL
-       *   which is not yet implemented
-       */
-      ndbrequire(false);
-    }
   }
   
   /**
@@ -5027,7 +5148,73 @@ Dbspj::scanIndex_abort(Signal* signal,
                        Ptr<TreeNode> treeNodePtr)
 {
   jam();
-  ndbrequire(false);
+
+  switch(treeNodePtr.p->m_state){
+  case TreeNode::TN_BUILDING:
+  case TreeNode::TN_PREPARING:
+  case TreeNode::TN_INACTIVE:
+  case TreeNode::TN_COMPLETING:
+  case TreeNode::TN_END:
+    ndbout_c("H'%.8x H'%.8x scanIndex_abort state: %u",
+             requestPtr.p->m_transId[0],
+             requestPtr.p->m_transId[1],
+             treeNodePtr.p->m_state);
+    return;
+
+  case TreeNode::TN_ACTIVE:
+    jam();
+    break;
+  }
+
+  ScanFragNextReq* req = CAST_PTR(ScanFragNextReq, signal->getDataPtrSend());
+  req->closeFlag = 1;
+  req->transId1 = requestPtr.p->m_transId[0];
+  req->transId2 = requestPtr.p->m_transId[1];
+  req->batch_size_rows = 0;
+  req->batch_size_bytes = 0;
+
+  ScanIndexData& data = treeNodePtr.p->m_scanindex_data;
+  Local_ScanFragHandle_list list(m_scanfraghandle_pool, data.m_fragments);
+  Ptr<ScanFragHandle> fragPtr;
+
+  Uint32 cnt_waiting = 0;
+  Uint32 cnt_scanning = 0;
+  for (list.first(fragPtr); !fragPtr.isNull(); list.next(fragPtr))
+  {
+    switch(fragPtr.p->m_state){
+    case ScanFragHandle::SFH_NOT_STARTED:
+    case ScanFragHandle::SFH_COMPLETE:
+    case ScanFragHandle::SFH_WAIT_CLOSE:
+      jam();
+      break;
+    case ScanFragHandle::SFH_WAIT_NEXTREQ:
+      jam();
+      cnt_waiting++;              // was idle...
+      data.m_frags_outstanding++; // is closing
+      goto do_abort;
+    case ScanFragHandle::SFH_SCANNING:
+      jam();
+      cnt_scanning++;
+      goto do_abort;
+    do_abort:
+      req->senderData = fragPtr.i;
+      sendSignal(fragPtr.p->m_ref, GSN_SCAN_NEXTREQ, signal,
+                 ScanFragNextReq::SignalLength, JBB);
+
+      fragPtr.p->m_state = ScanFragHandle::SFH_WAIT_CLOSE;
+      break;
+    }
+  }
+
+  ndbrequire(cnt_waiting + cnt_scanning > 0);
+  if (cnt_scanning == 0)
+  {
+    /**
+     * If all were waiting...this should increase m_outstanding
+     */
+    jam();
+    requestPtr.p->m_outstanding++;
+  }
 }
 
 Uint32
@@ -5037,8 +5224,91 @@ Dbspj::scanIndex_execNODE_FAILREP(Signal
                                   NdbNodeBitmask nodes)
 {
   jam();
-  ndbrequire(false);
-  return 0;
+
+  switch(treeNodePtr.p->m_state){
+  case TreeNode::TN_PREPARING:
+  case TreeNode::TN_INACTIVE:
+    return 1;
+
+  case TreeNode::TN_BUILDING:
+  case TreeNode::TN_COMPLETING:
+  case TreeNode::TN_END:
+    return 0;
+
+  case TreeNode::TN_ACTIVE:
+    jam();
+    break;
+  }
+
+
+  Uint32 sum = 0;
+  ScanIndexData& data = treeNodePtr.p->m_scanindex_data;
+  Local_ScanFragHandle_list list(m_scanfraghandle_pool, data.m_fragments);
+  Ptr<ScanFragHandle> fragPtr;
+
+  Uint32 save0 = data.m_frags_outstanding;
+  Uint32 save1 = data.m_frags_not_complete;
+
+  for (list.first(fragPtr); !fragPtr.isNull(); list.next(fragPtr))
+  {
+    if (nodes.get(refToNode(fragPtr.p->m_ref)) == false)
+    {
+      jam();
+      /**
+       * No action needed
+       */
+      continue;
+    }
+
+    switch(fragPtr.p->m_state){
+    case ScanFragHandle::SFH_NOT_STARTED:
+      jam();
+      ndbrequire(data.m_frags_not_complete > 0);
+      data.m_frags_not_complete--;
+      // fall through
+    case ScanFragHandle::SFH_COMPLETE:
+      jam();
+      sum++; // indicate that we should abort
+      /**
+       * we could keep list of all fragments...
+       *   or execute DIGETNODES again...
+       *   but for now, we don't
+       */
+      break;
+    case ScanFragHandle::SFH_WAIT_CLOSE:
+    case ScanFragHandle::SFH_SCANNING:
+      jam();
+      ndbrequire(data.m_frags_outstanding > 0);
+      data.m_frags_outstanding--;
+      // fall through
+    case ScanFragHandle::SFH_WAIT_NEXTREQ:
+      jam();
+      sum++;
+      ndbrequire(data.m_frags_not_complete > 0);
+      data.m_frags_not_complete--;
+      break;
+    }
+    fragPtr.p->m_ref = 0;
+    fragPtr.p->m_state = ScanFragHandle::SFH_COMPLETE;
+  }
+
+  if (save0 != 0 && data.m_frags_outstanding == 0)
+  {
+    jam();
+    ndbrequire(requestPtr.p->m_outstanding);
+    requestPtr.p->m_outstanding--;
+  }
+
+  if (save1 != 0 && data.m_frags_not_complete == 0)
+  {
+    jam();
+    ndbrequire(requestPtr.p->m_cnt_active);
+    requestPtr.p->m_cnt_active--;
+    treeNodePtr.p->m_state = TreeNode::TN_INACTIVE;
+    mark_active(requestPtr, treeNodePtr, false);
+  }
+
+  return sum;
 }
 
 void


Attachment: [text/bzr-bundle] bzr/jonas@mysql.com-20100906052023-ivfmy419i5g1oz5u.bundle
Thread
bzr push into mysql-5.1-telco-7.0-spj-scan-vs-scan branch (jonas:3266 to3269) Jonas Oreland6 Sep