bk commit into 5.1 tree (pekka:1.2423)

[pekka]

Below is the list of changes that have just been committed into a local
5.1 repository of pekka. When pekka does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-03-26 17:07:35+02:00, pekka@stripped +2 -0
  ndb - wl#3600 alter table mutex,cleanup

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp@stripped, 2007-03-26 17:06:51+02:00,
pekka@stripped +225 -1126
    wl#3600 alter table mutex,cleanup

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp@stripped, 2007-03-26 17:06:51+02:00,
pekka@stripped +9 -18
    wl#3600 alter table mutex,cleanup

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	pekka
# Host:	clam.(none)
# Root:	/export/space/pekka/ndb/version/my52-wl3600-a

--- 1.165/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2007-03-26 01:49:02 +02:00
+++ 1.166/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2007-03-26 17:06:51 +02:00
@@ -1636,7 +1636,6 @@
   addRecSignal(GSN_TAB_COMMITCONF, &Dbdict::execTAB_COMMITCONF);
   addRecSignal(GSN_TAB_COMMITREF, &Dbdict::execTAB_COMMITREF);
   addRecSignal(GSN_ALTER_TABLE_REQ, &Dbdict::execALTER_TABLE_REQ);
-  addRecSignal(GSN_ALTER_TAB_REQ, &Dbdict::execALTER_TAB_REQ);
   addRecSignal(GSN_ALTER_TAB_REF, &Dbdict::execALTER_TAB_REF);
   addRecSignal(GSN_ALTER_TAB_CONF, &Dbdict::execALTER_TAB_CONF);
 
@@ -6657,152 +6656,10 @@
 
   sendSignal(req->clientRef, GSN_ALTER_TABLE_REF, signal,
              AlterTableRef::SignalLength, JBB);
-
-#if wl3600_todo // to parse
-  // Received by master
-  jamEntry();
-  if(!assembleFragments(signal)){
-    return;
-  }
-  AlterTableReq* const req = (AlterTableReq*)signal->getDataPtr();
-  const Uint32 senderRef = req->senderRef;
-  const Uint32 senderData = req->senderData;
-  const Uint32 changeMask = req->changeMask;
-  const Uint32 tableId = req->tableId;
-  const Uint32 tableVersion = req->tableVersion;
-  ParseDictTabInfoRecord* aParseRecord;
-  
-  // Get table definition
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, tableId, false);
-  if(tablePtr.isNull()){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::NoSuchTable);
-    return;
-  }
-  
-  if(getOwnNodeId() != c_masterNodeId){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::NotMaster);
-    return;
-  }
-  
-  if(c_blockState == BS_NODE_RESTART){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::BusyWithNR);
-    return;
-  }
-  
-  if(c_blockState != BS_IDLE){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::Busy);
-    return;
-  }
-
-  if (!check_ndb_versions())
-  {
-    jam();
-    alterTableRef(signal, req, AlterTableRef::IncompatibleVersions);
-    return;
-  }
-  
-  const TableRecord::TabState tabState = tablePtr.p->tabState;
-  bool ok = false;
-  switch(tabState){
-  case TableRecord::NOT_DEFINED:
-  case TableRecord::REORG_TABLE_PREPARED:
-  case TableRecord::DEFINING:
-  case TableRecord::CHECKED:
-    jam();
-    alterTableRef(signal, req, AlterTableRef::NoSuchTable);
-    return;
-  case TableRecord::DEFINED:
-    ok = true;
-    jam();
-    break;
-  case TableRecord::BACKUP_ONGOING:
-    jam();
-    alterTableRef(signal, req, AlterTableRef::BackupInProgress);
-    return;
-  case TableRecord::PREPARE_DROPPING:
-  case TableRecord::DROPPING:
-    jam();
-    alterTableRef(signal, req, AlterTableRef::DropInProgress);
-    return;
-  }
-  ndbrequire(ok);
-
-  if(tablePtr.p->tableVersion != tableVersion){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::InvalidTableVersion);
-    return;
-  }
-  // Parse new table defintion
-  ParseDictTabInfoRecord parseRecord;
-  aParseRecord = &parseRecord;
-    
-  AlterTableDataPtr alterTabPtr; // Reuse create table records
-  c_opAlterTable.seize(alterTabPtr);
-  
-  if(alterTabPtr.isNull()){
-    jam();
-    alterTableRef(signal, req, AlterTableRef::Busy);
-    return;
-  }
-
-  alterTabPtr.p->m_changeMask = changeMask;
-  parseRecord.requestType = DictTabInfo::AlterTableFromAPI;
-  parseRecord.errorCode = 0;
-  
-  SegmentedSectionPtr ptr;
-  signal->getSection(ptr, AlterTableReq::DICT_TAB_INFO);
-  SimplePropertiesSectionReader r(ptr, getSectionSegmentPool());
-
-  handleTabInfoInit(r, &parseRecord, false); // Will not save info
-  
-  if(parseRecord.errorCode != 0){
-    jam();
-    c_opAlterTable.release(alterTabPtr);
-    alterTableRef(signal, req, 
-		  (AlterTableRef::ErrorCode) parseRecord.errorCode, 
-		  aParseRecord);
-    return;
-  }
-  
-  releaseSections(signal);
-  alterTabPtr.p->key = ++c_opRecordSequence;
-  c_opAlterTable.add(alterTabPtr);
-  ndbrequire(c_opAlterTable.find(alterTabPtr, alterTabPtr.p->key));
-  alterTabPtr.p->m_errorCode = 0;
-  alterTabPtr.p->m_senderRef = senderRef;
-  alterTabPtr.p->m_senderData = senderData;
-  alterTabPtr.p->m_tablePtrI = parseRecord.tablePtr.i;
-  alterTabPtr.p->m_alterTableFailed = false;
-  alterTabPtr.p->m_coordinatorRef = reference();
-  alterTabPtr.p->m_fragmentsPtrI = RNIL;
-  alterTabPtr.p->m_dihAddFragPtr = RNIL;
-  alterTabPtr.p->m_alterTableId = tablePtr.p->tableId;
-
-  // Send prepare request to all alive nodes
-  SimplePropertiesSectionWriter w(getSectionSegmentPool());
-  packTableIntoPages(w, parseRecord.tablePtr);
-  
-  SegmentedSectionPtr tabInfoPtr;
-  w.getPtr(tabInfoPtr);
-  
-  alterTabPtr.p->m_tabInfoPtrI = tabInfoPtr.i;
-
-  // Alter table on all nodes
-  c_blockState = BS_BUSY;
-
-  Mutex mutex(signal, c_mutexMgr, alterTabPtr.p->m_startLcpMutex);
-  Callback c = { safe_cast(&Dbdict::alterTable_backup_mutex_locked),
-		 alterTabPtr.p->key };
-  
-  ndbrequire(mutex.lock(c));
-#endif
 }
 
+// AlterTable PARSE
+
 void
 Dbdict::alterTable_parse(Signal* signal, SchemaOpPtr op_ptr, ErrorInfo& error)
 {
@@ -6905,11 +6762,8 @@
     alterTabPtr.p->m_oldTableEntry = *tableEntry;
   }
 
-  const bool fromMaster = (reference() == impl_req->senderRef);
-  ndbrequire(fromMaster == trans_ptr.p->m_isMaster);
-  
   // master rewrites DictTabInfo (it is re-parsed only on slaves)
-  if (fromMaster) {
+  if (trans_ptr.p->m_isMaster) {
     jam();
     releaseSections(signal);
     SimplePropertiesSectionWriter w(getSectionSegmentPool());
@@ -6922,34 +6776,6 @@
 
   // save sections
   saveOpSection(op_ptr, signal, AlterTabReq::DICT_TAB_INFO);
-
-#if wl3600_todo //out
-  alterTabPtr.p->key = ++c_opRecordSequence;
-  c_opAlterTable.add(alterTabPtr);
-  ndbrequire(c_opAlterTable.find(alterTabPtr, alterTabPtr.p->key));
-  alterTabPtr.p->m_errorCode = 0;
-  alterTabPtr.p->m_senderRef = senderRef;
-  alterTabPtr.p->m_senderData = senderData;
-  alterTabPtr.p->m_tablePtrI = parseRecord.tablePtr.i; // **new**
-  alterTabPtr.p->m_alterTableFailed = false;
-  alterTabPtr.p->m_coordinatorRef = reference();
-  alterTabPtr.p->m_fragmentsPtrI = RNIL;
-  alterTabPtr.p->m_dihAddFragPtr = RNIL;
-  alterTabPtr.p->m_alterTableId = tablePtr.p->tableId; // **old**
-#endif
-
-#if wl3600_todo //out
-  alterTabPtr.p->m_tabInfoPtrI = tabInfoPtr.i;
-
-  // Alter table on all nodes
-  c_blockState = BS_BUSY;
-
-  Mutex mutex(signal, c_mutexMgr, alterTabPtr.p->m_startLcpMutex);
-  Callback c = { safe_cast(&Dbdict::alterTable_backup_mutex_locked),
-		 alterTabPtr.p->key };
-  
-  ndbrequire(mutex.lock(c));
-#endif
 }
 
 bool
@@ -6997,6 +6823,8 @@
   }
 }
 
+// AlterTable PREPARE
+
 void
 Dbdict::alterTable_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
@@ -7009,63 +6837,122 @@
 
   D("alterTable_prepare" << V(itRepeat) << *op_ptr.p <<
*alterTabPtr.p);
 
-  if (itRepeat > 0) {
+  if (itRepeat == 0) {
     jam();
-    ndbrequire(alterTabPtr.p->m_blockIndex + 1 == itRepeat);
-    alterTable_toLocal(signal, op_ptr);
+
+    // master checks table state and all sync via next repeat
+
+    if (trans_ptr.p->m_isMaster) {
+      jam();
+      Mutex mutex(signal, c_mutexMgr, alterTabPtr.p->m_define_backup_mutex);
+      Callback c = {
+        safe_cast(&Dbdict::alterTable_backup_mutex_locked),
+        op_ptr.p->op_key
+      };
+      bool ok = mutex.lock(c);
+      ndbrequire(ok);
+      return;
+    }
+
+    Uint32 itFlags = SchemaTransImplReq::IT_REPEAT;
+    schemaTrans_sendConf(signal, trans_ptr, itFlags);
     return;
   }
 
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
-  TableRecordPtr newTablePtr = alterTabPtr.p->m_newTablePtr;
-
-  Uint32 changeMask = impl_req->changeMask;
+  if (itRepeat == 1) {
+    TableRecordPtr tablePtr;
+    c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
+    TableRecordPtr newTablePtr = alterTabPtr.p->m_newTablePtr;
+
+    Uint32 changeMask = impl_req->changeMask;
+
+    if (AlterTableReq::getNameFlag(changeMask)) {
+      jam();
+      D("alter name:"
+        << " old=" <<
tostr<MAX_TAB_NAME_SIZE>(tablePtr.p->tableName)
+        << " new=" <<
tostr<MAX_TAB_NAME_SIZE>(newTablePtr.p->tableName));
+
+      Ptr<DictObject> obj_ptr;
+      c_obj_pool.getPtr(obj_ptr, tablePtr.p->m_obj_ptr_i);
+
+      // remove old name from hash
+      c_obj_hash.remove(obj_ptr);
+
+      // save old name and replace it by new
+      const Uint32 sz = MAX_TAB_NAME_SIZE;
+      bool ok =
+        copyRope<sz>(alterTabPtr.p->m_oldTableName, tablePtr.p->tableName)
&&
+        copyRope<sz>(tablePtr.p->tableName, newTablePtr.p->tableName);
+      ndbrequire(ok);
 
-  if (AlterTableReq::getNameFlag(changeMask)) {
-    jam();
-    D("alter name:"
-      << " old=" << tostr<MAX_TAB_NAME_SIZE>(tablePtr.p->tableName)
-      << " new=" <<
tostr<MAX_TAB_NAME_SIZE>(newTablePtr.p->tableName));
+      // add new name to object hash
+      obj_ptr.p->m_name = tablePtr.p->tableName;
+      c_obj_hash.add(obj_ptr);
+    }
 
-    Ptr<DictObject> obj_ptr;
-    c_obj_pool.getPtr(obj_ptr, tablePtr.p->m_obj_ptr_i);
+    if (AlterTableReq::getFrmFlag(changeMask)) {
+      jam();
+      // save old frm and replace it by new
+      const Uint32 sz = MAX_FRM_DATA_SIZE;
+      bool ok =
+        copyRope<sz>(alterTabPtr.p->m_oldFrmData, tablePtr.p->frmData)
&&
+        copyRope<sz>(tablePtr.p->frmData, newTablePtr.p->frmData);
+      ndbrequire(ok);
+    }
 
-    // remove old name from hash
-    c_obj_hash.remove(obj_ptr);
+    /*
+      TODO RONM: Lite ny kod för FragmentData och RangeOrListData
+    */
 
-    // save old name and replace it by new
-    const Uint32 sz = MAX_TAB_NAME_SIZE;
-    bool ok =
-      copyRope<sz>(alterTabPtr.p->m_oldTableName, tablePtr.p->tableName)
&&
-      copyRope<sz>(tablePtr.p->tableName, newTablePtr.p->tableName);
-    ndbrequire(ok);
+    // set new schema version
+    tablePtr.p->tableVersion = newTablePtr.p->tableVersion;
 
-    // add new name to object hash
-    obj_ptr.p->m_name = tablePtr.p->tableName;
-    c_obj_hash.add(obj_ptr);
+    // repeat to do local blocks
+    Uint32 itFlags = SchemaTransImplReq::IT_REPEAT;
+    schemaTrans_sendConf(signal, trans_ptr, itFlags);
+    return;
   }
 
-  if (AlterTableReq::getFrmFlag(changeMask)) {
+  ndbrequire(itRepeat >= 2);
+  {
     jam();
-    // save old frm and replace it by new
-    const Uint32 sz = MAX_FRM_DATA_SIZE;
-    bool ok =
-      copyRope<sz>(alterTabPtr.p->m_oldFrmData, tablePtr.p->frmData)
&&
-      copyRope<sz>(tablePtr.p->frmData, newTablePtr.p->frmData);
-    ndbrequire(ok);
+    ndbrequire(2 + alterTabPtr.p->m_blockIndex == itRepeat);
+    alterTable_toLocal(signal, op_ptr);
+    return;
   }
+}
 
-/*
-  TODO RONM: Lite ny kod för FragmentData och RangeOrListData
-*/
+void
+Dbdict::alterTable_backup_mutex_locked(Signal* signal, Uint32 op_key, Uint32 ret)
+{
+  jamEntry();
+  D("alterTable_backup_mutex_locked");
+  
+  ndbrequire(ret == 0);
+  
+  SchemaOpPtr op_ptr;
+  AlterTableDataPtr alterTabPtr;
+  findSchemaOp(op_ptr, alterTabPtr, op_key);
+  ndbrequire(!op_ptr.isNull());
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
 
-  // set new schema version
-  tablePtr.p->tableVersion = newTablePtr.p->tableVersion;
+  TableRecordPtr tablePtr;
+  c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
 
-  // repeat to do local blocks
-  Uint32 itFlags = SchemaTransImplReq::IT_REPEAT;
-  schemaTrans_sendConf(signal, trans_ptr, itFlags);
+  Mutex mutex(signal, c_mutexMgr, alterTabPtr.p->m_define_backup_mutex);
+  mutex.unlock(); // ignore response
+  
+  if (tablePtr.p->tabState == TableRecord::BACKUP_ONGOING) {
+    jam();
+    setError(trans_ptr.p->m_error, AlterTableRef::BackupInProgress, __LINE__);
+    schemaTrans_sendRef(signal, trans_ptr);
+  } else {
+    jam();
+    //tablePtr.p->tabState = TableRecord::PREPARE_DROPPING;//wl3600_todo
+    Uint32 itFlags = SchemaTransImplReq::IT_REPEAT;
+    schemaTrans_sendConf(signal, trans_ptr, itFlags);
+  }
 }
 
 void
@@ -7127,6 +7014,8 @@
   }
 }
 
+// AlterTable COMMIT
+
 void
 Dbdict::alterTable_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
@@ -7146,14 +7035,15 @@
   TableRecordPtr tablePtr;
   c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
 
-  // Write schema for altered table to disk
+  // write schema entry for altered table to disk
+
   const OpSection& tabInfoSec =
     getOpSection(op_ptr, CreateTabReq::DICT_TAB_INFO);
   const Uint32 size = getSize(tabInfoSec);
   bool savetodisk = !(tablePtr.p->m_bits & TableRecord::TR_Temporary);
   const Uint32 tableVersion = alterTabPtr.p->m_newTablePtr.p->tableVersion;
 
-  // Update table record
+  // update table record
   tablePtr.p->packedSize = size;
   tablePtr.p->tableVersion = tableVersion;
   tablePtr.p->gciTableCreated = impl_req->gci; //wl3600_todo
@@ -7170,16 +7060,125 @@
   tabEntry.m_transKey = 0;
   tabEntry.zero_unused();
   
-  Callback callback;
-  callback.m_callbackData = op_ptr.p->op_key;
-  callback.m_callbackFunction = 
-    safe_cast(&Dbdict::alterTab_writeSchemaConf);
+  Callback callback = {
+    safe_cast(&Dbdict::alterTab_writeSchemaConf),
+    op_ptr.p->op_key
+  };
   
   updateSchemaState(signal, tablePtr.p->tableId, &tabEntry, &callback,
                     savetodisk);
 }
 
 void
+Dbdict::alterTab_writeSchemaConf(Signal* signal, Uint32 op_key, Uint32 ret)
+{
+  SchemaOpPtr op_ptr;
+  AlterTableDataPtr alterTabPtr;
+  findSchemaOp(op_ptr, alterTabPtr, op_key);
+  ndbrequire(!op_ptr.isNull());
+  const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
+
+  TableRecordPtr tablePtr;
+  c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
+  bool savetodisk = !(tablePtr.p->m_bits & TableRecord::TR_Temporary);
+
+  const OpSection& tabInfoSec =
+    getOpSection(op_ptr, CreateTabReq::DICT_TAB_INFO);
+
+  Callback callback = {
+    safe_cast(&Dbdict::alterTab_writeTableConf),
+    callback.m_callbackData = op_ptr.p->op_key
+  };
+
+  if (savetodisk) {
+    writeTableFile(signal, impl_req->tableId, tabInfoSec, &callback);
+  } else {
+    execute(signal, callback, 0);
+  }
+}
+
+void
+Dbdict::alterTab_writeTableConf(Signal* signal, Uint32 op_key, Uint32 ret)
+{
+  jam();
+  SchemaOpPtr op_ptr;
+  AlterTableDataPtr alterTabPtr;
+  findSchemaOp(op_ptr, alterTabPtr, op_key);
+  ndbrequire(!op_ptr.isNull());
+  const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+
+  TableRecordPtr tabPtr;
+  c_tableRecordPool.getPtr(tabPtr, impl_req->tableId);
+
+  // inform Suma so it can send events to any subscribers of the table
+  {
+    AlterTabReq* req = (AlterTabReq*)signal->getDataPtrSend();
+
+    // special use of senderRef
+    if (trans_ptr.p->m_isMaster)
+      req->senderRef = trans_ptr.p->m_clientRef;
+    else
+      req->senderRef = 0;
+    req->senderData = op_key;
+    req->tableId = tabPtr.p->tableId;
+    req->tableVersion = tabPtr.p->tableVersion;
+    req->gci = tabPtr.p->gciTableCreated;
+    req->requestInfo = 0;
+    DictSignal::setRequestType(req->requestInfo, AlterTabReq::AlterTableCommit);
+    req->changeMask = impl_req->changeMask;
+
+    // wl3600_todo move OpSections to Data record ?
+    const OpSection& tabInfoSec =
+      getOpSection(op_ptr, AlterTabReq::DICT_TAB_INFO);
+    SegmentedSectionPtr tabInfoPtr;
+    bool ok = copyOut(tabInfoSec, tabInfoPtr);
+    ndbrequire(ok);
+
+    signal->setSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
+    EXECUTE_DIRECT(SUMA, GSN_ALTER_TAB_REQ, signal,
+                   AlterTabReq::SignalLength);
+    releaseSections(signal);
+  }
+
+  // older set to notify  wl3600_todo disable to find SUMA problems
+  {
+    ApiBroadcastRep* api= (ApiBroadcastRep*)signal->getDataPtrSend();
+    api->gsn = GSN_ALTER_TABLE_REP;
+    api->minVersion = MAKE_VERSION(4,1,15);
+
+    AlterTableRep* rep = (AlterTableRep*)api->theData;
+    rep->tableId = tabPtr.p->tableId;
+    rep->tableVersion = alter_obj_dec_schema_version(tabPtr.p->tableVersion);
+    rep->changeType = AlterTableRep::CT_ALTERED;
+
+    char oldTableName[MAX_TAB_NAME_SIZE];
+    memset(oldTableName, 0, sizeof(oldTableName));
+    {
+      const RopeHandle& rh =
+        AlterTableReq::getNameFlag(impl_req->changeMask)
+          ? alterTabPtr.p->m_oldTableName
+          : tabPtr.p->tableName;
+      ConstRope r(c_rope_pool, rh);
+      r.copy(oldTableName);
+    }
+
+    LinearSectionPtr ptr[3];
+    ptr[0].p = (Uint32*)oldTableName;
+    ptr[0].sz = (sizeof(oldTableName) + 3) >> 2;
+    
+    sendSignal(QMGR_REF, GSN_API_BROADCAST_REP, signal, 
+	       ApiBroadcastRep::SignalLength + AlterTableRep::SignalLength,
+	       JBB, ptr, 1);
+  }
+
+  releaseTableObject(alterTabPtr.p->m_newTablePtr.i, false);
+  schemaTrans_sendConf(signal, op_ptr.p->m_trans_ptr);
+}
+
+// AlterTable ABORT
+
+void
 Dbdict::alterTable_abortParse(Signal* signal, SchemaOpPtr op_ptr)
 {
   D("alterTable_abortParse" << *op_ptr.p);
@@ -7232,629 +7231,6 @@
   execute(signal, op_ptr.p->m_callback, ref->errorCode);
 }
 
-void
-Dbdict::alterTable_backup_mutex_locked(Signal* signal,
-				       Uint32 callbackData,
-				       Uint32 retValue)
-{
-  ndbrequire(false);
-#if wl3600_todo
-  jamEntry();
-  
-  ndbrequire(retValue == 0);
-  
-  AlterTableDataPtr alterTabPtr;
-  ndbrequire(c_opAlterTable.find(alterTabPtr, callbackData));
-
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, alterTabPtr.p->m_alterTableId, true);
-
-  Mutex mutex(signal, c_mutexMgr, alterTabPtr.p->m_startLcpMutex);
-  mutex.unlock(); // ignore response
-
-  SegmentedSectionPtr tabInfoPtr;
-  getSection(tabInfoPtr, alterTabPtr.p->m_tabInfoPtrI);
-  signal->setSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
-  
-  alterTabPtr.p->m_tabInfoPtrI = RNIL;
-  
-  if(tablePtr.p->tabState == TableRecord::BACKUP_ONGOING)
-  {
-    jam();
-    AlterTableReq* req = (AlterTableReq*)signal->getDataPtr();
-    req->senderData = alterTabPtr.p->m_senderData;
-    req->senderRef = alterTabPtr.p->m_senderRef;
-    alterTableRef(signal, req, AlterTableRef::BackupInProgress);
-
-    c_tableRecordPool.getPtr(tablePtr, alterTabPtr.p->m_tablePtrI);  
-    releaseTableObject(tablePtr.i, false);
-
-    c_opAlterTable.release(alterTabPtr);
-    c_blockState = BS_IDLE;
-    return;
-  }
-  
-  NodeReceiverGroup rg(DBDICT, c_aliveNodes);
-  alterTabPtr.p->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ;
-  SafeCounter safeCounter(c_counterMgr, 
-			  alterTabPtr.p->m_coordinatorData.m_counter);
-  safeCounter.init<AlterTabRef>(rg, alterTabPtr.p->key);
-
-  AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend();
-  lreq->senderRef = reference();
-  lreq->senderData = alterTabPtr.p->key;
-  lreq->clientRef = alterTabPtr.p->m_senderRef;
-  lreq->clientData = alterTabPtr.p->m_senderData;
-  lreq->changeMask = alterTabPtr.p->m_changeMask;
-  lreq->tableId = tablePtr.p->tableId;
-  lreq->tableVersion = alter_obj_inc_schema_version(tablePtr.p->tableVersion);
-  lreq->gci = tablePtr.p->gciTableCreated;
-  lreq->requestType = AlterTabReq::AlterTablePrepare;
-  
-  sendFragmentedSignal(rg, GSN_ALTER_TAB_REQ, signal, 
-		       AlterTabReq::SignalLength, JBB);
-#endif
-}
-
-void Dbdict::alterTableRef(Signal * signal, 
-			   AlterTableReq * req, 
-			   AlterTableRef::ErrorCode errCode,
-			   ParseDictTabInfoRecord* parseRecord)
-{
-  ndbrequire(false);
-#if wl3600_todo
-  jam();
-  releaseSections(signal);
-  AlterTableRef * ref = (AlterTableRef*)signal->getDataPtrSend();
-  Uint32 senderRef = req->senderRef;
-  ref->senderData = req->senderData;
-  ref->senderRef = reference();
-  ref->masterNodeId = c_masterNodeId;
-  if (parseRecord) {
-    ref->errorCode = parseRecord->errorCode;
-    ref->errorLine = parseRecord->errorLine;
-    ref->errorKey = parseRecord->errorKey;
-    ref->status = parseRecord->status;
-  }
-  else {
-    ref->errorCode = errCode;
-    ref->errorLine = 0;
-    ref->errorKey = 0;
-    ref->status = 0;
-  }
-  sendSignal(senderRef, GSN_ALTER_TABLE_REF, signal, 
-	     AlterTableRef::SignalLength, JBB);
-#endif
-}
-
-void
-Dbdict::execALTER_TAB_REQ(Signal * signal) 
-{
-  ndbrequire(false);
-#if wl3600_todo
-  // Received in all nodes to handle change locally
-  jamEntry();
-
-  if(!assembleFragments(signal)){
-    return;
-  }
-  AlterTabReq* const req = (AlterTabReq*)signal->getDataPtr();
-  const Uint32 senderRef = req->senderRef;
-  const Uint32 senderData = req->senderData;
-  const Uint32 changeMask = req->changeMask;
-  const Uint32 tableId = req->tableId;
-  const Uint32 tableVersion = req->tableVersion;
-  const Uint32 gci = req->gci;
-  AlterTabReq::RequestType requestType = 
-    (AlterTabReq::RequestType) req->requestType;
-
-  SegmentedSectionPtr tabInfoPtr;
-  signal->getSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
-
-  AlterTableDataPtr alterTabPtr; // Reuse create table records
-
-  if (senderRef != reference()) {
-    jam();
-    c_blockState = BS_BUSY;
-  }
-  if ((requestType == AlterTabReq::AlterTablePrepare)
-      && (senderRef != reference())) {
-    jam();
-    c_opAlterTable.seize(alterTabPtr);
-    if(!alterTabPtr.isNull())
-      alterTabPtr.p->m_changeMask = changeMask;
-  }
-  else {
-    jam();
-    ndbrequire(c_opAlterTable.find(alterTabPtr, senderData));
-  }
-  if(alterTabPtr.isNull()){
-    jam();
-    alterTabRef(signal, req, AlterTableRef::Busy);
-    return;
-  }
-
-  if (!check_ndb_versions())
-  {
-    jam();
-    alterTabRef(signal, req, AlterTableRef::IncompatibleVersions);
-    return;
-  }
-
-  alterTabPtr.p->m_alterTableId = tableId;
-  alterTabPtr.p->m_coordinatorRef = senderRef;
-  
-  // Get table definition
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, tableId, false);
-  if(tablePtr.isNull()){
-    jam();
-    alterTabRef(signal, req, AlterTableRef::NoSuchTable);
-    return;
-  }
-    
-  switch(requestType) {
-  case(AlterTabReq::AlterTablePrepare): {
-    ParseDictTabInfoRecord* aParseRecord;
-  
-    const TableRecord::TabState tabState = tablePtr.p->tabState;
-    bool ok = false;
-    switch(tabState){
-    case TableRecord::NOT_DEFINED:
-    case TableRecord::REORG_TABLE_PREPARED:
-    case TableRecord::DEFINING:
-    case TableRecord::CHECKED:
-      jam();
-      alterTabRef(signal, req, AlterTableRef::NoSuchTable);
-      return;
-    case TableRecord::DEFINED:
-      ok = true;
-      jam();
-      break;
-    case TableRecord::PREPARE_DROPPING:
-    case TableRecord::DROPPING:
-      jam();
-      alterTabRef(signal, req, AlterTableRef::DropInProgress);
-      return;
-    case TableRecord::BACKUP_ONGOING:
-      jam();
-      alterTabRef(signal, req, AlterTableRef::BackupInProgress);
-      return;
-    }
-    ndbrequire(ok);
-
-    if(alter_obj_inc_schema_version(tablePtr.p->tableVersion) != tableVersion){
-      jam();
-      alterTabRef(signal, req, AlterTableRef::InvalidTableVersion);
-      return;
-    }
-    TableRecordPtr newTablePtr;
-    if (senderRef  != reference()) {
-      jam();
-      // Parse altered table defintion
-      ParseDictTabInfoRecord parseRecord;
-      aParseRecord = &parseRecord;
-      
-      parseRecord.requestType = DictTabInfo::AlterTableFromAPI;
-      parseRecord.errorCode = 0;
-      
-      SimplePropertiesSectionReader r(tabInfoPtr, getSectionSegmentPool());
-      
-      handleTabInfoInit(r, &parseRecord, false); // Will not save info
-      
-      if(parseRecord.errorCode != 0){
-	jam();
-	c_opAlterTable.release(alterTabPtr);
-	alterTabRef(signal, req, 
-		    (AlterTableRef::ErrorCode) parseRecord.errorCode, 
-		    aParseRecord);
-	return;
-      }
-      alterTabPtr.p->key = senderData;
-      c_opAlterTable.add(alterTabPtr);
-      alterTabPtr.p->m_errorCode = 0;
-      alterTabPtr.p->m_senderRef = senderRef;
-      alterTabPtr.p->m_senderData = senderData;
-      alterTabPtr.p->m_tablePtrI = parseRecord.tablePtr.i;
-      alterTabPtr.p->m_fragmentsPtrI = RNIL;
-      alterTabPtr.p->m_dihAddFragPtr = RNIL;
-      newTablePtr = parseRecord.tablePtr;
-      newTablePtr.p->tableVersion = tableVersion;
-    }
-    else { // (req->senderRef  == reference())
-      jam();
-      c_tableRecordPool.getPtr(newTablePtr, alterTabPtr.p->m_tablePtrI);
-      newTablePtr.p->tableVersion = tableVersion;
-    }
-    if (handleAlterTab(req, alterTabPtr.p, tablePtr, newTablePtr) == -1) {
-      jam();
-      c_opAlterTable.release(alterTabPtr);
-      alterTabRef(signal, req, AlterTableRef::UnsupportedChange);
-      return;
-    }
-    releaseSections(signal);
-    // Propagate alter table to other local blocks
-    AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend();
-    req->senderRef = reference();
-    req->senderData = senderData;
-    req->changeMask = changeMask;
-    req->tableId = tableId;
-    req->tableVersion = tableVersion;
-    req->gci = gci;
-    req->requestType = requestType;
-    sendSignal(DBLQH_REF, GSN_ALTER_TAB_REQ, signal, 
-	       AlterTabReq::SignalLength, JBB);	
-    return;
-  }
-  case(AlterTabReq::AlterTableCommit): {
-    jam();
-    // Write schema for altered table to disk
-    SegmentedSectionPtr tabInfoPtr;
-    signal->getSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
-    alterTabPtr.p->m_tabInfoPtrI = tabInfoPtr.i;
-    bool savetodisk = !(tablePtr.p->m_bits & TableRecord::TR_Temporary);
-    
-    signal->header.m_noOfSections = 0;
-
-    // Update table record
-    tablePtr.p->packedSize = tabInfoPtr.sz;
-    tablePtr.p->tableVersion = tableVersion;
-    tablePtr.p->gciTableCreated = gci;
-
-    SchemaFile::TableEntry tabEntry;
-    tabEntry.m_tableVersion = tableVersion;
-    tabEntry.m_tableType    = tablePtr.p->tableType;
-    if (savetodisk)
-      tabEntry.m_tableState   = SchemaFile::ALTER_TABLE_COMMITTED;
-    else
-      tabEntry.m_tableState   = SchemaFile::TEMPORARY_TABLE_COMMITTED;
-    tabEntry.m_gcp          = gci;
-    tabEntry.m_info_words   = tabInfoPtr.sz;
-    tabEntry.m_transKey = 0;
-    tabEntry.zero_unused();
-    
-    Callback callback;
-    callback.m_callbackData = senderData;
-    callback.m_callbackFunction = 
-      safe_cast(&Dbdict::alterTab_writeSchemaConf);
-    
-    updateSchemaState(signal, tableId, &tabEntry, &callback, savetodisk);
-    break;
-  }
-  case(AlterTabReq::AlterTableRevert): {
-    jam();
-    // Revert failed alter table
-    revertAlterTable(signal, changeMask, tableId, alterTabPtr.p);
-    // Acknowledge the reverted alter table
-    AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend();
-    conf->senderRef = reference();
-    conf->senderData = senderData;
-    conf->changeMask = changeMask;
-    conf->tableId = tableId;
-    conf->tableVersion = tableVersion;
-    conf->gci = gci;
-    conf->requestType = requestType;
-    sendSignal(senderRef, GSN_ALTER_TAB_CONF, signal, 
-	       AlterTabConf::SignalLength, JBB);
-    break;
-  }
-  default: ndbrequire(false);
-  }
-#endif
-}
-
-void Dbdict::alterTabRef(Signal * signal, 
-			 AlterTabReq * req, 
-			 AlterTableRef::ErrorCode errCode,
-			 ParseDictTabInfoRecord* parseRecord)
-{
-  jam();
-  releaseSections(signal);
-  AlterTabRef * ref = (AlterTabRef*)signal->getDataPtrSend();
-  Uint32 senderRef = req->senderRef;
-  ref->senderData = req->senderData;
-  ref->senderRef = reference();
-  if (parseRecord) {
-    jam();
-    ref->errorCode = parseRecord->errorCode;
-    ref->errorLine = parseRecord->errorLine;
-    ref->errorKey = parseRecord->errorKey;
-    ref->errorStatus = parseRecord->status;
-  }
-  else {
-    jam();
-    ref->errorCode = errCode;
-    ref->errorLine = 0;
-    ref->errorKey = 0;
-    ref->errorStatus = 0;
-  }
-  sendSignal(senderRef, GSN_ALTER_TAB_REF, signal, 
-	     AlterTabRef::SignalLength, JBB);
-  
-  c_blockState = BS_IDLE;
-}
-
-#if wl3600_todo
-void Dbdict::execALTER_TAB_REF(Signal * signal)
-{
-  ndbrequire(false);
-  jamEntry();
-
-  AlterTabRef * ref = (AlterTabRef*)signal->getDataPtr();
-
-  Uint32 senderRef = ref->senderRef;
-  Uint32 senderData = ref->senderData;
-  Uint32 errorCode = ref->errorCode;
-  Uint32 errorLine = ref->errorLine;
-  Uint32 errorKey = ref->errorKey;
-  Uint32 errorStatus = ref->errorStatus;
-  AlterTabReq::RequestType requestType = 
-    (AlterTabReq::RequestType) ref->requestType;
-  AlterTableDataPtr alterTabPtr;  
-  ndbrequire(c_opAlterTable.find(alterTabPtr, senderData));
-  Uint32 changeMask = alterTabPtr.p->m_changeMask;
-  SafeCounter safeCounter(c_counterMgr, alterTabPtr.p->m_coordinatorData.m_counter);
-  safeCounter.clearWaitingFor(refToNode(senderRef));
-  switch (requestType) {
-  case(AlterTabReq::AlterTablePrepare): {
-    if (safeCounter.done()) {
-      jam();
-      // Send revert request to all alive nodes
-      TableRecordPtr tablePtr;
-      c_tableRecordPool.getPtr(tablePtr, alterTabPtr.p->m_alterTableId);
-      Uint32 tableId = tablePtr.p->tableId;
-      Uint32 tableVersion = tablePtr.p->tableVersion;
-      Uint32 gci = tablePtr.p->gciTableCreated;
-      SimplePropertiesSectionWriter w(getSectionSegmentPool());
-      packTableIntoPages(w, tablePtr);
-      SegmentedSectionPtr spDataPtr;
-      w.getPtr(spDataPtr);
-      signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO);
-      
-      NodeReceiverGroup rg(DBDICT, c_aliveNodes);
-      alterTabPtr.p->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ;
-      safeCounter.init<AlterTabRef>(rg, alterTabPtr.p->key);
-  
-      AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend();
-      lreq->senderRef = reference();
-      lreq->senderData = alterTabPtr.p->key;
-      lreq->clientRef = alterTabPtr.p->m_senderRef;
-      lreq->clientData = alterTabPtr.p->m_senderData;
-      lreq->changeMask = changeMask;
-      lreq->tableId = tableId;
-      lreq->tableVersion = tableVersion;
-      lreq->gci = gci;
-      lreq->requestType = AlterTabReq::AlterTableRevert;
-      
-      sendSignal(rg, GSN_ALTER_TAB_REQ, signal, 
-		 AlterTabReq::SignalLength, JBB);
-    }
-    else {
-      jam();
-      alterTabPtr.p->m_alterTableFailed = true;
-    }
-    break;
-  }
-  case(AlterTabReq::AlterTableCommit):
-    jam();
-  case(AlterTabReq::AlterTableRevert): {
-    AlterTableRef * apiRef = (AlterTableRef*)signal->getDataPtrSend();
-    
-    apiRef->senderData = senderData;
-    apiRef->senderRef = reference();
-    apiRef->masterNodeId = c_masterNodeId;
-    apiRef->errorCode = errorCode;
-    apiRef->errorLine = errorLine;
-    apiRef->errorKey = errorKey;
-    apiRef->status = errorStatus;
-    if (safeCounter.done()) {
-      jam();
-      sendSignal(senderRef, GSN_ALTER_TABLE_REF, signal, 
-		 AlterTableRef::SignalLength, JBB);
-      c_blockState = BS_IDLE;
-    }
-    else {
-      jam();
-      alterTabPtr.p->m_alterTableFailed = true;
-      alterTabPtr.p->m_alterTableRef = *apiRef;
-    }
-    break;
-  } 
-  default: ndbrequire(false);
-  }
-}
-#endif
-
-#if wl3600_todo
-void
-Dbdict::execALTER_TAB_CONF(Signal * signal)
-{
-  ndbrequire(false);
-  jamEntry();
-  AlterTabConf * const conf = (AlterTabConf*)signal->getDataPtr();
-  Uint32 senderRef = conf->senderRef;
-  Uint32 senderData = conf->senderData;
-  Uint32 changeMask = conf->changeMask;
-  Uint32 tableId = conf->tableId;
-  Uint32 tableVersion = conf->tableVersion;
-  Uint32 gci = conf->gci;
-  AlterTabReq::RequestType requestType = 
-    (AlterTabReq::RequestType) conf->requestType;
-  AlterTableDataPtr alterTabPtr;  
-  ndbrequire(c_opAlterTable.find(alterTabPtr, senderData));
-
-  switch (requestType) {
-  case(AlterTabReq::AlterTablePrepare): {
-    switch(refToBlock(signal->getSendersBlockRef())) {
-    case DBLQH: {
-      jam();
-      AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend();
-      req->senderRef = reference();
-      req->senderData = senderData;
-      req->changeMask = changeMask;
-      req->tableId = tableId;
-      req->tableVersion = tableVersion;
-      req->gci = gci;
-      req->requestType = requestType;
-      sendSignal(DBDIH_REF, GSN_ALTER_TAB_REQ, signal, 
-		 AlterTabReq::SignalLength, JBB);	
-      return;
-    }
-    case DBDIH: {
-      jam();
-      AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend();
-      req->senderRef = reference();
-      req->senderData = senderData;
-      req->changeMask = changeMask;
-      req->tableId = tableId;
-      req->tableVersion = tableVersion;
-      req->gci = gci;
-      req->requestType = requestType;
-      sendSignal(DBTC_REF, GSN_ALTER_TAB_REQ, signal, 
-		 AlterTabReq::SignalLength, JBB);	
-      return;
-    }
-    case DBTC: {
-      jam();
-      // Participant is done with prepare phase, send conf to coordinator
-      AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend();
-      conf->senderRef = reference();
-      conf->senderData = senderData;
-      conf->changeMask = changeMask;
-      conf->tableId = tableId;
-      conf->tableVersion = tableVersion;
-      conf->gci = gci;
-      conf->requestType = requestType;
-      sendSignal(alterTabPtr.p->m_coordinatorRef, GSN_ALTER_TAB_CONF, signal, 
-		 AlterTabConf::SignalLength, JBB);
-      return;
-    }
-    default :break;
-    }
-    // Coordinator only
-    SafeCounter safeCounter(c_counterMgr, alterTabPtr.p->m_coordinatorData.m_counter);
-    safeCounter.clearWaitingFor(refToNode(senderRef));
-    if (safeCounter.done()) {
-      jam();
-      // We have received all local confirmations
-      if (alterTabPtr.p->m_alterTableFailed) {
-	jam();
-	// Send revert request to all alive nodes
-	TableRecordPtr tablePtr;
-	c_tableRecordPool.getPtr(tablePtr, alterTabPtr.p->m_alterTableId);
-	Uint32 tableId = tablePtr.p->tableId;
-	Uint32 tableVersion = tablePtr.p->tableVersion;
-	Uint32 gci = tablePtr.p->gciTableCreated;
-	SimplePropertiesSectionWriter w(getSectionSegmentPool());
-	packTableIntoPages(w, tablePtr);
-	SegmentedSectionPtr spDataPtr;
-	w.getPtr(spDataPtr);
-	signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO);
-	
-	NodeReceiverGroup rg(DBDICT, c_aliveNodes);
-	alterTabPtr.p->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ;
-	safeCounter.init<AlterTabRef>(rg, alterTabPtr.p->key);
-	
-	AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend();
-	lreq->senderRef = reference();
-	lreq->senderData = alterTabPtr.p->key;
-	lreq->clientRef = alterTabPtr.p->m_senderRef;
-	lreq->clientData = alterTabPtr.p->m_senderData;
-	lreq->changeMask = changeMask;
-	lreq->tableId = tableId;
-	lreq->tableVersion = tableVersion;
-	lreq->gci = gci;
-	lreq->requestType = AlterTabReq::AlterTableRevert;
-	
-	sendSignal(rg, GSN_ALTER_TAB_REQ, signal, 
-		   AlterTabReq::SignalLength, JBB);
-      }
-      else {
-	jam();
-	// Send commit request to all alive nodes
-	TableRecordPtr tablePtr;
-	c_tableRecordPool.getPtr(tablePtr, tableId);
-	SimplePropertiesSectionWriter w(getSectionSegmentPool());
-	packTableIntoPages(w, tablePtr);
-	SegmentedSectionPtr spDataPtr;
-	w.getPtr(spDataPtr);
-	signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO);
-	
-	NodeReceiverGroup rg(DBDICT, c_aliveNodes);
-	alterTabPtr.p->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ;
-	safeCounter.init<AlterTabRef>(rg, alterTabPtr.p->key);
-  	
-	AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend();
-	lreq->senderRef = reference();
-	lreq->senderData = alterTabPtr.p->key;
-	lreq->clientRef = alterTabPtr.p->m_senderRef;
-	lreq->clientData = alterTabPtr.p->m_senderData;
-	lreq->changeMask = changeMask;
-	lreq->tableId = tableId;
-	lreq->tableVersion = tableVersion;
-	lreq->gci = gci;
-	lreq->requestType = AlterTabReq::AlterTableCommit;
-	
-	sendFragmentedSignal(rg, GSN_ALTER_TAB_REQ, signal, 
-			     AlterTabReq::SignalLength, JBB);
-      }
-    }
-    else {
-      // (!safeCounter.done())
-      jam();
-    }
-    break;
-  }
-  case(AlterTabReq::AlterTableRevert):
-    jam();
-  case(AlterTabReq::AlterTableCommit): {
-    SafeCounter safeCounter(c_counterMgr, alterTabPtr.p->m_coordinatorData.m_counter);
-    safeCounter.clearWaitingFor(refToNode(senderRef));
-    if (safeCounter.done()) {
-      jam();
-      // We have received all local confirmations
-      releaseSections(signal);
-      if (alterTabPtr.p->m_alterTableFailed) {
-	jam();
-	AlterTableRef * apiRef = 
-	  (AlterTableRef*)signal->getDataPtrSend();
-	*apiRef = alterTabPtr.p->m_alterTableRef;
-	sendSignal(alterTabPtr.p->m_senderRef, GSN_ALTER_TABLE_REF, signal, 
-		   AlterTableRef::SignalLength, JBB);	
-      }
-      else {
-	jam();
-	// Alter table completed, inform API
-	AlterTableConf * const apiConf = 
-	  (AlterTableConf*)signal->getDataPtrSend();
-	apiConf->senderRef = reference();
-	apiConf->senderData = alterTabPtr.p->m_senderData;
-	apiConf->tableId = tableId;
-	apiConf->tableVersion = tableVersion;
-	
-	//@todo check api failed
-	sendSignal(alterTabPtr.p->m_senderRef, GSN_ALTER_TABLE_CONF, signal,
-		   AlterTableConf::SignalLength, JBB);
-      }
-      
-      // Release resources
-      TableRecordPtr tabPtr;
-      c_tableRecordPool.getPtr(tabPtr, alterTabPtr.p->m_tablePtrI);  
-      releaseTableObject(tabPtr.i, false);
-      releaseAlterTableOp(signal,alterTabPtr);
-      c_blockState = BS_IDLE;
-    }
-    else {
-      // (!safeCounter.done())
-      jam();
-    }
-    break;
-  }
-  default: ndbrequire(false);
-  }
-}
-#endif
-
 // For debugging
 inline
 void Dbdict::printTables()
@@ -7873,72 +7249,6 @@
   printf("\n");
 }
 
-int Dbdict::handleAlterTab(AlterTabReq * req,
-			   AlterTableData * alterTabPtrP,
-			   TableRecordPtr origTablePtr,
-			   TableRecordPtr newTablePtr)
-{
-  ndbrequire(false);
-#if wl3600_todo // to alterTable_prepare
-  bool supportedAlteration = false;
-  Uint32 changeMask = req->changeMask;
-  
-  if (AlterTableReq::getNameFlag(changeMask)) {
-    jam();
-    // Table rename
-    supportedAlteration = true;
-    // Remove from hashtable
-    Ptr<DictObject> obj_ptr;
-    c_obj_pool.getPtr(obj_ptr, origTablePtr.p->m_obj_ptr_i);
-    c_obj_hash.remove(obj_ptr);
-    {
-      Rope org(c_rope_pool, origTablePtr.p->tableName);
-      org.copy(alterTabPtrP->previousTableName);
-      
-      ConstRope src(c_rope_pool, newTablePtr.p->tableName);
-      char tmp[MAX_TAB_NAME_SIZE];
-      const int len = src.size();
-      src.copy(tmp);
-      ndbrequire(org.assign(tmp, len));
-    }
-    obj_ptr.p->m_name = origTablePtr.p->tableName;
-    // Put it back
-    c_obj_hash.add(obj_ptr);
-  }
-
-  if (AlterTableReq::getFrmFlag(changeMask)) {
-    // Table definition changed (new frm)
-    supportedAlteration = true;
-    // Save old definition
-    Rope org(c_rope_pool, origTablePtr.p->frmData);
-    org.copy(alterTabPtrP->previousFrmData);
-    alterTabPtrP->previousFrmLen = org.size();
-
-    // Set new definition
-    ConstRope src(c_rope_pool, newTablePtr.p->frmData);
-    char tmp[MAX_FRM_DATA_SIZE];
-    src.copy(tmp);
-    ndbrequire(org.assign(tmp, src.size()));
-  }
-
-/*
-  TODO RONM: Lite ny kod för FragmentData och RangeOrListData
-*/
-  if (supportedAlteration)
-  {
-    // Set new schema version
-    origTablePtr.p->tableVersion = newTablePtr.p->tableVersion;
-    return 0;
-  }
-  else
-  {
-    jam();
-    return -1;
-  }
-#endif
-  return -1;
-}
-
 void Dbdict::revertAlterTable(Signal * signal, 
 			      Uint32 changeMask, 
 			      Uint32 tableId,
@@ -7996,214 +7306,6 @@
 }
 
 void
-Dbdict::alterTab_writeSchemaConf(Signal* signal, 
-				 Uint32 callbackData,
-				 Uint32 returnCode)
-{
-  SchemaOpPtr op_ptr;
-  AlterTableDataPtr alterTabPtr;
-  findSchemaOp(op_ptr, alterTabPtr, callbackData);
-  ndbrequire(!op_ptr.isNull());
-  const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
-
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, impl_req->tableId);
-  bool savetodisk = !(tablePtr.p->m_bits & TableRecord::TR_Temporary);
-
-  const OpSection& tabInfoSec =
-    getOpSection(op_ptr, CreateTabReq::DICT_TAB_INFO);
-
-  Callback callback;
-  callback.m_callbackData = op_ptr.p->op_key;
-  callback.m_callbackFunction = 
-    safe_cast(&Dbdict::alterTab_writeTableConf);
-
-  if (savetodisk)
-  {
-    writeTableFile(signal, impl_req->tableId, tabInfoSec, &callback);
-  }
-  else
-  {
-    execute(signal, callback, 0);
-  }
-
-#if wl3600_todo
-  jam();
-  Uint32 key = callbackData;
-  AlterTableDataPtr alterTabPtr;  
-  ndbrequire(c_opAlterTable.find(alterTabPtr, key));
-  Uint32 tableId = alterTabPtr.p->m_alterTableId;
-
-  Callback callback;
-  callback.m_callbackData = alterTabPtr.p->key;
-  callback.m_callbackFunction = 
-    safe_cast(&Dbdict::alterTab_writeTableConf);
-  
-  TableRecordPtr tablePtr;
-  c_tableRecordPool.getPtr(tablePtr, tableId);
-  bool savetodisk = !(tablePtr.p->m_bits & TableRecord::TR_Temporary);
-  if (savetodisk)
-  {
-    SegmentedSectionPtr tabInfoPtr;
-    getSection(tabInfoPtr, alterTabPtr.p->m_tabInfoPtrI);
-    writeTableFile(signal, tableId, tabInfoPtr, &callback);
-  }
-  else
-  {
-    execute(signal, callback, 0);
-  }
-#endif
-}
-
-void
-Dbdict::alterTab_writeTableConf(Signal* signal, 
-				Uint32 callbackData,
-				Uint32 returnCode)
-{
-  jam();
-  SchemaOpPtr op_ptr;
-  AlterTableDataPtr alterTabPtr;
-  findSchemaOp(op_ptr, alterTabPtr, callbackData);
-  ndbrequire(!op_ptr.isNull());
-  const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
-  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
-
-  TableRecordPtr tabPtr;
-  c_tableRecordPool.getPtr(tabPtr, impl_req->tableId);
-
-  // inform Suma so it can send events to any subscribers of the table
-  {
-    AlterTabReq* req = (AlterTabReq*)signal->getDataPtrSend();
-
-    if (trans_ptr.p->m_isMaster)
-      req->senderRef = op_ptr.p->m_clientRef;
-    else
-      req->senderRef = 0;
-    req->senderData = callbackData;
-    req->tableId = tabPtr.p->tableId;
-    req->tableVersion = tabPtr.p->tableVersion;
-    req->gci = tabPtr.p->gciTableCreated;
-    req->requestInfo = 0;
-    DictSignal::setRequestType(req->requestInfo, AlterTabReq::AlterTableCommit);
-    req->changeMask = impl_req->changeMask;
-
-    // wl3600_todo move OpSections to Data record ?
-    const OpSection& tabInfoSec =
-      getOpSection(op_ptr, AlterTabReq::DICT_TAB_INFO);
-    SegmentedSectionPtr tabInfoPtr;
-    bool ok = copyOut(tabInfoSec, tabInfoPtr);
-    ndbrequire(ok);
-
-    signal->setSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
-    EXECUTE_DIRECT(SUMA, GSN_ALTER_TAB_REQ, signal,
-                   AlterTabReq::SignalLength);
-    releaseSections(signal);
-  }
-
-  // inform all APIs
-  {
-    ApiBroadcastRep* api= (ApiBroadcastRep*)signal->getDataPtrSend();
-    api->gsn = GSN_ALTER_TABLE_REP;
-    api->minVersion = MAKE_VERSION(4,1,15);
-
-    AlterTableRep* rep = (AlterTableRep*)api->theData;
-    rep->tableId = tabPtr.p->tableId;
-    rep->tableVersion = alter_obj_dec_schema_version(tabPtr.p->tableVersion);
-    rep->changeType = AlterTableRep::CT_ALTERED;
-
-    char oldTableName[MAX_TAB_NAME_SIZE];
-    memset(oldTableName, 0, sizeof(oldTableName));
-    {
-      const RopeHandle& rh =
-        AlterTableReq::getNameFlag(impl_req->changeMask)
-          ? alterTabPtr.p->m_oldTableName : tabPtr.p->tableName;
-      ConstRope r(c_rope_pool, rh);
-      r.copy(oldTableName);
-    }
-
-    LinearSectionPtr ptr[3];
-    ptr[0].p = (Uint32*)oldTableName;
-    ptr[0].sz = (sizeof(oldTableName) + 3) >> 2;
-    
-    sendSignal(QMGR_REF, GSN_API_BROADCAST_REP, signal, 
-	       ApiBroadcastRep::SignalLength + AlterTableRep::SignalLength,
-	       JBB, ptr, 1);
-  }
-
-  releaseTableObject(alterTabPtr.p->m_newTablePtr.i, false);
-  schemaTrans_sendConf(signal, op_ptr.p->m_trans_ptr);
-
-#if wl3600_todo //remove
-  jam();
-  AlterTableDataPtr alterTabPtr;  
-  ndbrequire(c_opAlterTable.find(alterTabPtr, callbackData));
-  Uint32 coordinatorRef = alterTabPtr.p->m_coordinatorRef;
-  TableRecordPtr tabPtr;
-  c_tableRecordPool.getPtr(tabPtr, alterTabPtr.p->m_alterTableId);
-  // Alter table commit request handled successfully 
-  // Inform Suma so it can send events to any subscribers of the table
-  AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend();
-  if (coordinatorRef == reference())
-    req->senderRef = alterTabPtr.p->m_senderRef;
-  else
-    req->senderRef = 0;
-  req->senderData = callbackData;
-  req->tableId = tabPtr.p->tableId;
-  req->tableVersion = tabPtr.p->tableVersion;
-  req->gci = tabPtr.p->gciTableCreated;
-  req->requestType = AlterTabReq::AlterTableCommit;
-  req->changeMask = alterTabPtr.p->m_changeMask;
-  SegmentedSectionPtr tabInfoPtr;
-  getSection(tabInfoPtr, alterTabPtr.p->m_tabInfoPtrI);
-  signal->setSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO);
-  EXECUTE_DIRECT(SUMA, GSN_ALTER_TAB_REQ, signal,
-                 AlterTabReq::SignalLength);
-  releaseSections(signal);
-  alterTabPtr.p->m_tabInfoPtrI = RNIL;
-  jamEntry();
-  AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend();
-  conf->senderRef = reference();
-  conf->senderData = callbackData;
-  conf->tableId = tabPtr.p->tableId;
-  conf->tableVersion = tabPtr.p->tableVersion;
-  conf->gci = tabPtr.p->gciTableCreated;
-  conf->requestType = AlterTabReq::AlterTableCommit;
-  conf->changeMask = alterTabPtr.p->m_changeMask;
-  sendSignal(coordinatorRef, GSN_ALTER_TAB_CONF, signal, 
-	       AlterTabConf::SignalLength, JBB);
-
-
-  {
-    ApiBroadcastRep* api= (ApiBroadcastRep*)signal->getDataPtrSend();
-    api->gsn = GSN_ALTER_TABLE_REP;
-    api->minVersion = MAKE_VERSION(4,1,15);
-
-    AlterTableRep* rep = (AlterTableRep*)api->theData;
-    rep->tableId = tabPtr.p->tableId;
-    rep->tableVersion = alter_obj_dec_schema_version(tabPtr.p->tableVersion);
-    rep->changeType = AlterTableRep::CT_ALTERED;
-    
-    LinearSectionPtr ptr[3];
-    ptr[0].p = (Uint32*)alterTabPtr.p->previousTableName;
-    ptr[0].sz = (sizeof(alterTabPtr.p->previousTableName) + 3) >> 2;
-    
-    sendSignal(QMGR_REF, GSN_API_BROADCAST_REP, signal, 
-	       ApiBroadcastRep::SignalLength + AlterTableRep::SignalLength,
-	       JBB, ptr,1);
-  }
-
-  if(coordinatorRef != reference()) {
-    jam();
-    // Release resources
-    c_tableRecordPool.getPtr(tabPtr, alterTabPtr.p->m_tablePtrI);  
-    releaseTableObject(tabPtr.i, false);
-    releaseAlterTableOp(signal,alterTabPtr);
-    c_blockState = BS_IDLE;
-  }
-#endif
-}
-
-void
 Dbdict::releaseAlterTableOp(Signal* signal, AlterTableDataPtr alterTabPtr)
 {
   ndbrequire(false);
@@ -8489,14 +7591,11 @@
   Mutex mutex(signal, c_mutexMgr, dropTabPtr.p->m_define_backup_mutex);
   mutex.unlock(); // ignore response
   
-  if (tablePtr.p->tabState == TableRecord::BACKUP_ONGOING)
-  {
+  if (tablePtr.p->tabState == TableRecord::BACKUP_ONGOING) {
     jam();
     setError(trans_ptr.p->m_error, DropTableRef::BackupInProgress, __LINE__);
     schemaTrans_sendRef(signal, trans_ptr);
-  }
-  else
-  {
+  } else {
     jam();
     tablePtr.p->tabState = TableRecord::PREPARE_DROPPING;
     Uint32 itFlags = SchemaTransImplReq::IT_REPEAT;

--- 1.88/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2007-03-26 01:49:03 +02:00
+++ 1.89/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2007-03-26 17:06:51 +02:00
@@ -855,7 +855,6 @@
   void execLQHADDATTCONF(Signal* signal);
   void execCREATE_TAB_REF(Signal* signal);
   void execCREATE_TAB_CONF(Signal* signal);  
-  void execALTER_TAB_REQ(Signal* signal);
   void execALTER_TAB_REF(Signal* signal);
   void execALTER_TAB_CONF(Signal* signal);
   bool check_ndb_versions() const;
@@ -2036,6 +2035,9 @@
   struct AlterTableData : public OpData {
     AlterTabReq m_request;
 
+    // wl3600_todo check mutex name and number later
+    MutexHandle2<BACKUP_DEFINE_MUTEX> m_define_backup_mutex;
+
     // new table def in pool  wl3600_todo store it here instead
     TableRecordPtr m_newTablePtr;
 
@@ -2127,9 +2129,14 @@
   void alterTable_abortPrepare(Signal*, SchemaOpPtr);
 
   // prepare phase
+  void alterTable_backup_mutex_locked(Signal*, Uint32 op_key, Uint32 ret);
   void alterTable_toLocal(Signal*, SchemaOpPtr);
   void alterTable_fromLocal(Signal*, Uint32 op_key, Uint32 ret);
 
+  // commit phase
+  void alterTab_writeSchemaConf(Signal*, Uint32 op_key, Uint32 ret);
+  void alterTab_writeTableConf(Signal*, Uint32 op_key, Uint32 ret);
+
   template <Uint32 sz>
   inline bool
   copyRope(RopeHandle& rh_dst, const RopeHandle& rh_src)
@@ -2164,6 +2171,7 @@
     Uint32 m_errorCode;//
     void setErrorCode(Uint32 c){ if(m_errorCode == 0) m_errorCode = c;}//
 
+    // wl3600_todo check mutex name and number later
     MutexHandle2<BACKUP_DEFINE_MUTEX> m_define_backup_mutex;
 
     struct ParticipantData {
@@ -3212,27 +3220,10 @@
   bool getIsFailed(Uint32 nodeId) const;
 
   void printTables(); // For debugging only
-  int handleAlterTab(AlterTabReq * req,
-		     AlterTableData * regAlterTabPtr,
-		     TableRecordPtr origTablePtr,
-		     TableRecordPtr newTablePtr);
   void revertAlterTable(Signal * signal, 
 			Uint32 changeMask, 
 			Uint32 tableId,
 			AlterTableData * regAlterTabPtr);
-  void alterTable_backup_mutex_locked(Signal* signal, Uint32, Uint32);
-  void alterTableRef(Signal * signal, 
-		     AlterTableReq *, AlterTableRef::ErrorCode, 
-		     ParseDictTabInfoRecord* parseRecord = NULL);
-  void alterTabRef(Signal * signal, 
-		   AlterTabReq *, AlterTableRef::ErrorCode, 
-		   ParseDictTabInfoRecord* parseRecord = NULL);
-  void alterTab_writeSchemaConf(Signal* signal, 
-				Uint32 callbackData,
-				Uint32 returnCode);
-  void alterTab_writeTableConf(Signal* signal, 
-			       Uint32 callbackData,
-			       Uint32 returnCode);
 
   void createTab_prepare(Signal* signal, CreateTabReq * req);
   void createTab_writeSchemaConf1(Signal* signal, Uint32 callback, Uint32);