BUG#9626 Several serious errors reported by Valgrind in latest 5.0 bk tree

 - Fix several valgrind warnings.

ndb/include/kernel/AttributeList.hpp

@@ -17,6 +17,8 @@
 #ifndef ATTRIBUTE_LIST_HPP
 #define ATTRIBUTE_LIST_HPP
 
+#include "ndb_limits.h"
+
 /**
  * Masks and lists used by index and trigger.  Must be plain old Uint32 data.
  * XXX depends on other headers XXX move to some common file

ndb/include/ndbapi/Ndb.hpp

@@ -1583,15 +1583,17 @@ private:
   void    abortTransactionsAfterNodeFailure(Uint16 aNodeId);
 
   static
-  const char * externalizeTableName(const char * internalTableName, bool fullyQualifiedNames);
+  const char * externalizeTableName(const char * internalTableName,
+                                    bool fullyQualifiedNames);
   const char * externalizeTableName(const char * internalTableName);
-  const char * internalizeTableName(const char * externalTableName);
+  const BaseString internalize_table_name(const char * external_name) const;
 
   static
-  const char * externalizeIndexName(const char * internalIndexName, bool fullyQualifiedNames);
+  const char * externalizeIndexName(const char * internalIndexName,
+                                    bool fullyQualifiedNames);
   const char * externalizeIndexName(const char * internalIndexName);
-  const char * internalizeIndexName(const NdbTableImpl * table,
-				    const char * externalIndexName);
+  const BaseString internalize_index_name(const NdbTableImpl * table,
+                                          const char * external_name) const;
 
   static
   const BaseString getDatabaseFromInternalName(const char * internalName);

ndb/include/util/SimpleProperties.hpp

@@ -172,6 +172,8 @@ public:
     virtual bool reset() = 0;
     virtual bool putWord(Uint32 val) = 0;
     virtual bool putWords(const Uint32 * src, Uint32 len) = 0;
+  private:
+    bool add(const char* value, int len);
   };
 };
 
@@ -211,7 +213,7 @@ private:
 };
 
 /**
- * Writer for linear memory
+ * Writer for UtilBuffer
  */
 class UtilBufferWriter : public SimpleProperties::Writer {
 public:

ndb/src/common/util/SimpleProperties.cpp

@@ -36,6 +36,28 @@ SimpleProperties::Writer::add(Uint16 key, Uint32 value){
   return putWord(htonl(value));
 }
 
+bool
+SimpleProperties::Writer::add(const char * value, int len){
+  const Uint32 valLen = (len + 3) / 4;
+
+  if ((len % 4) == 0)
+    return putWords((Uint32*)value, valLen);
+
+  const Uint32 putLen= valLen - 1;
+  if (!putWords((Uint32*)value, putLen))
+    return false;
+
+  // Special handling of last bytes
+  union {
+    Uint32 lastWord;
+    char lastBytes[4];
+  };
+  memcpy(lastBytes,
+         value + putLen*4,
+         len - putLen*4);
+  return putWord(lastWord);
+}
+
 bool
 SimpleProperties::Writer::add(Uint16 key, const char * value){
   Uint32 head = StringValue;
@@ -46,9 +68,9 @@ SimpleProperties::Writer::add(Uint16 key, const char * value){
   Uint32 strLen = strlen(value) + 1; // Including NULL-byte
   if(!putWord(htonl(strLen)))
     return false;
-  
-  const Uint32 valLen = (strLen + 3) / 4;
-  return putWords((Uint32*)value, valLen);
+
+  return add(value, (int)strLen);
+
 }
 
 bool
@@ -60,9 +82,8 @@ SimpleProperties::Writer::add(Uint16 key, const void* value, int len){
     return false;
   if(!putWord(htonl(len)))
     return false;
-  
-  const Uint32 valLen = (len + 3) / 4;
-  return putWords((Uint32*)value, valLen);
+
+  return add((const char*)value, len);
 }
 
 SimpleProperties::Reader::Reader(){
@@ -392,6 +413,7 @@ UtilBufferWriter::putWords(const Uint32 * src, Uint32 len){
   return (m_buf.append(src, 4 * len) == 0);
 }
 
+
 Uint32
 UtilBufferWriter::getWordsUsed() const { return m_buf.length() / 4;}
 

ndb/src/ndbapi/DictCache.cpp

@@ -79,11 +79,14 @@ LocalDictCache::drop(const char * name){
  * Global cache
  */
 GlobalDictCache::GlobalDictCache(){
+  DBUG_ENTER("GlobalDictCache::GlobalDictCache");
   m_tableHash.createHashTable();
   m_waitForTableCondition = NdbCondition_Create();
+  DBUG_VOID_RETURN;
 }
 
 GlobalDictCache::~GlobalDictCache(){
+  DBUG_ENTER("GlobalDictCache::~GlobalDictCache");
   NdbElement_t<Vector<TableVersion> > * curr = m_tableHash.getNext(0);
   while(curr != 0){
     Vector<TableVersion> * vers = curr->theData;
@@ -93,20 +96,52 @@ GlobalDictCache::~GlobalDictCache(){
 	delete (* vers)[i].m_impl;
     }
     delete curr->theData;
+    curr->theData= NULL;
     curr = m_tableHash.getNext(curr);
   }
-  
   m_tableHash.releaseHashTable();
   NdbCondition_Destroy(m_waitForTableCondition);
+  DBUG_VOID_RETURN;
 }
 
-#include <NdbOut.hpp>
+void GlobalDictCache::printCache()
+{
+  DBUG_ENTER("GlobalDictCache::printCache");
+  NdbElement_t<Vector<TableVersion> > * curr = m_tableHash.getNext(0);
+  while(curr != 0){
+    DBUG_PRINT("curr", ("len: %d, hash: %d, lk: %d, str: %s",
+                        curr->len, curr->hash, curr->localkey1, curr->str));
+    if (curr->theData){
+      Vector<TableVersion> * vers = curr->theData;
+      const unsigned sz = vers->size();
+      for(unsigned i = 0; i<sz ; i++){
+        TableVersion tv= (*vers)[i];
+        DBUG_PRINT("  ", ("vers[%d]: ver: %d, refCount: %d, status: %d",
+                          sz, tv.m_version, tv.m_refCount, tv.m_status));
+        if(tv.m_impl != 0)
+        {
+          DBUG_PRINT("  ", ("m_impl: internalname: %s",
+                            tv.m_impl->m_internalName.c_str()));
+        }
+      }
+    }
+    else
+    {
+      DBUG_PRINT("  ", ("NULL"));
+    }
+    curr = m_tableHash.getNext(curr);
+  }
+  DBUG_VOID_RETURN;
+}
 
-NdbTableImpl * 
+NdbTableImpl *
 GlobalDictCache::get(const char * name)
 {
+  DBUG_ENTER("GlobalDictCache::get");
+  DBUG_PRINT("enter", ("name: %s", name));
+
   const Uint32 len = strlen(name);
-  Vector<TableVersion> * versions = 0;  
+  Vector<TableVersion> * versions = 0;
   versions = m_tableHash.getData(name, len);
   if(versions == 0){
     versions = new Vector<TableVersion>(2);
@@ -121,7 +156,7 @@ GlobalDictCache::get(const char * name)
     switch(ver->m_status){
     case OK:
       ver->m_refCount++;
-      return ver->m_impl;
+      DBUG_RETURN(ver->m_impl);
     case DROPPED:
       retreive = true; // Break loop
       break;
@@ -140,24 +175,28 @@ GlobalDictCache::get(const char * name)
   tmp.m_status = RETREIVING;
   tmp.m_refCount = 1; // The one retreiving it
   versions->push_back(tmp);
-  return 0;
+  DBUG_RETURN(0);
 }
 
 NdbTableImpl *
 GlobalDictCache::put(const char * name, NdbTableImpl * tab)
 {
+  DBUG_ENTER("GlobalDictCache::put");
+  DBUG_PRINT("enter", ("name: %s, internal_name: %s",
+                       name, tab ? tab->m_internalName.c_str() : "tab NULL"));
+
   const Uint32 len = strlen(name);
   Vector<TableVersion> * vers = m_tableHash.getData(name, len);
   if(vers == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
 
   const Uint32 sz = vers->size();
   if(sz == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
   
@@ -170,7 +209,7 @@ GlobalDictCache::put(const char * name, NdbTableImpl * tab)
   }
   
   if(tab == 0){
-    // No table found in db
+    DBUG_PRINT("info", ("No table found in db"));
     vers->erase(sz - 1);
   } else {
     ver.m_impl = tab;
@@ -179,74 +218,84 @@ GlobalDictCache::put(const char * name, NdbTableImpl * tab)
   }
   
   NdbCondition_Broadcast(m_waitForTableCondition);
-  return tab;
+  DBUG_RETURN(tab);
 } 
 
 void
 GlobalDictCache::drop(NdbTableImpl * tab)
 {
+  DBUG_ENTER("GlobalDictCache::drop");
+  DBUG_PRINT("enter", ("internal_name: %s", tab->m_internalName.c_str()));
+
   unsigned i;
   const Uint32 len = strlen(tab->m_internalName.c_str());
   Vector<TableVersion> * vers = 
     m_tableHash.getData(tab->m_internalName.c_str(), len);
   if(vers == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
 
   const Uint32 sz = vers->size();
   if(sz == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
-  
+
   for(i = 0; i < sz; i++){
     TableVersion & ver = (* vers)[i];
     if(ver.m_impl == tab){
-      if(ver.m_refCount == 0 || ver.m_status == RETREIVING || 
+      if(ver.m_refCount == 0 || ver.m_status == RETREIVING ||
 	 ver.m_version != tab->m_version){
-	ndbout_c("Dropping with refCount=%d status=%d impl=%p",
-		 ver.m_refCount, ver.m_status, ver.m_impl);
+	DBUG_PRINT("info", ("Dropping with refCount=%d status=%d impl=%p",
+                            ver.m_refCount, ver.m_status, ver.m_impl));
 	break;
       }
-      
+      DBUG_PRINT("info", ("Found table to drop, i: %d, name: %s",
+                          i, ver.m_impl->m_internalName.c_str()));
       ver.m_refCount--;
       ver.m_status = DROPPED;
       if(ver.m_refCount == 0){
+        DBUG_PRINT("info", ("refCount is zero, deleting m_impl"))
 	delete ver.m_impl;
 	vers->erase(i);
       }
-      return;
+      DBUG_VOID_RETURN;
     }
   }
-  
+
   for(i = 0; i<sz; i++){
     TableVersion & ver = (* vers)[i];
-    ndbout_c("%d: version: %d refCount: %d status: %d impl: %p",
-	     i, ver.m_version, ver.m_refCount, ver.m_status, ver.m_impl);
+    DBUG_PRINT("info", ("%d: version: %d refCount: %d status: %d impl: %p",
+                        i, ver.m_version, ver.m_refCount,
+                        ver.m_status, ver.m_impl));
   }
   
   abort();
 }
 
 void
-GlobalDictCache::release(NdbTableImpl * tab){
+GlobalDictCache::release(NdbTableImpl * tab)
+{
+  DBUG_ENTER("GlobalDictCache::release");
+  DBUG_PRINT("enter", ("internal_name: %s", tab->m_internalName.c_str()));
+
   unsigned i;
   const Uint32 len = strlen(tab->m_internalName.c_str());
   Vector<TableVersion> * vers = 
     m_tableHash.getData(tab->m_internalName.c_str(), len);
   if(vers == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
 
   const Uint32 sz = vers->size();
   if(sz == 0){
     // Should always tried to retreive it first 
-    // and then there should be a record
+    // and thus there should be a record
     abort(); 
   }
   
@@ -255,20 +304,21 @@ GlobalDictCache::release(NdbTableImpl * tab){
     if(ver.m_impl == tab){
       if(ver.m_refCount == 0 || ver.m_status == RETREIVING || 
 	 ver.m_version != tab->m_version){
-	ndbout_c("Releasing with refCount=%d status=%d impl=%p",
-		 ver.m_refCount, ver.m_status, ver.m_impl);
+	DBUG_PRINT("info", ("Releasing with refCount=%d status=%d impl=%p",
+                            ver.m_refCount, ver.m_status, ver.m_impl));
 	break;
       }
       
       ver.m_refCount--;
-      return;
+      DBUG_VOID_RETURN;
     }
   }
   
   for(i = 0; i<sz; i++){
     TableVersion & ver = (* vers)[i];
-    ndbout_c("%d: version: %d refCount: %d status: %d impl: %p",
-	     i, ver.m_version, ver.m_refCount, ver.m_status, ver.m_impl);
+    DBUG_PRINT("info", ("%d: version: %d refCount: %d status: %d impl: %p",
+                        i, ver.m_version, ver.m_refCount,
+                        ver.m_status, ver.m_impl));
   }
   
   abort();

ndb/src/ndbapi/DictCache.hpp

@@ -76,6 +76,8 @@ public:
   };
   
 private:
+  void printCache();
+
   struct TableVersion {
     Uint32 m_version;
     Uint32 m_refCount;

ndb/src/ndbapi/Ndb.cpp

@@ -750,16 +750,14 @@ Remark:		Returns a new TupleId to the application.
                 The TupleId comes from SYSTAB_0 where SYSKEY_0 = TableId.
                 It is initialized to (TableId << 48) + 1 in NdbcntrMain.cpp.
 ****************************************************************************/
-#define DEBUG_TRACE(msg) \
-//  ndbout << __FILE__ << " line: " << __LINE__ << " msg: " << msg << endl
-
 Uint64
 Ndb::getAutoIncrementValue(const char* aTableName, Uint32 cacheSize)
 {
   DBUG_ENTER("getAutoIncrementValue");
-  const char * internalTableName = internalizeTableName(aTableName);
+  BaseString internal_tabname(internalize_table_name(aTableName));
+
   Ndb_local_table_info *info=
-    theDictionary->get_local_table_info(internalTableName, false);
+    theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0)
     DBUG_RETURN(~(Uint64)0);
   const NdbTableImpl *table= info->m_table_impl;
@@ -811,7 +809,7 @@ Ndb::getTupleIdFromNdb(Uint32 aTableId, Uint32 cacheSize)
 Uint64
 Ndb::readAutoIncrementValue(const char* aTableName)
 {
-  DBUG_ENTER("readtAutoIncrementValue");
+  DBUG_ENTER("readAutoIncrementValue");
   const NdbTableImpl* table = theDictionary->getTable(aTableName);
   if (table == 0) {
     theError= theDictionary->getNdbError();
@@ -825,7 +823,7 @@ Ndb::readAutoIncrementValue(const char* aTableName)
 Uint64
 Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable)
 {
-  DBUG_ENTER("readtAutoIncrementValue");
+  DBUG_ENTER("readAutoIncrementValue");
   if (aTable == 0)
     DBUG_RETURN(~(Uint64)0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
@@ -847,62 +845,63 @@ Ndb::readTupleIdFromNdb(Uint32 aTableId)
 bool
 Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
 {
-  DEBUG_TRACE("setAutoIncrementValue " << val);
-  const char * internalTableName= internalizeTableName(aTableName);
+  DBUG_ENTER("setAutoIncrementValue");
+  BaseString internal_tabname(internalize_table_name(aTableName));
+
   Ndb_local_table_info *info=
-    theDictionary->get_local_table_info(internalTableName, false);
+    theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError= theDictionary->getNdbError();
-    return false;
+    DBUG_RETURN(false);
   }
   const NdbTableImpl* table= info->m_table_impl;
-  return setTupleIdInNdb(table->m_tableId, val, increase);
+  DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
 }
 
 bool
 Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool increase)
 {
-  DEBUG_TRACE("setAutoIncrementValue " << val);
+  DBUG_ENTER("setAutoIncrementValue");
   if (aTable == 0)
-    return ~(Uint64)0;
+    DBUG_RETURN(~(Uint64)0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
-  return setTupleIdInNdb(table->m_tableId, val, increase);
+  DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
 }
 
-bool 
+bool
 Ndb::setTupleIdInNdb(const char* aTableName, Uint64 val, bool increase )
 {
-  DEBUG_TRACE("setTupleIdInNdb");
+  DBUG_ENTER("setTupleIdInNdb(const char*, ...)");
   const NdbTableImpl* table = theDictionary->getTable(aTableName);
   if (table == 0) {
     theError= theDictionary->getNdbError();
-    return false;
+    DBUG_RETURN(false);
   }
-  return setTupleIdInNdb(table->m_tableId, val, increase);
+  DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
 }
 
 bool
 Ndb::setTupleIdInNdb(Uint32 aTableId, Uint64 val, bool increase )
 {
-  DEBUG_TRACE("setTupleIdInNdb");
+  DBUG_ENTER("setTupleIdInNdb(Uint32, ...)");
   if (increase)
   {
     if (theFirstTupleId[aTableId] != theLastTupleId[aTableId])
     {
       // We have a cache sequence
       if (val <= theFirstTupleId[aTableId]+1)
-	return false;
+	DBUG_RETURN(false);
       if (val <= theLastTupleId[aTableId])
       {
 	theFirstTupleId[aTableId] = val - 1;
-	return true;
+	DBUG_RETURN(true);
       }
       // else continue;
-    }    
-    return (opTupleIdOnNdb(aTableId, val, 2) == val);
+    }
+    DBUG_RETURN((opTupleIdOnNdb(aTableId, val, 2) == val));
   }
   else
-    return (opTupleIdOnNdb(aTableId, val, 1) == val);
+    DBUG_RETURN((opTupleIdOnNdb(aTableId, val, 1) == val));
 }
 
 Uint64
@@ -1142,25 +1141,63 @@ Ndb::externalizeIndexName(const char * internalIndexName)
   return externalizeIndexName(internalIndexName, usingFullyQualifiedNames());
 }
 
-const char *
-Ndb::internalizeTableName(const char * externalTableName)
+
+const BaseString
+Ndb::internalize_table_name(const char *external_name) const
 {
+  BaseString ret;
+  DBUG_ENTER("internalize_table_name");
+  DBUG_PRINT("enter", ("external_name: %s", external_name));
+
   if (fullyQualifiedNames)
-    return theImpl->internalize_table_name(externalTableName);
+  {
+    /* Internal table name format <db>/<schema>/<table>
+       <db>/<schema> is already available in m_prefix
+       so just concat the two strings
+     */
+    ret.assfmt("%s%s",
+               theImpl->m_prefix.c_str(),
+               external_name);
+  }
   else
-    return externalTableName;
+    ret.assign(external_name);
+
+  DBUG_PRINT("exit", ("internal_name: %s", ret.c_str()));
+  DBUG_RETURN(ret);
 }
- 
-const char *
-Ndb::internalizeIndexName(const NdbTableImpl * table,
-                          const char * externalIndexName)
+
+
+const BaseString
+Ndb::internalize_index_name(const NdbTableImpl * table,
+                           const char * external_name) const
 {
+  BaseString ret;
+  DBUG_ENTER("internalize_index_name");
+  DBUG_PRINT("enter", ("external_name: %s, table_id: %d",
+                       external_name, table ? table->m_tableId : ~0));
+  if (!table)
+  {
+    DBUG_PRINT("error", ("!table"));
+    return ret;
+  }
+
   if (fullyQualifiedNames)
-    return theImpl->internalize_index_name(table, externalIndexName);
+  {
+    /* Internal index name format <db>/<schema>/<tabid>/<table> */
+    ret.assfmt("%s%d%c%s",
+               theImpl->m_prefix.c_str(),
+               table->m_tableId,
+               table_name_separator,
+               external_name);
+  }
   else
-    return externalIndexName;
+    ret.assign(external_name);
+
+  DBUG_PRINT("exit", ("internal_name: %s", ret.c_str()));
+  DBUG_RETURN(ret);
 }
 
+
 const BaseString
 Ndb::getDatabaseFromInternalName(const char * internalName)
 {

ndb/src/ndbapi/NdbDictionary.cpp

@@ -773,9 +773,11 @@ NdbDictionary::Dictionary::getTable(const char * name) const
 
 void
 NdbDictionary::Dictionary::invalidateTable(const char * name){
+  DBUG_ENTER("NdbDictionaryImpl::invalidateTable");
   NdbTableImpl * t = m_impl.getTable(name);
   if(t)
     m_impl.invalidateObject(* t);
+  DBUG_VOID_RETURN;
 }
 
 void
@@ -811,11 +813,13 @@ NdbDictionary::Dictionary::getIndex(const char * indexName,
 void
 NdbDictionary::Dictionary::invalidateIndex(const char * indexName,
                                            const char * tableName){
+  DBUG_ENTER("NdbDictionaryImpl::invalidateIndex");
   NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
   if(i) {
     assert(i->m_table != 0);
     m_impl.invalidateObject(* i->m_table);
   }
+  DBUG_VOID_RETURN;
 }
 
 void

ndb/src/ndbapi/NdbDictionaryImpl.hpp

@@ -19,7 +19,6 @@
 
 #include <ndb_types.h>
 #include <kernel_types.h>
-#include <ndb_limits.h>
 #include <NdbError.hpp>
 #include <BaseString.hpp>
 #include <Vector.hpp>
@@ -309,8 +308,8 @@ public:
   int listObjects(NdbDictionary::Dictionary::List& list, Uint32 requestData, bool fullyQualifiedNames);
   int listObjects(NdbApiSignal* signal);
   
-  NdbTableImpl * getTable(int tableId, bool fullyQualifiedNames);
-  NdbTableImpl * getTable(const char * name, bool fullyQualifiedNames);
+/*  NdbTableImpl * getTable(int tableId, bool fullyQualifiedNames); */
+  NdbTableImpl * getTable(const BaseString& name, bool fullyQualifiedNames);
   NdbTableImpl * getTable(class NdbApiSignal * signal, 
 			  LinearSectionPtr ptr[3],
 			  Uint32 noOfSections, bool fullyQualifiedNames);
@@ -368,8 +367,6 @@ private:
 
   Uint32 m_fragmentId;
   UtilBuffer m_buffer;
-  // Buffer used when requesting a table by name
-  UtilBuffer m_namebuf;
 };
 
 class NdbDictionaryImpl : public NdbDictionary::Dictionary {
@@ -406,13 +403,12 @@ public:
 
   int listObjects(List& list, NdbDictionary::Object::Type type);
   int listIndexes(List& list, Uint32 indexId);
-  
+
   NdbTableImpl * getTable(const char * tableName, void **data= 0);
-  Ndb_local_table_info * get_local_table_info(const char * internalName,
-					      bool do_add_blob_tables);
+  Ndb_local_table_info* get_local_table_info(
+    const BaseString& internalTableName, bool do_add_blob_tables);
   NdbIndexImpl * getIndex(const char * indexName,
 			  const char * tableName);
-  NdbIndexImpl * getIndexImpl(const char * name, const char * internalName);
   NdbEventImpl * getEvent(const char * eventName);
   NdbEventImpl * getEventImpl(const char * internalName);
   
@@ -430,7 +426,9 @@ public:
   NdbDictInterface m_receiver;
   Ndb & m_ndb;
 private:
-  Ndb_local_table_info * fetchGlobalTableImpl(const char * internalName);
+  NdbIndexImpl * getIndexImpl(const char * name,
+                              const BaseString& internalName);
+  Ndb_local_table_info * fetchGlobalTableImpl(const BaseString& internalName);
 };
 
 inline
@@ -638,26 +636,27 @@ NdbDictionaryImpl::getImpl(const NdbDictionary::Dictionary & t){
  */
 
 inline
-NdbTableImpl * 
-NdbDictionaryImpl::getTable(const char * tableName, void **data)
+NdbTableImpl *
+NdbDictionaryImpl::getTable(const char * table_name, void **data)
 {
+  const BaseString internal_tabname(m_ndb.internalize_table_name(table_name));
   Ndb_local_table_info *info=
-    get_local_table_info(m_ndb.internalizeTableName(tableName), true);
-  if (info == 0) {
+    get_local_table_info(internal_tabname, true);
+  if (info == 0)
     return 0;
-  }
-  if (data) {
+
+  if (data)
     *data= info->m_local_data;
-  }
+
   return info->m_table_impl;
 }
 
 inline
 Ndb_local_table_info * 
-NdbDictionaryImpl::get_local_table_info(const char * internalTableName,
+NdbDictionaryImpl::get_local_table_info(const BaseString& internalTableName,
 					bool do_add_blob_tables)
 {
-  Ndb_local_table_info *info= m_localHash.get(internalTableName);
+  Ndb_local_table_info *info= m_localHash.get(internalTableName.c_str());
   if (info == 0) {
     info= fetchGlobalTableImpl(internalTableName);
     if (info == 0) {
@@ -672,34 +671,35 @@ NdbDictionaryImpl::get_local_table_info(const char * internalTableName,
 
 inline
 NdbIndexImpl * 
-NdbDictionaryImpl::getIndex(const char * indexName,
-			    const char * tableName)
+NdbDictionaryImpl::getIndex(const char * index_name,
+			    const char * table_name)
 {
-  if (tableName || m_ndb.usingFullyQualifiedNames()) {
-    const char * internalIndexName = 0;
-    if (tableName) {
-      NdbTableImpl * t = getTable(tableName);
-      if (t != 0)
-        internalIndexName = m_ndb.internalizeIndexName(t, indexName);
-    } else {
-      internalIndexName =
-	m_ndb.internalizeTableName(indexName); // Index is also a table
-    }
-    if (internalIndexName) {
-      Ndb_local_table_info * info = get_local_table_info(internalIndexName,
-							 false);
-      if (info) {
-	NdbTableImpl * tab = info->m_table_impl;
+  if (table_name || m_ndb.usingFullyQualifiedNames())
+  {
+    const BaseString internal_indexname(
+      (table_name)
+      ?
+      m_ndb.internalize_index_name(getTable(table_name), index_name)
+      :
+      m_ndb.internalize_table_name(index_name)); // Index is also a table
+
+    if (internal_indexname.length())
+    {
+      Ndb_local_table_info * info=
+        get_local_table_info(internal_indexname, false);
+      if (info)
+      {
+	NdbTableImpl * tab= info->m_table_impl;
         if (tab->m_index == 0)
-          tab->m_index = getIndexImpl(indexName, internalIndexName);
+          tab->m_index= getIndexImpl(index_name, internal_indexname);
         if (tab->m_index != 0)
-          tab->m_index->m_table = tab;
+          tab->m_index->m_table= tab;
         return tab->m_index;
       }
     }
   }
 
-  m_error.code = 4243;
+  m_error.code= 4243;
   return 0;
 }
 

ndb/src/ndbapi/NdbImpl.hpp

@@ -65,7 +65,6 @@ public:
   BaseString m_schemaname; // Schema name
 
   BaseString m_prefix; // Buffer for preformatted internal name <db>/<schema>/
-  BaseString m_internalname;
 
   void update_prefix()
   {
@@ -73,23 +72,6 @@ public:
                     m_schemaname.c_str(), table_name_separator);
   }
 
-  const char* internalize_table_name(const char* ext_name)
-  {
-    // Internal table name format <db>/<schema>/<table>
-    return m_internalname.assign(m_prefix).append(ext_name).c_str();
-  }
-
-  const char* internalize_index_name(const NdbTableImpl *table,
-                                     const char* ext_name)
-  {
-    // Internal index name format <db>/<schema>/<tabid>/<table>
-    return m_internalname.assign(m_prefix).appfmt("%d%c%s",
-                                                  table->m_tableId,
-                                                  table_name_separator,
-                                                  ext_name).c_str();
-  }
-
-
 };
 
 #ifdef VM_TRACE

ndb/src/ndbapi/NdbLinHash.hpp

@@ -192,7 +192,7 @@ template <class C>
 inline
 Int32
 NdbLinHash<C>::insertKey( const char* str, Uint32 len, Uint32 lkey1, C* data )
-{
+{ 
   const Uint32 hash = Hash(str, len);
   int dir, seg;
   getBucket(hash, &dir, &seg);
@@ -219,8 +219,9 @@ NdbLinHash<C>::insertKey( const char* str, Uint32 len, Uint32 lkey1, C* data )
   chain->localkey1 = lkey1;
   chain->next = 0;
   chain->theData = data;
+  len++; // Null terminated
   chain->str = new Uint32[((len + 3) >> 2)];
-  memcpy( &chain->str[0], str, len );
+  memcpy( &chain->str[0], str, len);
   if (oldChain != 0) 
     oldChain->next = chain;
   else

ndb/src/ndbapi/NdbTransaction.cpp

@@ -25,7 +25,6 @@
 #include "TransporterFacade.hpp"
 #include "API.hpp"
 #include "NdbBlob.hpp"
-#include <ndb_limits.h>
 
 #include <signaldata/TcKeyConf.hpp>
 #include <signaldata/TcIndx.hpp>
@@ -1287,10 +1286,9 @@ NdbTransaction::getNdbIndexOperation(const char* anIndexName,
     {
       // This unique index is defined from SQL level
       static const char* uniqueSuffix= "$unique";
-      char uniqueIndexName[MAX_TAB_NAME_SIZE];
-
-      strxnmov(uniqueIndexName, MAX_TAB_NAME_SIZE, anIndexName, uniqueSuffix, NullS);
-      index = theNdb->theDictionary->getIndex(uniqueIndexName,
+      BaseString uniqueIndexName(anIndexName);
+      uniqueIndexName.append(uniqueSuffix);
+      index = theNdb->theDictionary->getIndex(uniqueIndexName.c_str(),
 					      aTableName);      
     }
     else

sql/ha_ndbcluster.cc

@@ -4709,7 +4709,7 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path,
   List_iterator_fast<char> it2(create_list);
   while ((file_name=it2++))
   {  
-    DBUG_PRINT("info", ("Table %s need discovery", name));
+    DBUG_PRINT("info", ("Table %s need discovery", file_name));
     if (ha_create_table_from_engine(thd, db, file_name, TRUE) == 0)
       files->push_back(thd->strdup(file_name)); 
   }