开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
DbtupTrigger.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：39k
源码类别：

MySQL数据库

开发平台：

Visual C++

DbtupTrigger.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #define DBTUP_C
  19. #include "Dbtup.hpp"
  20. #include <RefConvert.hpp>
  21. #include <ndb_limits.h>
  22. #include <pc.hpp>
  23. #include <AttributeDescriptor.hpp>
  24. #include "AttributeOffset.hpp"
  25. #include <AttributeHeader.hpp>
  26. #include <signaldata/FireTrigOrd.hpp>
  27. #include <signaldata/CreateTrig.hpp>
  28. #include <signaldata/TuxMaint.hpp>
  30. #define ljam() { jamLine(7000 + __LINE__); }
  31. #define ljamEntry() { jamEntryLine(7000 + __LINE__); }
  33. /* **************************************************************** */
  34. /* ---------------------------------------------------------------- */
  35. /* ----------------------- TRIGGER HANDLING ----------------------- */
  36. /* ---------------------------------------------------------------- */
  37. /* **************************************************************** */
  39. ArrayList<Dbtup::TupTriggerData>*
  40. Dbtup::findTriggerList(Tablerec* table,
  41.                        TriggerType::Value ttype,
  42.                        TriggerActionTime::Value ttime,
  43.                        TriggerEvent::Value tevent)
  44. {
  45.   ArrayList<TupTriggerData>* tlist = NULL;
  46.   switch (ttype) {
  47.   case TriggerType::SUBSCRIPTION:
  48.   case TriggerType::SUBSCRIPTION_BEFORE:
  49.     switch (tevent) {
  50.     case TriggerEvent::TE_INSERT:
  51.       ljam();
  52.       if (ttime == TriggerActionTime::TA_DETACHED)
  53.         tlist = &table->subscriptionInsertTriggers;
  54.       break;
  55.     case TriggerEvent::TE_UPDATE:
  56.       ljam();
  57.       if (ttime == TriggerActionTime::TA_DETACHED)
  58.         tlist = &table->subscriptionUpdateTriggers;
  59.       break;
  60.     case TriggerEvent::TE_DELETE:
  61.       ljam();
  62.       if (ttime == TriggerActionTime::TA_DETACHED)
  63.         tlist = &table->subscriptionDeleteTriggers;
  64.       break;
  65.     default:
  66.       break;
  67.     }
  68.     break;
  69.   case TriggerType::SECONDARY_INDEX:
  70.     switch (tevent) {
  71.     case TriggerEvent::TE_INSERT:
  72.       ljam();
  73.       if (ttime == TriggerActionTime::TA_AFTER)
  74.         tlist = &table->afterInsertTriggers;
  75.       break;
  76.     case TriggerEvent::TE_UPDATE:
  77.       ljam();
  78.       if (ttime == TriggerActionTime::TA_AFTER)
  79.         tlist = &table->afterUpdateTriggers;
  80.       break;
  81.     case TriggerEvent::TE_DELETE:
  82.       ljam();
  83.       if (ttime == TriggerActionTime::TA_AFTER)
  84.         tlist = &table->afterDeleteTriggers;
  85.       break;
  86.     default:
  87.       break;
  88.     }
  89.     break;
  90.   case TriggerType::ORDERED_INDEX:
  91.     switch (tevent) {
  92.     case TriggerEvent::TE_CUSTOM:
  93.       ljam();
  94.       if (ttime == TriggerActionTime::TA_CUSTOM)
  95.         tlist = &table->tuxCustomTriggers;
  96.       break;
  97.     default:
  98.       break;
  99.     }
  100.     break;
  101.   case TriggerType::READ_ONLY_CONSTRAINT:
  102.     switch (tevent) {
  103.     case TriggerEvent::TE_UPDATE:
  104.       ljam();
  105.       if (ttime == TriggerActionTime::TA_AFTER)
  106.         tlist = &table->constraintUpdateTriggers;
  107.       break;
  108.     default:
  109.       break;
  110.     }
  111.     break;
  112.   default:
  113.     break;
  114.   }
  115.   return tlist;
  116. }
  118. // Trigger signals
  119. void
  120. Dbtup::execCREATE_TRIG_REQ(Signal* signal)
  121. {
  122.   ljamEntry();
  123.   BlockReference senderRef = signal->getSendersBlockRef();
  124.   const CreateTrigReq reqCopy = *(const CreateTrigReq*)signal->getDataPtr();
  125.   const CreateTrigReq* const req = &reqCopy;
  127.   // Find table
  128.   TablerecPtr tabPtr;
  129.   tabPtr.i = req->getTableId();
  130.   ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  132.   // Create trigger and associate it with the table
  133.   if (createTrigger(tabPtr.p, req)) {
  134.     ljam();
  135.     // Send conf
  136.     CreateTrigConf* const conf = (CreateTrigConf*)signal->getDataPtrSend();
  137.     conf->setUserRef(reference());
  138.     conf->setConnectionPtr(req->getConnectionPtr());
  139.     conf->setRequestType(req->getRequestType());
  140.     conf->setTableId(req->getTableId());
  141.     conf->setIndexId(req->getIndexId());
  142.     conf->setTriggerId(req->getTriggerId());
  143.     conf->setTriggerInfo(req->getTriggerInfo());
  144.     sendSignal(senderRef, GSN_CREATE_TRIG_CONF, 
  145.                signal, CreateTrigConf::SignalLength, JBB);
  146.   } else {
  147.     ljam();
  148.     // Send ref
  149.     CreateTrigRef* const ref = (CreateTrigRef*)signal->getDataPtrSend();
  150.     ref->setUserRef(reference());
  151.     ref->setConnectionPtr(req->getConnectionPtr());
  152.     ref->setRequestType(req->getRequestType());
  153.     ref->setTableId(req->getTableId());
  154.     ref->setIndexId(req->getIndexId());
  155.     ref->setTriggerId(req->getTriggerId());
  156.     ref->setTriggerInfo(req->getTriggerInfo());
  157.     ref->setErrorCode(CreateTrigRef::TooManyTriggers);
  158.     sendSignal(senderRef, GSN_CREATE_TRIG_REF, 
  159.                signal, CreateTrigRef::SignalLength, JBB);
  160.   }
  161. }//Dbtup::execCREATE_TRIG_REQ()
  163. void
  164. Dbtup::execDROP_TRIG_REQ(Signal* signal)
  165. {
  166.   ljamEntry();
  167.   BlockReference senderRef = signal->getSendersBlockRef();
  168.   const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr();
  169.   const DropTrigReq* const req = &reqCopy;
  171.   // Find table
  172.   TablerecPtr tabPtr;
  173.   tabPtr.i = req->getTableId();
  174.   ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  176.   // Drop trigger
  177.   Uint32 r = dropTrigger(tabPtr.p, req);
  178.   if (r == 0){
  179.     // Send conf
  180.     DropTrigConf* const conf = (DropTrigConf*)signal->getDataPtrSend();
  181.     conf->setUserRef(senderRef);
  182.     conf->setConnectionPtr(req->getConnectionPtr());
  183.     conf->setRequestType(req->getRequestType());
  184.     conf->setTableId(req->getTableId());
  185.     conf->setIndexId(req->getIndexId());
  186.     conf->setTriggerId(req->getTriggerId());
  187.     sendSignal(senderRef, GSN_DROP_TRIG_CONF, 
  188.        signal, DropTrigConf::SignalLength, JBB);
  189.   } else {
  190.     // Send ref
  191.     DropTrigRef* const ref = (DropTrigRef*)signal->getDataPtrSend();
  192.     ref->setUserRef(senderRef);
  193.     ref->setConnectionPtr(req->getConnectionPtr());
  194.     ref->setRequestType(req->getRequestType());
  195.     ref->setTableId(req->getTableId());
  196.     ref->setIndexId(req->getIndexId());
  197.     ref->setTriggerId(req->getTriggerId());
  198.     ref->setErrorCode((DropTrigRef::ErrorCode)r);
  199.     ref->setErrorLine(__LINE__);
  200.     ref->setErrorNode(refToNode(reference()));
  201.     sendSignal(senderRef, GSN_DROP_TRIG_REF, 
  202.        signal, DropTrigRef::SignalLength, JBB);
  203.   }
  204. }//Dbtup::DROP_TRIG_REQ()
  206. /* ---------------------------------------------------------------- */
  207. /* ------------------------- createTrigger ------------------------ */
  208. /*                                                                  */
  209. /* Creates a new trigger record by fetching one from the trigger    */
  210. /* pool and associates it with the given table.                     */
  211. /* Trigger type can be one of secondary_index, subscription,        */
  212. /* constraint(NYI), foreign_key(NYI), schema_upgrade(NYI),          */
  213. /* api_trigger(NYI) or sql_trigger(NYI).                            */   
  214. /* Note that this method only checks for total number of allowed    */
  215. /* triggers. Checking the number of allowed triggers per table is   */
  216. /* done by TRIX.                                                    */
  217. /*                                                                  */
  218. /* ---------------------------------------------------------------- */
  219. bool
  220. Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
  221. {
  222.   if (ERROR_INSERTED(4003)) {
  223.     CLEAR_ERROR_INSERT_VALUE;
  224.     return false;
  225.   }
  226.   TriggerType::Value ttype = req->getTriggerType();
  227.   TriggerActionTime::Value ttime = req->getTriggerActionTime();
  228.   TriggerEvent::Value tevent = req->getTriggerEvent();
  230.   ArrayList<TupTriggerData>* tlist = findTriggerList(table, ttype, ttime, tevent);
  231.   ndbrequire(tlist != NULL);
  233.   TriggerPtr tptr;
  234.   if (!tlist->seize(tptr))
  235.     return false;
  237.   // Set trigger id
  238.   tptr.p->triggerId = req->getTriggerId();
  240.   //  ndbout_c("Create TupTrigger %u = %u %u %u %u", tptr.p->triggerId, table, ttype, ttime, tevent);
  242.   // Set index id
  243.   tptr.p->indexId = req->getIndexId();
  245.   // Set trigger type etc
  246.   tptr.p->triggerType = ttype;
  247.   tptr.p->triggerActionTime = ttime;
  248.   tptr.p->triggerEvent = tevent;
  250.   tptr.p->sendBeforeValues = true;
  251.   if ((tptr.p->triggerType == TriggerType::SUBSCRIPTION) &&
  252.       ((tptr.p->triggerEvent == TriggerEvent::TE_UPDATE) ||
  253.        (tptr.p->triggerEvent == TriggerEvent::TE_DELETE))) {
  254.     ljam();
  255.     tptr.p->sendBeforeValues = false;
  256.   }
  257.   tptr.p->sendOnlyChangedAttributes = false;
  258.   if (((tptr.p->triggerType == TriggerType::SUBSCRIPTION) ||
  259.       (tptr.p->triggerType == TriggerType::SUBSCRIPTION_BEFORE)) &&
  260.       (tptr.p->triggerEvent == TriggerEvent::TE_UPDATE)) {
  261.     ljam();
  262.     tptr.p->sendOnlyChangedAttributes = true;
  263.   }
  265.   // Set monitor all
  266.   tptr.p->monitorAllAttributes = req->getMonitorAllAttributes();
  267.   tptr.p->monitorReplicas = req->getMonitorReplicas();
  268.   tptr.p->m_receiverBlock = refToBlock(req->getReceiverRef());
  270.   tptr.p->attributeMask.clear();
  271.   if (tptr.p->monitorAllAttributes) {
  272.     ljam();
  273.     for(Uint32 i = 0; i < table->noOfAttr; i++) {
  274.       if (!primaryKey(table, i)) {
  275.         ljam();
  276.         tptr.p->attributeMask.set(i);
  277.       }
  278.     }
  279.   } else {
  280.     // Set attribute mask
  281.     ljam();
  282.     tptr.p->attributeMask = req->getAttributeMask();
  283.   }
  284.   return true;
  285. }//Dbtup::createTrigger()
  287. bool
  288. Dbtup::primaryKey(Tablerec* const regTabPtr, Uint32 attrId)
  289. {
  290.   Uint32 attrDescriptorStart = regTabPtr->tabDescriptor;
  291.   Uint32 attrDescriptor = getTabDescrWord(attrDescriptorStart + (attrId * ZAD_SIZE));
  292.   return (bool)AttributeDescriptor::getPrimaryKey(attrDescriptor);
  293. }//Dbtup::primaryKey()
  295. /* ---------------------------------------------------------------- */
  296. /* -------------------------- dropTrigger ------------------------- */
  297. /*                                                                  */
  298. /* Deletes a trigger record by disassociating it with the given     */
  299. /* table and returning it to the trigger pool.                      */
  300. /* Trigger type can be one of secondary_index, subscription,        */
  301. /* constraint(NYI), foreign_key(NYI), schema_upgrade(NYI),          */
  302. /* api_trigger(NYI) or sql_trigger(NYI).                            */   
  303. /*                                                                  */
  304. /* ---------------------------------------------------------------- */
  305. Uint32
  306. Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req)
  307. {
  308.   if (ERROR_INSERTED(4004)) {
  309.     CLEAR_ERROR_INSERT_VALUE;
  310.     return 9999;
  311.   }
  312.   Uint32 triggerId = req->getTriggerId();
  314.   TriggerType::Value ttype = req->getTriggerType();
  315.   TriggerActionTime::Value ttime = req->getTriggerActionTime();
  316.   TriggerEvent::Value tevent = req->getTriggerEvent();
  318.   //  ndbout_c("Drop TupTrigger %u = %u %u %u %u", triggerId, table, ttype, ttime, tevent);
  320.   ArrayList<TupTriggerData>* tlist = findTriggerList(table, ttype, ttime, tevent);
  321.   ndbrequire(tlist != NULL);
  323.   Ptr<TupTriggerData> ptr;
  324.   for (tlist->first(ptr); !ptr.isNull(); tlist->next(ptr)) {
  325.     ljam();
  326.     if (ptr.p->triggerId == triggerId) {
  327.       ljam();
  328.       tlist->release(ptr.i);
  329.       return 0;
  330.     }
  331.   }
  332.   return DropTrigRef::TriggerNotFound;
  333. }//Dbtup::dropTrigger()
  335. /* ---------------------------------------------------------------- */
  336. /* -------------- checkImmediateTriggersAfterOp ------------------ */
  337. /*                                                                  */
  338. /* Called after an insert, delete, or update operation takes        */
  339. /* place. Fetches before tuple for deletes and updates and          */
  340. /* after tuple for inserts and updates.                             */
  341. /* Executes immediate triggers by sending FIRETRIGORD               */
  342. /*                                                                  */
  343. /* ---------------------------------------------------------------- */
  344. void Dbtup::checkImmediateTriggersAfterInsert(Signal* signal, 
  345.                                               Operationrec* const regOperPtr, 
  346.                                               Tablerec* const regTablePtr)
  347. {
  348.   if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) {
  349.     return;
  350.   }
  352.   if ((regOperPtr->primaryReplica) &&
  353.       (!(regTablePtr->afterInsertTriggers.isEmpty()))) {
  354.     ljam();
  355.     fireImmediateTriggers(signal,
  356.                           regTablePtr->afterInsertTriggers,
  357.                           regOperPtr);
  358.   }//if
  359. }//Dbtup::checkImmediateTriggersAfterInsert()
  361. void Dbtup::checkImmediateTriggersAfterUpdate(Signal* signal, 
  362.                                               Operationrec* const regOperPtr, 
  363.                                               Tablerec* const regTablePtr)
  364. {
  365.   if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) {
  366.     return;
  367.   }
  369.   if ((regOperPtr->primaryReplica) &&
  370.       (!(regTablePtr->afterUpdateTriggers.isEmpty()))) {
  371.     ljam();
  372.     fireImmediateTriggers(signal,
  373.                           regTablePtr->afterUpdateTriggers,
  374.                           regOperPtr);
  375.   }//if
  376.   if ((regOperPtr->primaryReplica) &&
  377.       (!(regTablePtr->constraintUpdateTriggers.isEmpty()))) {
  378.     ljam();
  379.     fireImmediateTriggers(signal,
  380.                           regTablePtr->constraintUpdateTriggers,
  381.                           regOperPtr);
  382.   }//if
  383. }//Dbtup::checkImmediateTriggersAfterUpdate()
  385. void Dbtup::checkImmediateTriggersAfterDelete(Signal* signal, 
  386.                                               Operationrec* const regOperPtr, 
  387.                                               Tablerec* const regTablePtr)
  388. {
  389.   if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) {
  390.     return;
  391.   }
  393.   if ((regOperPtr->primaryReplica) &&
  394.       (!(regTablePtr->afterDeleteTriggers.isEmpty()))) {
  395.     ljam();
  396.     executeTriggers(signal,
  397.                     regTablePtr->afterDeleteTriggers,
  398.                     regOperPtr);
  399.   }//if
  400. }//Dbtup::checkImmediateTriggersAfterDelete()
  402. #if 0
  403. /* ---------------------------------------------------------------- */
  404. /* --------------------- checkDeferredTriggers -------------------- */
  405. /*                                                                  */
  406. /* Called before commit after an insert, delete, or update          */
  407. /* operation. Fetches before tuple for deletes and updates and      */
  408. /* after tuple for inserts and updates.                             */
  409. /* Executes deferred triggers by sending FIRETRIGORD                */
  410. /*                                                                  */
  411. /* ---------------------------------------------------------------- */
  412. void Dbtup::checkDeferredTriggers(Signal* signal, 
  413.                                   Operationrec* const regOperPtr,
  414.                                   Tablerec* const regTablePtr)
  415. {
  416.   ljam();
  417.   // NYI
  418. }//Dbtup::checkDeferredTriggers()
  419. #endif
  421. /* ---------------------------------------------------------------- */
  422. /* --------------------- checkDetachedTriggers -------------------- */
  423. /*                                                                  */
  424. /* Called at commit after an insert, delete, or update operation.   */
  425. /* Fetches before tuple for deletes and updates and                 */
  426. /* after tuple for inserts and updates.                             */
  427. /* Executes detached triggers by sending FIRETRIGORD                */
  428. /*                                                                  */
  429. /* ---------------------------------------------------------------- */
  430. void Dbtup::checkDetachedTriggers(Signal* signal, 
  431.                                   Operationrec* const regOperPtr,
  432.                                   Tablerec* const regTablePtr)
  433. {
  434.   switch(regOperPtr->optype) {
  435.   case(ZINSERT):
  436.     ljam();
  437.     if (regTablePtr->subscriptionInsertTriggers.isEmpty()) {
  438.       // Table has no active triggers monitoring inserts at commit
  439.       ljam();
  440.       return;
  441.     }//if
  443.     // If any fired immediate insert trigger then fetch after tuple
  444.     fireDetachedTriggers(signal, 
  445.                          regTablePtr->subscriptionInsertTriggers, 
  446.                          regOperPtr);
  447.     break;
  448.   case(ZDELETE):
  449.     ljam();
  450.     if (regTablePtr->subscriptionDeleteTriggers.isEmpty()) {
  451.       // Table has no active triggers monitoring deletes at commit
  452.       ljam();
  453.       return;
  454.     }//if
  456.     // Execute any after delete triggers by sending 
  457.     // FIRETRIGORD with the before tuple
  458.     executeTriggers(signal, 
  459.                     regTablePtr->subscriptionDeleteTriggers, 
  460.                     regOperPtr);
  461.     break;
  462.   case(ZUPDATE):
  463.     ljam();
  464.     if (regTablePtr->subscriptionUpdateTriggers.isEmpty()) {
  465.       // Table has no active triggers monitoring updates at commit
  466.       ljam();
  467.       return;
  468.     }//if
  470.     // If any fired immediate update trigger then fetch after tuple
  471.     // and send two FIRETRIGORD one with before tuple and one with after tuple
  472.     fireDetachedTriggers(signal, 
  473.                          regTablePtr->subscriptionUpdateTriggers, 
  474.                          regOperPtr);
  475.     break;
  476.   default:
  477.     ndbrequire(false);
  478.     break;
  479.   }//switch
  480. }//Dbtup::CheckDetachedTriggers()
  482. void 
  483. Dbtup::fireImmediateTriggers(Signal* signal, 
  484.                              ArrayList<TupTriggerData>& triggerList, 
  485.                              Operationrec* const regOperPtr)
  486. {
  487.   TriggerPtr trigPtr;
  488.   triggerList.first(trigPtr);
  489.   while (trigPtr.i != RNIL) {
  490.     ljam();
  491.     if (trigPtr.p->monitorAllAttributes ||
  492.         trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask)) {
  493.       ljam();
  494.       executeTrigger(signal,
  495.                      trigPtr.p,
  496.                      regOperPtr);
  497.     }//if
  498.     triggerList.next(trigPtr);
  499.   }//while
  500. }//Dbtup::fireImmediateTriggers()
  502. #if 0
  503. void 
  504. Dbtup::fireDeferredTriggers(Signal* signal, 
  505.                             ArrayList<TupTriggerData>& triggerList, 
  506.                             Operationrec* const regOperPtr)
  507. {
  508.   TriggerPtr trigPtr;
  509.   triggerList.first(trigPtr);
  510.   while (trigPtr.i != RNIL) {
  511.     ljam();
  512.     if (trigPtr.p->monitorAllAttributes ||
  513.         trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask)) {
  514.       ljam();
  515.       executeTrigger(signal,
  516.                      trigPtr,
  517.                      regOperPtr);
  518.     }//if
  519.     triggerList.next(trigPtr);
  520.   }//while
  521. }//Dbtup::fireDeferredTriggers()
  522. #endif
  524. void 
  525. Dbtup::fireDetachedTriggers(Signal* signal, 
  526.                             ArrayList<TupTriggerData>& triggerList, 
  527.                             Operationrec* const regOperPtr)
  528. {
  529.   TriggerPtr trigPtr;  
  530.   triggerList.first(trigPtr);
  531.   while (trigPtr.i != RNIL) {
  532.     ljam();
  533.     if ((trigPtr.p->monitorReplicas || regOperPtr->primaryReplica) &&
  534.         (trigPtr.p->monitorAllAttributes ||
  535.          trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask))) {
  536.       ljam();
  537.       executeTrigger(signal,
  538.                      trigPtr.p,
  539.                      regOperPtr);
  540.     }//if
  541.     triggerList.next(trigPtr);
  542.   }//while
  543. }//Dbtup::fireDetachedTriggers()
  545. void Dbtup::executeTriggers(Signal* signal, 
  546.                             ArrayList<TupTriggerData>& triggerList, 
  547.                             Operationrec* regOperPtr)
  548. {
  549.   TriggerPtr trigPtr;
  550.   triggerList.first(trigPtr);
  551.   while (trigPtr.i != RNIL) {
  552.     ljam();
  553.     executeTrigger(signal,
  554.                    trigPtr.p,
  555.                    regOperPtr);
  556.     triggerList.next(trigPtr);
  558.   }//while
  559. }//Dbtup::executeTriggers()
  561. void Dbtup::executeTrigger(Signal* signal,
  562.                            TupTriggerData* const trigPtr,
  563.                            Operationrec* const regOperPtr)
  564. {
  566.   /**
  567.    * The block below does not work together with GREP.
  568.    * I have 2 db nodes (2 replicas) -> one node group.
  569.    * I want to have FIRETRIG_ORD sent to all SumaParticipants,
  570.    * from all nodes in the node group described above. However, 
  571.    * only one of the nodes in the node group actually sends the
  572.    *  FIRE_TRIG_ORD, and the other node enters this "hack" below.
  573.    * I don't really know what the code snippet below does, but it
  574.    * does not work with GREP the way Lars and I want it.
  575.    * We need to have triggers fired from both the primary and the
  576.    * backup replica, not only the primary as it is now.
  577.    * 
  578.    * Note: In Suma, I have changed triggers to be created with
  579.    * setMonitorReplicas(true).
  580.    * /Johan
  581.    *
  582.    * See RT 709
  583.    */
  584.   // XXX quick fix to NR, should fix in LQHKEYREQ instead
  585.   /*  
  586.       if (refToBlock(regOperPtr->coordinatorTC) == DBLQH) {
  587.       jam();
  588.       return;
  589.       }
  590.   */
  591.   BlockReference ref = trigPtr->m_receiverBlock;
  592.   Uint32* const keyBuffer = &cinBuffer[0];
  593.   Uint32* const mainBuffer = &coutBuffer[0];
  594.   Uint32* const copyBuffer = &clogMemBuffer[0];
  596.   Uint32 noPrimKey, noMainWords, noCopyWords;
  598.   if (ref == BACKUP) {
  599.     ljam();
  600.     /*
  601.     In order for the implementation of BACKUP to work even when changing
  602.     primaries in the middle of the backup we need to set the trigger on
  603.     all replicas. This check checks whether this is the node where this
  604.     trigger should be fired. The check should preferably have been put
  605.     completely in the BACKUP block but it was about five times simpler
  606.     to put it here and also much faster for the backup (small overhead
  607.     for everybody else.
  608.     */
  609.     signal->theData[0] = trigPtr->triggerId;
  610.     signal->theData[1] = regOperPtr->fragId;
  611.     EXECUTE_DIRECT(BACKUP, GSN_BACKUP_TRIG_REQ, signal, 2);
  612.     ljamEntry();
  613.     if (signal->theData[0] == 0) {
  614.       ljam();
  615.       return;
  616.     }//if
  617.   }//if
  618.   if (!readTriggerInfo(trigPtr,
  619.                        regOperPtr,
  620.                        keyBuffer,
  621.                        noPrimKey,
  622.                        mainBuffer,
  623.                        noMainWords,
  624.                        copyBuffer,
  625.                        noCopyWords,
  626.        (ref == BACKUP ? false : true))) {
  627.     ljam();
  628.     return;
  629.   }//if
  630. //--------------------------------------------------------------------
  631. // Now all data for this trigger has been read. It is now time to send
  632. // the trigger information consisting of two or three sets of TRIG_
  633. // ATTRINFO signals and one FIRE_TRIG_ORD signal.
  634. // We start by setting common header info for all TRIG_ATTRINFO signals.
  635. //--------------------------------------------------------------------
  636.   bool executeDirect;
  637.   TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend();
  638.   trigAttrInfo->setConnectionPtr(regOperPtr->tcOpIndex);
  639.   trigAttrInfo->setTriggerId(trigPtr->triggerId);
  641.   switch(trigPtr->triggerType) {
  642.   case (TriggerType::SECONDARY_INDEX):
  643.     ljam();
  644.     ref = regOperPtr->coordinatorTC;
  645.     executeDirect = false;
  646.     break;
  647.   case (TriggerType::SUBSCRIPTION):
  648.   case (TriggerType::SUBSCRIPTION_BEFORE):
  649.     ljam();
  650.     // Since only backup uses subscription triggers we send to backup directly for now
  651.     ref = trigPtr->m_receiverBlock;
  652.     executeDirect = true;
  653.     break;
  654.   case (TriggerType::READ_ONLY_CONSTRAINT):
  655.     terrorCode = ZREAD_ONLY_CONSTRAINT_VIOLATION;
  656.     // XXX should return status and abort the rest
  657.     return;
  658.   default:
  659.     ndbrequire(false);
  660.     executeDirect= false; // remove warning
  661.   }//switch
  663.   regOperPtr->noFiredTriggers++;
  665.   trigAttrInfo->setAttrInfoType(TrigAttrInfo::PRIMARY_KEY);
  666.   sendTrigAttrInfo(signal, keyBuffer, noPrimKey, executeDirect, ref);
  668.   Uint32 noAfter = 0;
  669.   Uint32 noBefore = 0;
  670.   switch(regOperPtr->optype) {
  671.   case(ZINSERT):
  672.     ljam();
  673.     // Send AttrInfo signals with new attribute values
  674.     trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES);
  675.     sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref);
  676.     noAfter = noMainWords;
  677.     break;
  678.   case(ZDELETE):
  679.     if (trigPtr->sendBeforeValues) {
  680.       ljam();
  681.       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
  682.       sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref);
  683.       noBefore = noMainWords;
  684.     }//if
  685.     break;
  686.   case(ZUPDATE):
  687.     ljam();
  688.     if (trigPtr->sendBeforeValues) {
  689.       ljam();
  690.       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
  691.       sendTrigAttrInfo(signal, copyBuffer, noCopyWords, executeDirect, ref);
  692.       noBefore = noCopyWords;
  693.     }//if
  694.     trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES);
  695.     sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref);
  696.     noAfter = noMainWords;
  697.     break;
  698.   default:
  699.     ndbrequire(false);
  700.   }//switch
  701.   sendFireTrigOrd(signal,
  702.                   regOperPtr,
  703.                   trigPtr,
  704.                   noPrimKey,
  705.                   noBefore,
  706.                   noAfter);
  707. }//Dbtup::executeTrigger()
  709. Uint32 Dbtup::setAttrIds(Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask, 
  710.                          Uint32 noOfAttributes, 
  711.                          Uint32* inBuffer)
  712. {
  713.   Uint32 bufIndx = 0;
  714.   for (Uint32 i = 0; i < noOfAttributes; i++) {
  715.     ljam();
  716.     if (attributeMask.get(i)) {
  717.       ljam();
  718.       AttributeHeader::init(&inBuffer[bufIndx++], i, 0);
  719.     }//if
  720.   }//for
  721.   return bufIndx;
  722. }//Dbtup::setAttrIds()
  724. bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
  725.                             Operationrec* const regOperPtr, 
  726.                             Uint32* const keyBuffer,
  727.                             Uint32& noPrimKey,
  728.                             Uint32*  const mainBuffer,
  729.                             Uint32& noMainWords,
  730.                             Uint32* const copyBuffer,
  731.                             Uint32& noCopyWords,
  732.     bool xfrm)
  733. {
  734.   noCopyWords = 0;
  735.   noMainWords = 0;
  736.   Uint32 readBuffer[MAX_ATTRIBUTES_IN_TABLE];
  737.   PagePtr pagep;
  739. //---------------------------------------------------------------------------
  740. // Set-up variables needed by readAttributes operPtr.p, tabptr.p
  741. //---------------------------------------------------------------------------
  742.   operPtr.p = regOperPtr;
  743.   tabptr.i = regOperPtr->tableRef;
  744.   ptrCheckGuard(tabptr, cnoOfTablerec, tablerec);
  745.   Tablerec* const regTabPtr = tabptr.p;
  746. //--------------------------------------------------------------------
  747. // Initialise pagep and tuple offset for read of main tuple
  748. //--------------------------------------------------------------------
  749.   Uint32 tupheadoffset = regOperPtr->pageOffset;
  750.   pagep.i = regOperPtr->realPageId;
  751.   ptrCheckGuard(pagep, cnoOfPage, page);
  753. //--------------------------------------------------------------------
  754. // Read Primary Key Values
  755. //--------------------------------------------------------------------
  756.   int ret= readAttributes(pagep.p,
  757.   tupheadoffset,
  758.   &tableDescriptor[regTabPtr->readKeyArray].tabDescr,
  759.   regTabPtr->noOfKeyAttr,
  760.   keyBuffer,
  761.   ZATTR_BUFFER_SIZE,
  762.   xfrm);
  763.   ndbrequire(ret != -1);
  764.   noPrimKey= ret;
  766.   Uint32 numAttrsToRead;
  767.   if ((regOperPtr->optype == ZUPDATE) &&
  768.       (trigPtr->sendOnlyChangedAttributes)) {
  769.     ljam();
  770. //--------------------------------------------------------------------
  771. // Update that sends only changed information
  772. //--------------------------------------------------------------------
  773.     Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;
  774.     attributeMask = trigPtr->attributeMask;
  775.     attributeMask.bitAND(regOperPtr->changeMask);
  776.     numAttrsToRead = setAttrIds(attributeMask, regTabPtr->noOfAttr, &readBuffer[0]);
  778.   } else if ((regOperPtr->optype == ZDELETE) &&
  779.              (!trigPtr->sendBeforeValues)) {
  780.     ljam();
  781. //--------------------------------------------------------------------
  782. // Delete without sending before values only read Primary Key
  783. //--------------------------------------------------------------------
  784.     return true;
  785.   } else {
  786.     ljam();
  787. //--------------------------------------------------------------------
  788. // All others send all attributes that are monitored
  789. //--------------------------------------------------------------------
  790.     numAttrsToRead = setAttrIds(trigPtr->attributeMask, regTabPtr->noOfAttr, &readBuffer[0]);
  791.   }//if
  792.   ndbrequire(numAttrsToRead < MAX_ATTRIBUTES_IN_TABLE);
  793. //--------------------------------------------------------------------
  794. // Read Main tuple values
  795. //--------------------------------------------------------------------
  796.   if ((regOperPtr->optype != ZDELETE) ||
  797.       (trigPtr->sendBeforeValues)) {
  798.     ljam();
  799.     int ret= readAttributes(pagep.p,
  800.     tupheadoffset,
  801.     &readBuffer[0],
  802.     numAttrsToRead,
  803.     mainBuffer,
  804.     ZATTR_BUFFER_SIZE,
  805.     xfrm);
  806.     ndbrequire(ret != -1);
  807.     noMainWords= ret;
  808.   } else {
  809.     ljam();
  810.     noMainWords = 0;
  811.   }//if
  812. //--------------------------------------------------------------------
  813. // Read Copy tuple values for UPDATE's
  814. //--------------------------------------------------------------------
  815. // Initialise pagep and tuple offset for read of copy tuple
  816. //--------------------------------------------------------------------
  817.   if ((regOperPtr->optype == ZUPDATE) &&
  818.       (trigPtr->sendBeforeValues)) {
  819.     ljam();
  821.     tupheadoffset = regOperPtr->pageOffsetC;
  822.     pagep.i = regOperPtr->realPageIdC;
  823.     ptrCheckGuard(pagep, cnoOfPage, page);
  825.     int ret= readAttributes(pagep.p,
  826.     tupheadoffset,
  827.     &readBuffer[0],
  828.     numAttrsToRead,
  829.     copyBuffer,
  830.     ZATTR_BUFFER_SIZE,
  831.     xfrm);
  833.     ndbrequire(ret != -1);
  834.     noCopyWords = ret;
  835.     if ((noMainWords == noCopyWords) &&
  836.         (memcmp(mainBuffer, copyBuffer, noMainWords << 2) == 0)) {
  837. //--------------------------------------------------------------------
  838. // Although a trigger was fired it was not necessary since the old
  839. // value and the new value was exactly the same
  840. //--------------------------------------------------------------------
  841.       ljam();
  842.       return false;
  843.     }//if
  844.   }//if
  845.   return true;
  846. }//Dbtup::readTriggerInfo()
  848. void Dbtup::sendTrigAttrInfo(Signal* signal, 
  849.                              Uint32* data, 
  850.                              Uint32  dataLen,
  851.                              bool    executeDirect,
  852.                              BlockReference receiverReference)
  853. {
  854.   TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend();
  855.   Uint32 sigLen;
  856.   Uint32 dataIndex = 0;
  857.   do {
  858.     sigLen = dataLen - dataIndex;
  859.     if (sigLen > TrigAttrInfo::DataLength) {
  860.       ljam();
  861.       sigLen = TrigAttrInfo::DataLength;
  862.     }//if
  863.     MEMCOPY_NO_WORDS(trigAttrInfo->getData(), 
  864.                      data + dataIndex,
  865.                      sigLen);
  866.     if (executeDirect) {
  867.       ljam();
  868.       EXECUTE_DIRECT(receiverReference, 
  869.                      GSN_TRIG_ATTRINFO,
  870.                      signal,
  871.      TrigAttrInfo::StaticLength + sigLen);
  872.       ljamEntry();
  873.     } else {
  874.       ljam();
  875.       sendSignal(receiverReference, 
  876.                  GSN_TRIG_ATTRINFO, 
  877.                  signal, 
  878.                  TrigAttrInfo::StaticLength + sigLen,
  879.                  JBB);
  880.     }//if
  881.     dataIndex += sigLen;
  882.   } while (dataLen != dataIndex);
  883. }//Dbtup::sendTrigAttrInfo()
  885. void Dbtup::sendFireTrigOrd(Signal* signal, 
  886.                             Operationrec * const regOperPtr, 
  887.                             TupTriggerData* const trigPtr, 
  888.                             Uint32 noPrimKeyWords, 
  889.                             Uint32 noBeforeValueWords, 
  890.                             Uint32 noAfterValueWords)
  891. {
  892.   FireTrigOrd* const fireTrigOrd = (FireTrigOrd *)signal->getDataPtrSend();
  893.   
  894.   fireTrigOrd->setConnectionPtr(regOperPtr->tcOpIndex);
  895.   fireTrigOrd->setTriggerId(trigPtr->triggerId);
  897.   switch(regOperPtr->optype) {
  898.   case(ZINSERT):
  899.     ljam();
  900.     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT);
  901.     break;
  902.   case(ZDELETE):
  903.     ljam();
  904.     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE);
  905.     break;
  906.   case(ZUPDATE):
  907.     ljam();
  908.     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE);
  909.     break;
  910.   default:
  911.     ndbrequire(false);
  912.     break;
  913.   }//switch
  915.   fireTrigOrd->setNoOfPrimaryKeyWords(noPrimKeyWords);
  916.   fireTrigOrd->setNoOfBeforeValueWords(noBeforeValueWords);
  917.   fireTrigOrd->setNoOfAfterValueWords(noAfterValueWords);
  919.   switch(trigPtr->triggerType) {
  920.   case (TriggerType::SECONDARY_INDEX):
  921.     ljam();
  922.     sendSignal(regOperPtr->coordinatorTC, GSN_FIRE_TRIG_ORD, 
  923.                signal, FireTrigOrd::SignalLength, JBB);
  924.     break;
  925.   case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma
  926.     ljam();
  927.     // Since only backup uses subscription triggers we 
  928.     // send to backup directly for now
  929.     fireTrigOrd->setGCI(regOperPtr->gci);
  930.     fireTrigOrd->setHashValue(regOperPtr->hashValue);
  931.     EXECUTE_DIRECT(trigPtr->m_receiverBlock,
  932.                    GSN_FIRE_TRIG_ORD,
  933.                    signal,
  934.    FireTrigOrd::SignalWithHashValueLength);
  935.     break;
  936.   case (TriggerType::SUBSCRIPTION):
  937.     ljam();
  938.     // Since only backup uses subscription triggers we 
  939.     // send to backup directly for now
  940.     fireTrigOrd->setGCI(regOperPtr->gci);
  941.     EXECUTE_DIRECT(trigPtr->m_receiverBlock,
  942.                    GSN_FIRE_TRIG_ORD,
  943.                    signal,
  944.    FireTrigOrd::SignalWithGCILength);
  945.     break;
  946.   default:
  947.     ndbrequire(false);
  948.     break;
  949.   }//switch
  950. }//Dbtup::sendFireTrigOrd()
  952. /*
  953.  * Ordered index triggers.
  954.  *
  955.  * Insert: add entry to index
  956.  * Update: add entry to index, de|ay remove until commit
  957.  * Delete: do nothing, delay remove until commit
  958.  * Commit: remove entry delayed from update and delete
  959.  * Abort : remove entry added by insert and update
  960.  *
  961.  * See Notes.txt for the details.
  962.  */
  964. int
  965. Dbtup::executeTuxInsertTriggers(Signal* signal,
  966.                                 Operationrec* const regOperPtr,
  967.                                 Tablerec* const regTabPtr)
  968. {
  969.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  970.   PagePtr pagePtr;
  971.   pagePtr.i = regOperPtr->realPageId;
  972.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  973.   Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
  974.   ndbrequire(tupVersion == regOperPtr->tupVersion);
  975.   // fill in constant part
  976.   req->tableId = regOperPtr->tableRef;
  977.   req->fragId = regOperPtr->fragId;
  978.   req->pageId = regOperPtr->realPageId;
  979.   req->pageOffset = regOperPtr->pageOffset;
  980.   req->tupVersion = tupVersion;
  981.   req->opInfo = TuxMaintReq::OpAdd;
  982.   return addTuxEntries(signal, regOperPtr, regTabPtr);
  983. }
  985. int
  986. Dbtup::executeTuxUpdateTriggers(Signal* signal,
  987.                                 Operationrec* const regOperPtr,
  988.                                 Tablerec* const regTabPtr)
  989. {
  990.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  991.   PagePtr pagePtr;
  992.   pagePtr.i = regOperPtr->realPageId;
  993.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  994.   Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
  995.   ndbrequire(tupVersion == regOperPtr->tupVersion);
  996.   // fill in constant part
  997.   req->tableId = regOperPtr->tableRef;
  998.   req->fragId = regOperPtr->fragId;
  999.   req->pageId = regOperPtr->realPageId;
  1000.   req->pageOffset = regOperPtr->pageOffset;
  1001.   req->tupVersion = tupVersion;
  1002.   req->opInfo = TuxMaintReq::OpAdd;
  1003.   return addTuxEntries(signal, regOperPtr, regTabPtr);
  1004. }
  1006. int
  1007. Dbtup::addTuxEntries(Signal* signal,
  1008.                      Operationrec* regOperPtr,
  1009.                      Tablerec* regTabPtr)
  1010. {
  1011.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  1012.   const ArrayList<TupTriggerData>& triggerList = regTabPtr->tuxCustomTriggers;
  1013.   TriggerPtr triggerPtr;
  1014.   Uint32 failPtrI;
  1015.   triggerList.first(triggerPtr);
  1016.   while (triggerPtr.i != RNIL) {
  1017.     ljam();
  1018.     req->indexId = triggerPtr.p->indexId;
  1019.     req->errorCode = RNIL;
  1020.     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
  1021.         signal, TuxMaintReq::SignalLength);
  1022.     ljamEntry();
  1023.     if (req->errorCode != 0) {
  1024.       ljam();
  1025.       terrorCode = req->errorCode;
  1026.       failPtrI = triggerPtr.i;
  1027.       goto fail;
  1028.     }
  1029.     triggerList.next(triggerPtr);
  1030.   }
  1031.   return 0;
  1032. fail:
  1033.   req->opInfo = TuxMaintReq::OpRemove;
  1034.   triggerList.first(triggerPtr);
  1035.   while (triggerPtr.i != failPtrI) {
  1036.     ljam();
  1037.     req->indexId = triggerPtr.p->indexId;
  1038.     req->errorCode = RNIL;
  1039.     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
  1040.         signal, TuxMaintReq::SignalLength);
  1041.     ljamEntry();
  1042.     ndbrequire(req->errorCode == 0);
  1043.     triggerList.next(triggerPtr);
  1044.   }
  1045. #ifdef VM_TRACE
  1046.   ndbout << "aborted partial tux update: op " << hex << regOperPtr << endl;
  1047. #endif
  1048.   return -1;
  1049. }
  1051. int
  1052. Dbtup::executeTuxDeleteTriggers(Signal* signal,
  1053.                                 Operationrec* const regOperPtr,
  1054.                                 Tablerec* const regTabPtr)
  1055. {
  1056.   // do nothing
  1057.   return 0;
  1058. }
  1060. void
  1061. Dbtup::executeTuxCommitTriggers(Signal* signal,
  1062.                                 Operationrec* regOperPtr,
  1063.                                 Tablerec* const regTabPtr)
  1064. {
  1065.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  1066.   // get version
  1067.   Uint32 tupVersion;
  1068.   if (regOperPtr->optype == ZINSERT) {
  1069.     if (! regOperPtr->deleteInsertFlag)
  1070.       return;
  1071.     ljam();
  1072.     PagePtr pagePtr;
  1073.     pagePtr.i = regOperPtr->realPageIdC;
  1074.     ptrCheckGuard(pagePtr, cnoOfPage, page);
  1075.     tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1];
  1076.     ndbrequire(tupVersion != regOperPtr->tupVersion);
  1077.   } else if (regOperPtr->optype == ZUPDATE) {
  1078.     ljam();
  1079.     PagePtr pagePtr;
  1080.     pagePtr.i = regOperPtr->realPageIdC;
  1081.     ptrCheckGuard(pagePtr, cnoOfPage, page);
  1082.     tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1];
  1083.     ndbrequire(tupVersion != regOperPtr->tupVersion);
  1084.   } else if (regOperPtr->optype == ZDELETE) {
  1085.     if (regOperPtr->deleteInsertFlag)
  1086.       return;
  1087.     ljam();
  1088.     PagePtr pagePtr;
  1089.     pagePtr.i = regOperPtr->realPageId;
  1090.     ptrCheckGuard(pagePtr, cnoOfPage, page);
  1091.     tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
  1092.     ndbrequire(tupVersion == regOperPtr->tupVersion);
  1093.   } else {
  1094.     ndbrequire(false);
  1095.     tupVersion= 0; // remove warning
  1096.   }
  1097.   // fill in constant part
  1098.   req->tableId = regOperPtr->tableRef;
  1099.   req->fragId = regOperPtr->fragId;
  1100.   req->pageId = regOperPtr->realPageId;
  1101.   req->pageOffset = regOperPtr->pageOffset;
  1102.   req->tupVersion = tupVersion;
  1103.   req->opInfo = TuxMaintReq::OpRemove;
  1104.   removeTuxEntries(signal, regOperPtr, regTabPtr);
  1105. }
  1107. void
  1108. Dbtup::executeTuxAbortTriggers(Signal* signal,
  1109.                                Operationrec* regOperPtr,
  1110.                                Tablerec* const regTabPtr)
  1111. {
  1112.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  1113.   // get version
  1114.   Uint32 tupVersion;
  1115.   if (regOperPtr->optype == ZINSERT) {
  1116.     ljam();
  1117.     tupVersion = regOperPtr->tupVersion;
  1118.   } else if (regOperPtr->optype == ZUPDATE) {
  1119.     ljam();
  1120.     tupVersion = regOperPtr->tupVersion;
  1121.   } else if (regOperPtr->optype == ZDELETE) {
  1122.     ljam();
  1123.     return;
  1124.   } else {
  1125.     ndbrequire(false);
  1126.     tupVersion= 0; // remove warning
  1127.   }
  1128.   // fill in constant part
  1129.   req->tableId = regOperPtr->tableRef;
  1130.   req->fragId = regOperPtr->fragId;
  1131.   req->pageId = regOperPtr->realPageId;
  1132.   req->pageOffset = regOperPtr->pageOffset;
  1133.   req->tupVersion = tupVersion;
  1134.   req->opInfo = TuxMaintReq::OpRemove;
  1135.   removeTuxEntries(signal, regOperPtr, regTabPtr);
  1136. }
  1138. void
  1139. Dbtup::removeTuxEntries(Signal* signal,
  1140.                         Operationrec* regOperPtr,
  1141.                         Tablerec* regTabPtr)
  1142. {
  1143.   TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  1144.   const ArrayList<TupTriggerData>& triggerList = regTabPtr->tuxCustomTriggers;
  1145.   TriggerPtr triggerPtr;
  1146.   triggerList.first(triggerPtr);
  1147.   while (triggerPtr.i != RNIL) {
  1148.     ljam();
  1149.     req->indexId = triggerPtr.p->indexId;
  1150.     req->errorCode = RNIL,
  1151.     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
  1152.         signal, TuxMaintReq::SignalLength);
  1153.     ljamEntry();
  1154.     // must succeed
  1155.     ndbrequire(req->errorCode == 0);
  1156.     triggerList.next(triggerPtr);
  1157.   }
  1158. }