bk commit into 5.1 tree (jonas:1.1873)

[jonas]

Below is the list of changes that have just been committed into a local
5.1 repository of jonas. When jonas 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
  1.1873 05/08/27 07:42:59 jonas@eel.(none) +14 -0
  Merge joreland@stripped:/home/bk/mysql-5.1
  into  eel.(none):/home/jonas/src/mysql-5.1-push

  storage/ndb/tools/ndb_condig.cpp
    1.8 05/08/27 07:42:51 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/tools/Makefile.am
    1.21 05/08/27 07:42:51 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
    1.90 05/08/27 07:42:51 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/mgmapi/mgmapi.cpp
    1.53 05/08/27 07:42:51 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
    1.86 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
    1.74 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
    1.33 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
    1.17 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
    1.52 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
    1.59 05/08/27 07:42:50 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/include/ndbapi/NdbDictionary.hpp
    1.54 05/08/27 07:42:49 jonas@eel.(none) +0 -0
    Auto merged

  storage/ndb/include/kernel/signaldata/AlterTable.hpp
    1.5 05/08/27 07:42:49 jonas@eel.(none) +0 -0
    Auto merged

  sql/ha_ndbcluster.cc
    1.205 05/08/27 07:42:49 jonas@eel.(none) +0 -0
    Auto merged

  sql/ha_innodb.h
    1.104 05/08/27 07:42:49 jonas@eel.(none) +0 -0
    Auto merged

# 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:	jonas
# Host:	eel.(none)
# Root:	/home/jonas/src/mysql-5.1-push/RESYNC

--- 1.4/storage/ndb/include/kernel/signaldata/AlterTable.hpp	2005-07-22 15:27:07 +02:00
+++ 1.5/storage/ndb/include/kernel/signaldata/AlterTable.hpp	2005-08-27 07:42:49 +02:00
@@ -129,7 +129,8 @@
     InvalidPrimaryKeySize  = 739,
     NullablePrimaryKey = 740,
     UnsupportedChange = 741,
-    BackupInProgress = 762
+    BackupInProgress = 762,
+    IncompatibleVersions = 763
   };
 
 private:
@@ -175,6 +176,28 @@
   Uint32 senderRef;
   Uint32 tableId;
   Uint32 tableVersion;
+};
+
+/**
+ * Inform API about change of table definition
+ */
+struct AlterTableRep 
+{
+  friend bool printALTER_TABLE_REP(FILE*, const Uint32*, Uint32, Uint16);
+  
+  STATIC_CONST( SignalLength = 3 );
+  
+  enum Change_type 
+  {
+    CT_ALTERED = 0x1,
+    CT_DROPPED = 0x2
+  };
+  
+  Uint32 tableId;
+  Uint32 tableVersion;
+  Uint32 changeType;
+  
+  SECTION( TABLE_NAME = 0 );
 };
 
 #endif

--- 1.53/storage/ndb/include/ndbapi/NdbDictionary.hpp	2005-07-22 15:27:07 +02:00
+++ 1.54/storage/ndb/include/ndbapi/NdbDictionary.hpp	2005-08-27 07:42:49 +02:00
@@ -78,9 +78,10 @@
                               ///< changes to take effect
       Retrieved,              ///< The object exist and has been read 
                               ///< into main memory from NDB Kernel
-      Invalid                 ///< The object has been invalidated
+      Invalid,                ///< The object has been invalidated
                               ///< and should not be used
-      
+      Altered                 ///< Table has been altered in NDB kernel
+                              ///< but is still valid for usage
     };
 
     /**

--- 1.58/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2005-08-08 22:21:37 +02:00
+++ 1.59/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2005-08-27 07:42:50 +02:00
@@ -28,7 +28,8 @@
 #include <signaldata/FsRemoveReq.hpp>
 #include <signaldata/DropTab.hpp>
 #include <signaldata/DumpStateOrd.hpp>
-#include <SectionReader.hpp>
+#include <KeyDescriptor.hpp>
+
 
 // TO_DO_RONM is a label for comments on what needs to be improved in future versions
 // when more time is given.
@@ -1037,12 +1038,6 @@
       tabptr.p->fragholder[i] = RNIL;
       tabptr.p->fragptrholder[i] = RNIL;
     }//for
-    tabptr.p->noOfKeyAttr = 0;
-    tabptr.p->hasCharAttr = 0;
-    for (Uint32 k = 0; k < MAX_ATTRIBUTES_IN_INDEX; k++) {
-      tabptr.p->keyAttr[k].attributeDescriptor = 0;
-      tabptr.p->keyAttr[k].charsetInfo = 0;
-    }
   }//for
 }//Dbacc::initialiseTableRec()
 
@@ -1172,8 +1167,8 @@
   Uint32 userPtr = req->userPtr;
   BlockReference retRef = req->userRef;
   rootfragrecptr.p->rootState = ACTIVEROOT;
-  AccFragConf * const conf = (AccFragConf*)&signal->theData[0];
 
+  AccFragConf * const conf = (AccFragConf*)&signal->theData[0];
   conf->userPtr = userPtr;
   conf->rootFragPtr = rootfragrecptr.i;
   conf->fragId[0] = rootfragrecptr.p->fragmentid[0];
@@ -1197,65 +1192,6 @@
   return;
 }//Dbacc::addFragRefuseEarly()
 
-void
-Dbacc::execTC_SCHVERREQ(Signal* signal)
-{
-  jamEntry();
-  if (! assembleFragments(signal)) {
-    jam();
-    return;
-  }
-  tabptr.i = signal->theData[0];
-  ptrCheckGuard(tabptr, ctablesize, tabrec);
-  Uint32 noOfKeyAttr = signal->theData[6];
-  ndbrequire(noOfKeyAttr <= MAX_ATTRIBUTES_IN_INDEX);
-  Uint32 hasCharAttr = 0;
-
-  SegmentedSectionPtr s0Ptr;
-  signal->getSection(s0Ptr, 0);
-  SectionReader r0(s0Ptr, getSectionSegmentPool());
-  Uint32 i = 0;
-  while (i < noOfKeyAttr) {
-    jam();
-    Uint32 attributeDescriptor = ~0;
-    Uint32 csNumber = ~0;
-    if (! r0.getWord(&attributeDescriptor) ||
-        ! r0.getWord(&csNumber)) {
-      jam();
-      break;
-    }
-    CHARSET_INFO* cs = 0;
-    if (csNumber != 0) {
-      cs = all_charsets[csNumber];
-      ndbrequire(cs != 0);
-      hasCharAttr = 1;
-    }
-    tabptr.p->keyAttr[i].attributeDescriptor = attributeDescriptor;
-    tabptr.p->keyAttr[i].charsetInfo = cs;
-    i++;
-  }
-  ndbrequire(i == noOfKeyAttr);
-  releaseSections(signal);
-
-  tabptr.p->noOfKeyAttr = noOfKeyAttr;
-  tabptr.p->hasCharAttr = hasCharAttr;
-
-  // copy char attr flag to each fragment
-  for (Uint32 i1 = 0; i1 < MAX_FRAG_PER_NODE; i1++) {
-    jam();
-    if (tabptr.p->fragptrholder[i1] != RNIL) {
-      rootfragrecptr.i = tabptr.p->fragptrholder[i1];
-      ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec);
-      for (Uint32 i2 = 0; i2 < 2; i2++) {
-        fragrecptr.i = rootfragrecptr.p->fragmentptr[i2];
-        ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec);
-        fragrecptr.p->hasCharAttr = hasCharAttr;
-      }
-    }
-  }
-
-  // no reply to DICT
-}
 
 void
 Dbacc::execDROP_TAB_REQ(Signal* signal){
@@ -1841,55 +1777,14 @@
 void
 Dbacc::xfrmKeyData(Signal* signal)
 {
-  tabptr.i = fragrecptr.p->myTableId;
-  ptrCheckGuard(tabptr, ctablesize, tabrec);
-
-  Uint32 dst[1024 * MAX_XFRM_MULTIPLY];
-  Uint32 dstSize = (sizeof(dst) >> 2);
+  Uint32 table = fragrecptr.p->myTableId;
+  Uint32 dst[MAX_KEY_SIZE_IN_WORDS * MAX_XFRM_MULTIPLY];
+  Uint32 keyPartLen[MAX_ATTRIBUTES_IN_INDEX];
   Uint32* src = &signal->theData[7];
-  const Uint32 noOfKeyAttr = tabptr.p->noOfKeyAttr;
-  Uint32 dstPos = 0;
-  Uint32 srcPos = 0;
-  Uint32 i = 0;
-
-  while (i < noOfKeyAttr) {
-    const Tabrec::KeyAttr& keyAttr = tabptr.p->keyAttr[i];
-
-    Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(keyAttr.attributeDescriptor);
-    Uint32 srcWords = (srcBytes + 3) / 4;
-    Uint32 dstWords = ~0;
-    uchar* dstPtr = (uchar*)&dst[dstPos];
-    const uchar* srcPtr = (const uchar*)&src[srcPos];
-    CHARSET_INFO* cs = keyAttr.charsetInfo;
-
-    if (cs == 0) {
-      jam();
-      memcpy(dstPtr, srcPtr, srcWords << 2);
-      dstWords = srcWords;
-    } else {
-      jam();
-      Uint32 typeId = AttributeDescriptor::getType(keyAttr.attributeDescriptor);
-      Uint32 lb, len;
-      bool ok = NdbSqlUtil::get_var_length(typeId, srcPtr, srcBytes, lb, len);
-      ndbrequire(ok);
-      Uint32 xmul = cs->strxfrm_multiply;
-      if (xmul == 0)
-        xmul = 1;
-      // see comment in DbtcMain.cpp
-      Uint32 dstLen = xmul * (srcBytes - lb);
-      ndbrequire(dstLen <= ((dstSize - dstPos) << 2));
-      int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
-      ndbrequire(n != -1);
-      while ((n & 3) != 0)
-        dstPtr[n++] = 0;
-      dstWords = (n >> 2);
-    }
-    dstPos += dstWords;
-    srcPos += srcWords;
-    i++;
-  }
-  memcpy(src, dst, dstPos << 2);
-  operationRecPtr.p->xfrmtupkeylen = dstPos;
+  Uint32 len = xfrm_key(table, src, dst, sizeof(dst) >> 2, keyPartLen);
+  ndbrequire(len); // 0 means error
+  memcpy(src, dst, len << 2);
+  operationRecPtr.p->xfrmtupkeylen = len;
 }
 
 void Dbacc::accIsLockedLab(Signal* signal) 
@@ -8024,6 +7919,10 @@
   Uint32 Tmp2 = regFragPtr.p->maxloadfactor - regFragPtr.p->minloadfactor;
   Tmp2 = Tmp1 * Tmp2;
   regFragPtr.p->slackCheck = Tmp2;
+
+  Uint32 hasCharAttr = g_key_descriptor_pool.getPtr(req->tableId)->hasCharAttr;
+  regFragPtr.p->hasCharAttr = hasCharAttr;
+
 }//Dbacc::initFragAdd()
 
 void Dbacc::initFragGeneral(FragmentrecPtr regFragPtr)

--- 1.51/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2005-07-25 10:13:09 +02:00
+++ 1.52/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2005-08-27 07:42:50 +02:00
@@ -27,6 +27,7 @@
 #include <SectionReader.hpp>
 #include <SimpleProperties.hpp>
 #include <AttributeHeader.hpp>
+#include <KeyDescriptor.hpp>
 #include <signaldata/DictSchemaInfo.hpp>
 #include <signaldata/DictTabInfo.hpp>
 #include <signaldata/DropTabFile.hpp>
@@ -77,6 +78,7 @@
 #include <signaldata/CreateFragmentation.hpp>
 #include <signaldata/CreateTab.hpp>
 #include <NdbSleep.h>
+#include <signaldata/ApiBroadcast.hpp>
 
 #define ZNOT_FOUND 626
 #define ZALREADYEXIST 630
@@ -91,6 +93,27 @@
 #define DIV(x,y) (((x)+(y)-1)/(y))
 #include <ndb_version.h>
 
+static
+Uint32
+alter_table_inc_schema_version(Uint32 old)
+{
+   return (old & 0x00FFFFFF) + ((old + 0x1000000) & 0xFF000000);
+}
+
+static
+Uint32
+alter_table_dec_schema_version(Uint32 old)
+{
+  return (old & 0x00FFFFFF) + ((old - 0x1000000) & 0xFF000000);
+}
+
+static
+Uint32
+create_table_inc_schema_version(Uint32 old)
+{
+  return (old + 0x00000001) & 0x00FFFFFF;
+}
+
 /* **************************************************************** */
 /* ---------------------------------------------------------------- */
 /* MODULE:          GENERAL MODULE -------------------------------- */
@@ -603,7 +626,7 @@
     jam();
     fsOpenReq->fileFlags = FsOpenReq::OM_READONLY;
   }//if
-  ndbrequire(tablePtr.p->tableVersion < ZNIL);
+
   fsOpenReq->fileNumber[3] = 0; // Initialise before byte changes
   FsOpenReq::setVersion(fsOpenReq->fileNumber, 1);
   FsOpenReq::setSuffix(fsOpenReq->fileNumber, FsOpenReq::S_TABLELIST);
@@ -793,7 +816,7 @@
   case SchemaFile::ADD_STARTED:
     jam();
     ok = true;
-    ndbrequire((oldVersion + 1) == newVersion);
+    ndbrequire(create_table_inc_schema_version(oldVersion) == newVersion);
     ndbrequire(oldState == SchemaFile::INIT ||
 	       oldState == SchemaFile::DROP_TABLE_COMMITTED);
     break;
@@ -806,7 +829,7 @@
   case SchemaFile::ALTER_TABLE_COMMITTED:
     jam();
     ok = true;
-    ndbrequire((oldVersion + 1) == newVersion);
+    ndbrequire(alter_table_inc_schema_version(oldVersion) == newVersion);
     ndbrequire(oldState == SchemaFile::TABLE_ADD_COMMITTED ||
 	       oldState == SchemaFile::ALTER_TABLE_COMMITTED);
     break;
@@ -1730,6 +1753,7 @@
   c_schemaPageRecordArray.setSize(2 * NDB_SF_MAX_PAGES);
   c_tableRecordPool.setSize(tablerecSize);
   c_tableRecordHash.setSize(tablerecSize);
+  g_key_descriptor_pool.setSize(tablerecSize);
   c_triggerRecordPool.setSize(c_maxNoOfTriggers);
   c_triggerRecordHash.setSize(c_maxNoOfTriggers);
   c_opRecordPool.setSize(256);   // XXX need config params
@@ -3014,6 +3038,21 @@
   }
 }
 
+bool
+Dbdict::check_ndb_versions() const
+{
+  Uint32 node = 0;
+  Uint32 version = getNodeInfo(getOwnNodeId()).m_version;
+  while((node = c_aliveNodes.find(node + 1)) != BitmaskImpl::NotFound)
+  {
+    if(getNodeInfo(node).m_version != version)
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
 void
 Dbdict::execALTER_TABLE_REQ(Signal* signal)
 {
@@ -3050,6 +3089,13 @@
     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;
@@ -3200,7 +3246,7 @@
   lreq->clientData = alterTabPtr.p->m_senderData;
   lreq->changeMask = alterTabPtr.p->m_changeMask;
   lreq->tableId = tablePtr.p->tableId;
-  lreq->tableVersion = tablePtr.p->tableVersion + 1;
+  lreq->tableVersion = alter_table_inc_schema_version(tablePtr.p->tableVersion);
   lreq->gci = tablePtr.p->gciTableCreated;
   lreq->requestType = AlterTabReq::AlterTablePrepare;
   
@@ -3280,6 +3326,14 @@
     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;
   
@@ -3322,7 +3376,7 @@
     }
     ndbrequire(ok);
 
-    if(tablePtr.p->tableVersion + 1 != tableVersion){
+    if(alter_table_inc_schema_version(tablePtr.p->tableVersion) != tableVersion){
       jam();
       alterTabRef(signal, req, AlterTableRef::InvalidTableVersion);
       return;
@@ -3807,7 +3861,7 @@
     // Restore name
     strcpy(tablePtr.p->tableName, alterTabPtrP->previousTableName);
     // Revert schema version
-    tablePtr.p->tableVersion = tablePtr.p->tableVersion - 1;
+    tablePtr.p->tableVersion =
alter_table_dec_schema_version(tablePtr.p->tableVersion);
     // Put it back
 #ifdef VM_TRACE
     ndbrequire(!c_tableRecordHash.find(tmp, * tablePtr.p));
@@ -3867,6 +3921,27 @@
   conf->requestType = AlterTabReq::AlterTableCommit;
   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_table_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
@@ -3918,7 +3993,7 @@
   XSchemaFile * xsf = &c_schemaFile[c_schemaRecord.schemaPage != 0];
   SchemaFile::TableEntry * tabEntry = getTableEntry(xsf, tabPtr.i);
 
-  tabPtr.p->tableVersion = tabEntry->m_tableVersion + 1;
+  tabPtr.p->tableVersion =
create_table_inc_schema_version(tabEntry->m_tableVersion);
 
   /**
    * Pack
@@ -3947,7 +4022,7 @@
 
   req->gci = 0;
   req->tableId = tabPtr.i;
-  req->tableVersion = tabEntry->m_tableVersion + 1;
+  req->tableVersion = create_table_inc_schema_version(tabEntry->m_tableVersion);
   
   sendFragmentedSignal(rg, GSN_CREATE_TAB_REQ, signal, 
 		       CreateTabReq::SignalLength, JBB);
@@ -4409,6 +4484,44 @@
     sendSignal(DBLQH_REF, GSN_LQHFRAGREQ, signal, 
 	       LqhFragReq::SignalLength, JBB);
   }
+
+  /**
+   * Create KeyDescriptor
+   */
+  KeyDescriptor* desc= g_key_descriptor_pool.getPtr(tabPtr.i);
+  new (desc) KeyDescriptor();
+
+  Uint32 key = 0;
+  Uint32 tAttr = tabPtr.p->firstAttribute;
+  while (tAttr != RNIL) 
+  {
+    jam();
+    AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr);
+    if (aRec->tupleKey) 
+    {
+      desc->noOfKeyAttr ++;
+      desc->keyAttr[key].attributeDescriptor = aRec->attributeDescriptor;
+      
+      Uint32 csNumber = (aRec->extPrecision >> 16);
+      if(csNumber)
+      {
+	desc->keyAttr[key].charsetInfo = all_charsets[csNumber];
+	ndbrequire(all_charsets[csNumber]);
+	desc->hasCharAttr = 1;
+      }
+      else
+      {
+	desc->keyAttr[key].charsetInfo = 0;	  
+      }
+      if(AttributeDescriptor::getDKey(aRec->attributeDescriptor))
+      {
+	desc->noOfDistrKeys ++;
+      }
+      key++;
+    }
+    tAttr = aRec->nextAttrInTable;
+  }
+  ndbrequire(key == tabPtr.p->noOfPrimkey);
 }
 
 void
@@ -4603,31 +4716,11 @@
     signal->theData[4] = (Uint32)tabPtr.p->tableType;
     signal->theData[5] = createTabPtr.p->key;
     signal->theData[6] = (Uint32)tabPtr.p->noOfPrimkey;
-
-    Uint32 buf[2 * MAX_ATTRIBUTES_IN_INDEX];
-    Uint32 sz = 0;
-    Uint32 tAttr = tabPtr.p->firstAttribute;
-    while (tAttr != RNIL) {
-      jam();
-      AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr);
-      if (aRec->tupleKey) {
-        buf[sz++] = aRec->attributeDescriptor;
-        buf[sz++] = (aRec->extPrecision >> 16); // charset number
-      }
-      tAttr = aRec->nextAttrInTable;
-    }
-    ndbrequire((int)sz == 2 * tabPtr.p->noOfPrimkey);
-
-    LinearSectionPtr lsPtr[3];
-    lsPtr[0].p = buf;
-    lsPtr[0].sz = sz;
-    // note: ACC does not reply
-    if (tabPtr.p->isTable() || tabPtr.p->isHashIndex())
-      sendSignal(DBACC_REF, GSN_TC_SCHVERREQ, signal, 7, JBB, lsPtr, 1);
-    sendSignal(DBTC_REF, GSN_TC_SCHVERREQ, signal, 7, JBB, lsPtr, 1);
+    
+    sendSignal(DBTC_REF, GSN_TC_SCHVERREQ, signal, 7, JBB);
     return;
   }
-
+  
   ndbrequire(false);
 }
 
@@ -12312,3 +12405,5 @@
   new (&attr) MetaData::Attribute(*attrPtr.p);
   return 0;
 }
+
+CArray<KeyDescriptor> g_key_descriptor_pool;

--- 1.16/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2005-07-22 15:27:07 +02:00
+++ 1.17/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2005-08-27 07:42:50 +02:00
@@ -591,6 +591,7 @@
   void execALTER_TAB_REQ(Signal* signal);
   void execALTER_TAB_REF(Signal* signal);
   void execALTER_TAB_CONF(Signal* signal);
+  bool check_ndb_versions() const;
 
   /*
    *  2.4 COMMON STORED VARIABLES

--- 1.32/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2005-07-22 15:27:08 +02:00
+++ 1.33/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2005-08-27 07:42:50 +02:00
@@ -1886,8 +1886,6 @@
     
     // Suma will not send response to this for now, later...
     sendSignal(SUMA_REF, GSN_INCL_NODEREQ, signal, 2, JBB);
-   // Grep will not send response to this for now, later...
-    sendSignal(GREP_REF, GSN_INCL_NODEREQ, signal, 2, JBB);
     return;
   }//if
   if (TstartNode_or_blockref == numberToRef(BACKUP, getOwnNodeId())){

--- 1.73/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2005-07-22 15:27:08 +02:00
+++ 1.74/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2005-08-27 07:42:50 +02:00
@@ -55,6 +55,7 @@
 #include <signaldata/AlterTab.hpp>
 
 #include <signaldata/LCP.hpp>
+#include <KeyDescriptor.hpp>
 
 // Use DEBUG to print messages that should be
 // seen only when we debug the product
@@ -3522,7 +3523,8 @@
     LQHKEY_abort(signal, 4);
     return;
   }
-  if(tabptr.p->schemaVersion != schemaVersion){
+  if(table_version_major(tabptr.p->schemaVersion) != 
+     table_version_major(schemaVersion)){
     LQHKEY_abort(signal, 5);
     return;
   }
@@ -4461,7 +4463,7 @@
   lqhKeyReq->requestInfo = Treqinfo;
   lqhKeyReq->tcBlockref = sig4;
 
-  sig0 = regTcPtr->tableref + (regTcPtr->schemaVersion << 16);
+  sig0 = regTcPtr->tableref + ((regTcPtr->schemaVersion << 16) &
0xFFFF0000);
   sig1 = regTcPtr->fragmentid + (regTcPtr->nodeAfterNext[0] << 16);
   sig2 = regTcPtr->transid[0];
   sig3 = regTcPtr->transid[1];
@@ -9012,44 +9014,17 @@
 /*   FRAGMENT TO A NEW REPLICA OF THE FRAGMENT. IT DOES ALSO SHUT DOWN ALL   */
 /*   CONNECTIONS TO THE FAILED NODE.                                         */
 /*---------------------------------------------------------------------------*/
-void Dblqh::calculateHash(Signal* signal) 
+Uint32 
+Dblqh::calculateHash(Uint32 tableId, const Uint32* src) 
 {
-  DatabufPtr locDatabufptr;
-  UintR  Ti;
-  UintR  Tdata0;
-  UintR  Tdata1;
-  UintR  Tdata2;
-  UintR  Tdata3;
-  UintR*  Tdata32;
-  Uint64 Tdata[512];
-
-  Tdata32 = (UintR*)&Tdata[0];
-
-  Tdata0 = tcConnectptr.p->tupkeyData[0];
-  Tdata1 = tcConnectptr.p->tupkeyData[1];
-  Tdata2 = tcConnectptr.p->tupkeyData[2];
-  Tdata3 = tcConnectptr.p->tupkeyData[3];
-  Tdata32[0] = Tdata0;
-  Tdata32[1] = Tdata1;
-  Tdata32[2] = Tdata2;
-  Tdata32[3] = Tdata3;
-  locDatabufptr.i = tcConnectptr.p->firstTupkeybuf;
-  Ti = 4;
-  while (locDatabufptr.i != RNIL) {
-    ptrCheckGuard(locDatabufptr, cdatabufFileSize, databuf);
-    Tdata0 = locDatabufptr.p->data[0];
-    Tdata1 = locDatabufptr.p->data[1];
-    Tdata2 = locDatabufptr.p->data[2];
-    Tdata3 = locDatabufptr.p->data[3];
-    Tdata32[Ti    ] = Tdata0;
-    Tdata32[Ti + 1] = Tdata1;
-    Tdata32[Ti + 2] = Tdata2;
-    Tdata32[Ti + 3] = Tdata3;
-    locDatabufptr.i = locDatabufptr.p->nextDatabuf;
-    Ti += 4;
-  }//while
-  tcConnectptr.p->hashValue = 
-    md5_hash((Uint64*)&Tdata32[0], (UintR)tcConnectptr.p->primKeyLen);
+  jam();
+  Uint64 Tmp[(MAX_KEY_SIZE_IN_WORDS*MAX_XFRM_MULTIPLY) >> 1];
+  Uint32 keyPartLen[MAX_ATTRIBUTES_IN_INDEX];
+  Uint32 keyLen = xfrm_key(tableId, src, (Uint32*)Tmp, sizeof(Tmp) >> 2, 
+			   keyPartLen);
+  ndbrequire(keyLen);
+  
+  return md5_hash(Tmp, keyLen);
 }//Dblqh::calculateHash()
 
 /* *************************************** */
@@ -9383,7 +9358,7 @@
   const TupKeyConf * const tupKeyConf = (TupKeyConf *)signal->getDataPtr();
 
   UintR readLength = tupKeyConf->readLength;
-
+  Uint32 tableId = tcConnectptr.p->tableref;
   scanptr.i = tcConnectptr.p->tcScanRec;
   c_scanRecordPool.getPtr(scanptr);
   ScanRecord* scanP = scanptr.p;
@@ -9410,7 +9385,14 @@
   Uint32 len= tcConnectptr.p->primKeyLen = readPrimaryKeys(scanP, tcConP, tmp);
   
   // Calculate hash (no need to linearies key)
-  tcConnectptr.p->hashValue = md5_hash((Uint64*)tmp, len);
+  if (g_key_descriptor_pool.getPtr(tableId)->hasCharAttr)
+  {
+    tcConnectptr.p->hashValue = calculateHash(tableId, tmp);
+  }
+  else
+  {
+    tcConnectptr.p->hashValue = md5_hash((Uint64*)tmp, len);
+  }
 
   // Move into databuffer to make packLqhkeyreqLab happy
   memcpy(tcConP->tupkeyData, tmp, 4*4);
@@ -15922,7 +15904,7 @@
   tabptr.i = tcConnectptr.p->tableref;
   ptrCheckGuard(tabptr, ctabrecFileSize, tablerec);
   if (getFragmentrec(signal, tcConnectptr.p->fragmentid) &&
-      (tabptr.p->schemaVersion == tcConnectptr.p->schemaVersion)) {
+      (table_version_major(tabptr.p->schemaVersion) ==
table_version_major(tcConnectptr.p->schemaVersion))) {
     if (fragptr.p->execSrStatus != Fragrecord::IDLE) {
       if (fragptr.p->execSrNoReplicas > logPartPtr.p->execSrExecuteIndex) {
         ndbrequire((fragptr.p->execSrNoReplicas - 1) < 4);

--- 1.85/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2005-07-26 15:05:00 +02:00
+++ 1.86/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2005-08-27 07:42:50 +02:00
@@ -66,6 +66,7 @@
 #include <signaldata/DictTabInfo.hpp>
 #include <AttributeDescriptor.hpp>
 #include <SectionReader.hpp>
+#include <KeyDescriptor.hpp>
 
 #include <NdbOut.hpp>
 #include <DebuggerNames.hpp>
@@ -329,42 +330,16 @@
   BlockReference retPtr = signal->theData[5];
   Uint32 noOfKeyAttr = signal->theData[6];
   ndbrequire(noOfKeyAttr <= MAX_ATTRIBUTES_IN_INDEX);
-  Uint32 hasCharAttr = 0;
-  Uint32 noOfDistrKeys = 0;
-  SegmentedSectionPtr s0Ptr;
-  signal->getSection(s0Ptr, 0);
-  SectionReader r0(s0Ptr, getSectionSegmentPool());
-  Uint32 i = 0;
-  while (i < noOfKeyAttr) {
-    jam();
-    Uint32 attributeDescriptor = ~0;
-    Uint32 csNumber = ~0;
-    if (! r0.getWord(&attributeDescriptor) ||
-        ! r0.getWord(&csNumber)) {
-      jam();
-      break;
-    }
-    CHARSET_INFO* cs = 0;
-    if (csNumber != 0) {
-      cs = all_charsets[csNumber];
-      ndbrequire(cs != 0);
-      hasCharAttr = 1;
-    }
-    
-    noOfDistrKeys += AttributeDescriptor::getDKey(attributeDescriptor);
-    tabptr.p->keyAttr[i].attributeDescriptor = attributeDescriptor;
-    tabptr.p->keyAttr[i].charsetInfo = cs;
-    i++;
-  }
-  ndbrequire(i == noOfKeyAttr);
-  releaseSections(signal);
+
+  const KeyDescriptor* desc = g_key_descriptor_pool.getPtr(tabptr.i);
+  ndbrequire(noOfKeyAttr == desc->noOfKeyAttr);
 
   ndbrequire(tabptr.p->enabled == false);
   tabptr.p->enabled = true;
   tabptr.p->dropping = false;
-  tabptr.p->noOfKeyAttr = noOfKeyAttr;
-  tabptr.p->hasCharAttr = hasCharAttr;
-  tabptr.p->noOfDistrKeys = noOfDistrKeys;
+  tabptr.p->noOfKeyAttr = desc->noOfKeyAttr;
+  tabptr.p->hasCharAttr = desc->hasCharAttr;
+  tabptr.p->noOfDistrKeys = desc->noOfDistrKeys;
   
   signal->theData[0] = tabptr.i;
   signal->theData[1] = retPtr;
@@ -2323,113 +2298,37 @@
 			  Uint32 tabPtrI,
 			  bool distr)
 {
-  Uint64 Tmp[MAX_KEY_SIZE_IN_WORDS * 4 * MAX_XFRM_MULTIPLY];
-  const Uint32 dstSize = sizeof(Tmp) / 4;
+  Uint64 Tmp[MAX_KEY_SIZE_IN_WORDS * MAX_XFRM_MULTIPLY];
   const TableRecord* tabPtrP = &tableRecord[tabPtrI];
-  const Uint32 noOfKeyAttr = tabPtrP->noOfKeyAttr;
-  Uint32 noOfDistrKeys = tabPtrP->noOfDistrKeys;
   const bool hasCharAttr = tabPtrP->hasCharAttr;
+  const bool hasDistKeys = tabPtrP->noOfDistrKeys > 0;
   
   Uint32 *dst = (Uint32*)Tmp;
   Uint32 dstPos = 0;
-  Uint32 srcPos = 0;
   Uint32 keyPartLen[MAX_ATTRIBUTES_IN_INDEX];
-  if(hasCharAttr){
-    Uint32 i = 0;
-    while (i < noOfKeyAttr) {
-      const TableRecord::KeyAttr& keyAttr = tabPtrP->keyAttr[i];
-      
-      Uint32 srcBytes = 
-	AttributeDescriptor::getSizeInBytes(keyAttr.attributeDescriptor);
-      Uint32 srcWords = (srcBytes + 3) / 4;
-      Uint32 dstWords = ~0;
-      uchar* dstPtr = (uchar*)&dst[dstPos];
-      const uchar* srcPtr = (const uchar*)&src[srcPos];
-      CHARSET_INFO* cs = keyAttr.charsetInfo;
-      
-      if (cs == NULL) {
-	jam();
-	memcpy(dstPtr, srcPtr, srcWords << 2);
-	dstWords = srcWords;
-      } else {
-	jam();
-        Uint32 typeId =
-          AttributeDescriptor::getType(keyAttr.attributeDescriptor);
-        Uint32 lb, len;
-        bool ok = NdbSqlUtil::get_var_length(typeId, srcPtr, srcBytes, lb, len);
-        ndbrequire(ok);
-	Uint32 xmul = cs->strxfrm_multiply;
-	if (xmul == 0)
-	  xmul = 1;
-        /*
-         * Varchar is really Char.  End spaces do not matter.  To get
-         * same hash we blank-pad to maximum length via strnxfrm.
-         * TODO use MySQL charset-aware hash function instead
-         */
-	Uint32 dstLen = xmul * (srcBytes - lb);
-	ndbrequire(dstLen <= ((dstSize - dstPos) << 2));
-	int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
-        ndbrequire(n != -1);
-	while ((n & 3) != 0) {
-	  dstPtr[n++] = 0;
-	}
-	dstWords = (n >> 2);
-      }
-      dstPos += dstWords;
-      srcPos += srcWords;
-      keyPartLen[i++] = dstWords;
-    }
+  Uint32 * keyPartLenPtr;
+  if(hasCharAttr)
+  {
+    keyPartLenPtr = keyPartLen;
+    dstPos = xfrm_key(tabPtrI, src, dst, sizeof(Tmp) >> 2, keyPartLenPtr);
+    ndbrequire(dstPos);
   } 
   else 
   {
     dst = src;
     dstPos = srcLen;
+    keyPartLenPtr = 0;
   }
   
   md5_hash(dstHash, (Uint64*)dst, dstPos);
   
-  if(distr && noOfDistrKeys)
+  if(distr && hasDistKeys)
   {
     jam();
-    src = dst;
-    dstPos = 0;
-    Uint32 i = 0;
-    if(hasCharAttr)
-    {
-      while (i < noOfKeyAttr && noOfDistrKeys) 
-      {
-	const TableRecord::KeyAttr& keyAttr = tabPtrP->keyAttr[i];
-	Uint32 len = keyPartLen[i];
-	if(AttributeDescriptor::getDKey(keyAttr.attributeDescriptor))
-	{
-	  noOfDistrKeys--;
-	  memmove(dst+dstPos, src, len << 2);
-	  dstPos += len;
-	}
-	src += len;
-	i++;
-      }
-    }
-    else
-    {
-      while (i < noOfKeyAttr && noOfDistrKeys) 
-      {
-	const TableRecord::KeyAttr& keyAttr = tabPtrP->keyAttr[i];
-	Uint32 len = 
-	  AttributeDescriptor::getSizeInBytes(keyAttr.attributeDescriptor);
-	len = (len + 3) / 4;
-	if(AttributeDescriptor::getDKey(keyAttr.attributeDescriptor))
-	{
-	  noOfDistrKeys--;
-	  memmove(dst+dstPos, src, len << 2);
-	  dstPos += len;
-	}
-	src += len;
-	i++;
-      }
-    }
+    
     Uint32 tmp[4];
-    md5_hash(tmp, (Uint64*)dst, dstPos);
+    Uint32 len = create_distr_key(tabPtrI, dst, keyPartLenPtr);
+    md5_hash(tmp, (Uint64*)dst, len);
     dstHash[1] = tmp[1];
   }
   return true;  // success
@@ -3347,7 +3246,7 @@
   lqhKeyReq->tcBlockref = sig4;
   lqhKeyReq->savePointId = sig5;
 
-  sig0 = regCachePtr->tableref + (regCachePtr->schemaVersion << 16);
+  sig0 = regCachePtr->tableref + ((regCachePtr->schemaVersion << 16) &
0xFFFF0000);
   sig1 = regCachePtr->fragmentid + (regTcPtr->tcNodedata[1] << 16);
   sig2 = regApiPtr->transid[0];
   sig3 = regApiPtr->transid[1];
@@ -10204,10 +10103,6 @@
     tabptr.p->noOfKeyAttr = 0;
     tabptr.p->hasCharAttr = 0;
     tabptr.p->noOfDistrKeys = 0;
-    for (unsigned k = 0; k < MAX_ATTRIBUTES_IN_INDEX; k++) {
-      tabptr.p->keyAttr[k].attributeDescriptor = 0;
-      tabptr.p->keyAttr[k].charsetInfo = 0;
-    }
   }//for
 }//Dbtc::initTable()
 
@@ -13137,7 +13032,7 @@
     return ZNO_SUCH_TABLE;
   if(dropping)
     return ZDROP_TABLE_IN_PROGRESS;
-  if(schemaVersion != currentSchemaVersion)
+  if(table_version_major(schemaVersion) != table_version_major(currentSchemaVersion))
     return ZWRONG_SCHEMA_VERSION_ERROR;
   ErrorReporter::handleAssert("Dbtc::TableRecord::getErrorCode",
 			      __FILE__, __LINE__);

--- 1.52/storage/ndb/src/mgmapi/mgmapi.cpp	2005-08-08 22:21:37 +02:00
+++ 1.53/storage/ndb/src/mgmapi/mgmapi.cpp	2005-08-27 07:42:51 +02:00
@@ -335,15 +335,21 @@
 
   const Properties* p = parser.parse(ctx, session);
   if (p == NULL){
-    /**
-     * Print some info about why the parser returns NULL
-     */
-    fprintf(handle->errstream, 
-	    "Error in mgm protocol parser. cmd: >%s< status: %d curr: %d\n",
-	    cmd, (Uint32)ctx.m_status, ctx.m_currentToken);
-    DBUG_PRINT("info",("ctx.status: %d, ctx.m_currentToken: %s",
-		       ctx.m_status, ctx.m_currentToken));
-  } 
+    if(!ndb_mgm_is_connected(handle)) {
+      return NULL;
+    }
+    else
+    {
+      /**
+       * Print some info about why the parser returns NULL
+       */
+      fprintf(handle->errstream,
+	      "Error in mgm protocol parser. cmd: >%s< status: %d curr: %d\n",
+	      cmd, (Uint32)ctx.m_status, ctx.m_currentToken);
+      DBUG_PRINT("info",("ctx.status: %d, ctx.m_currentToken: %s",
+		         ctx.m_status, ctx.m_currentToken));
+    }
+  }
 #ifdef MGMAPI_LOG
   else {
     /** 
@@ -363,6 +369,15 @@
 {
   if(!handle)
     return 0;
+
+  if(handle->connected)
+  {
+    if(Ndb_check_socket_hup(handle->socket))
+    {
+      handle->connected= 0;
+      NDB_CLOSE_SOCKET(handle->socket);
+    }
+  }
   return handle->connected;
 }
 

--- 1.89/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2005-08-08 22:21:37 +02:00
+++ 1.90/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2005-08-27 07:42:51 +02:00
@@ -1564,25 +1564,22 @@
   const char * originalInternalName = internalName.c_str();
 
   DBUG_ENTER("NdbDictionaryImpl::alterTable");
-  if(!get_local_table_info(internalName, false)){
-    m_error.code= 709;
+  Ndb_local_table_info * local = 0;
+  if((local= get_local_table_info(originalInternalName, false)) == 0)
+  {
+    m_error.code = 709;
     DBUG_RETURN(-1);
   }
+
   // Alter the table
   int ret = m_receiver.alterTable(m_ndb, impl);
   if(ret == 0){
     // Remove cached information and let it be refreshed at next access
-    if (m_localHash.get(originalInternalName) != NULL) {
-      m_localHash.drop(originalInternalName);
-      m_globalHash->lock();
-      NdbTableImpl * cachedImpl = m_globalHash->get(originalInternalName);
-      // If in local cache it must be in global
-      if (!cachedImpl)
-	abort();
-      cachedImpl->m_status = NdbDictionary::Object::Invalid;
-      m_globalHash->drop(cachedImpl);
-      m_globalHash->unlock();
-    }
+    m_globalHash->lock();
+    local->m_table_impl->m_status = NdbDictionary::Object::Invalid;
+    m_globalHash->drop(local->m_table_impl);
+    m_globalHash->unlock();
+    m_localHash.drop(originalInternalName);
   }
   DBUG_RETURN(ret);
 }

--- 1.204/sql/ha_ndbcluster.cc	2005-08-22 12:41:17 +02:00
+++ 1.205/sql/ha_ndbcluster.cc	2005-08-27 07:42:49 +02:00
@@ -2921,7 +2921,16 @@
     errkey= m_dupkey;
   }
   if (flag & HA_STATUS_AUTO)
+  {
     DBUG_PRINT("info", ("HA_STATUS_AUTO"));
+    if (m_table)
+    {
+      Ndb *ndb= get_ndb();
+      
+      auto_increment_value= 
+        ndb->readAutoIncrementValue((const NDBTAB *) m_table);
+    }
+  }
   DBUG_VOID_RETURN;
 }
 
@@ -3243,7 +3252,10 @@
       DBUG_PRINT("info", ("Table schema version: %d", 
                           tab->getObjectVersion()));
       // Check if thread has stale local cache
-      if (tab->getObjectStatus() == NdbDictionary::Object::Invalid)
+      // New transaction must not use old tables... (trans != 0)
+      // Running might...
+      if ((trans && tab->getObjectStatus() !=
NdbDictionary::Object::Retrieved)
+	  || tab->getObjectStatus() == NdbDictionary::Object::Invalid)
       {
         invalidate_dictionary_cache(FALSE);
         if (!(tab= dict->getTable(m_tabname, &tab_info)))
@@ -6947,6 +6959,8 @@
       break;
     Ndb_item *a= cond->next->ndb_item;
     Ndb_item *b, *field, *value= NULL;
+    LINT_INIT(field);
+
     switch (cond->ndb_item->argument_count()) {
     case 1:
       field= 

--- 1.103/sql/ha_innodb.h	2005-08-21 21:06:07 +02:00
+++ 1.104/sql/ha_innodb.h	2005-08-27 07:42:49 +02:00
@@ -244,6 +244,7 @@
 extern ulong srv_n_free_tickets_to_enter;
 extern ulong srv_thread_sleep_delay;
 extern ulong srv_thread_concurrency;
+extern ulong srv_commit_concurrency;
 }
 
 extern TYPELIB innobase_lock_typelib;