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

 - Fix several valgrind warnings.


ndb/include/kernel/AttributeList.hpp:
  Include ndb_limits.h
ndb/include/ndbapi/Ndb.hpp:
  Add new function internalize_table_name
  Proper formatting
ndb/include/util/SimpleProperties.hpp:
  Add function "add" for adding strings/data to word buffers without reading after the string/data 
  Fix comment for UtilBufferWriter
ndb/src/common/util/SimpleProperties.cpp:
  Add function "add" for adding strings/data to word buffers without reading after the string/data
ndb/src/ndbapi/DictCache.cpp:
  Add DBUG printouts to all functions in GlobalDictCache
  Change ndbout_c to DBUG_PRINT
  Add function GlobalDictCache::printCache
ndb/src/ndbapi/DictCache.hpp:
  Add function GlobalDictCache::printCache
ndb/src/ndbapi/Ndb.cpp:
  Change DEBUG_TRACE to DBUG_PRINT, DBUG_ENTER
  Use new function internalize_table_name, and create internal tabname on stack
ndb/src/ndbapi/NdbDictionary.cpp:
  Add DBUG_ENTER calls
ndb/src/ndbapi/NdbDictionaryImpl.cpp:
  Pass BaseString as reference when passing internal table name to internal functions.
  Remove check for exceeding MAX_SECTION_SIZE.
  Remove pekkas fix that saves internalName in save_me variable, not needed when tablename is stack variable.
  NdbDictInterface::gettable(int tableid, ...) - Not used
ndb/src/ndbapi/NdbDictionaryImpl.hpp:
  Remove include of ndb_limits.h
  Use BaseString& for internal functions
  Remove m_namebuf, not needed, uses m_buffer
  Formatting
  NdbDictInterface::getTable(int tableId, ...) - Not used
ndb/src/ndbapi/NdbImpl.hpp:
  Remove buffer for m_internalname, placed on stack of caller.
  Moved impl of internalize_table_name and internalize_index_anme to Ndb::internalize_table_name and Ndb::internalize_index_name
ndb/src/ndbapi/NdbLinHash.hpp:
  Save also the terminating null character in chain->str to get nicer printouts.
ndb/src/ndbapi/NdbTransaction.cpp:
  Remove hardcoded buffer sizes.
  Remove include of ndb_limits.h
sql/ha_ndbcluster.cc:
  Fix "typo", use file_name var since that is the current files name,

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;
@@ -47,8 +69,8 @@ SimpleProperties::Writer::add(Uint16 key, const char * value){
   if(!putWord(htonl(strLen)))
     return false;
 
-  const Uint32 valLen = (strLen + 3) / 4;
-  return putWords((Uint32*)value, valLen);
+  return add(value, (int)strLen);
+
 }
 
 bool
@@ -61,8 +83,7 @@ SimpleProperties::Writer::add(Uint16 key, const void* value, int len){
   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,18 +96,50 @@ 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 *
 GlobalDictCache::get(const char * name)
 {
+  DBUG_ENTER("GlobalDictCache::get");
+  DBUG_PRINT("enter", ("name: %s", name));
+
   const Uint32 len = strlen(name);
   Vector<TableVersion> * versions = 0;
   versions = m_tableHash.getData(name, len);
@@ -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,26 +218,29 @@ 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(); 
   }
 
@@ -207,46 +249,53 @@ GlobalDictCache::drop(NdbTableImpl * tab)
     if(ver.m_impl == tab){
       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
 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.cpp

@@ -735,19 +735,19 @@ NdbDictionaryImpl::~NdbDictionaryImpl()
 }
 
 Ndb_local_table_info *
-NdbDictionaryImpl::fetchGlobalTableImpl(const char * internalTableName)
+NdbDictionaryImpl::fetchGlobalTableImpl(const BaseString& internalTableName)
 {
   NdbTableImpl *impl;
 
   m_globalHash->lock();
-  impl = m_globalHash->get(internalTableName);
+  impl = m_globalHash->get(internalTableName.c_str());
   m_globalHash->unlock();
 
   if (impl == 0){
     impl = m_receiver.getTable(internalTableName,
 			       m_ndb.usingFullyQualifiedNames());
     m_globalHash->lock();
-    m_globalHash->put(internalTableName, impl);
+    m_globalHash->put(internalTableName.c_str(), impl);
     m_globalHash->unlock();
     
     if(impl == 0){
@@ -758,7 +758,7 @@ NdbDictionaryImpl::fetchGlobalTableImpl(const char * internalTableName)
   Ndb_local_table_info *info=
     Ndb_local_table_info::create(impl, m_local_table_data_size);
 
-  m_localHash.put(internalTableName, info);
+  m_localHash.put(internalTableName.c_str(), info);
 
   m_ndb.theFirstTupleId[impl->getTableId()] = ~0;
   m_ndb.theLastTupleId[impl->getTableId()]  = ~0;
@@ -810,10 +810,9 @@ NdbTableImpl *
 NdbDictionaryImpl::getIndexTable(NdbIndexImpl * index,
 				 NdbTableImpl * table)
 {
-  const char * internalName = 
-    m_ndb.internalizeIndexName(table, index->getName());
-  
-  return getTable(m_ndb.externalizeTableName(internalName));
+  const BaseString internalName(
+    m_ndb.internalize_index_name(table, index->getName()));
+  return getTable(m_ndb.externalizeTableName(internalName.c_str()));
 }
 
 #if 0
@@ -1055,7 +1054,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* signal,
   }
   DBUG_RETURN(-1);
 }
-
+#if 0
 /*
   Get dictionary information for a table using table id as reference
 
@@ -1079,6 +1078,7 @@ NdbDictInterface::getTable(int tableId, bool fullyQualifiedNames)
 
   return getTable(&tSignal, 0, 0, fullyQualifiedNames);
 }
+#endif
 
 
 /*
@@ -1090,36 +1090,31 @@ NdbDictInterface::getTable(int tableId, bool fullyQualifiedNames)
 */
 
 NdbTableImpl *
-NdbDictInterface::getTable(const char * name, bool fullyQualifiedNames)
+NdbDictInterface::getTable(const BaseString& name, bool fullyQualifiedNames)
 {
   NdbApiSignal tSignal(m_reference);
   GetTabInfoReq* const req = CAST_PTR(GetTabInfoReq, tSignal.getDataPtrSend());
 
-  const Uint32 str_len= strlen(name) + 1; // NULL terminated
-  const Uint32 str_len_words= (str_len + 3) / 4; // Size in words
-
-  if (str_len > MAX_SECTION_SIZE)
-  {
-    m_error.code= 4307;
-    return 0;
-  }
-
-  m_namebuf.clear();
-  m_namebuf.grow(str_len_words*4); // Word size aligned number of bytes
-  m_namebuf.append(name, str_len);
+  const Uint32 namelen= name.length() + 1; // NULL terminated
+  const Uint32 namelen_words= (namelen + 3) >> 2; // Size in words
 
   req->senderRef= m_reference;
   req->senderData= 0;
   req->requestType=
     GetTabInfoReq::RequestByName | GetTabInfoReq::LongSignalConf;
-  req->tableNameLen= str_len;
+  req->tableNameLen= namelen;
   tSignal.theReceiversBlockNumber= DBDICT;
   tSignal.theVerId_signalNumber= GSN_GET_TABINFOREQ;
   tSignal.theLength= GetTabInfoReq::SignalLength;
 
+  // Copy name to m_buffer to get a word sized buffer
+  m_buffer.clear();
+  m_buffer.grow(namelen_words*4);
+  m_buffer.append(name.c_str(), namelen);
+
   LinearSectionPtr ptr[1];
-  ptr[0].p= (Uint32*)m_namebuf.get_data();
-  ptr[0].sz= str_len_words; 
+  ptr[0].p= (Uint32*)m_buffer.get_data();
+  ptr[0].sz= namelen_words;
 
   return getTable(&tSignal, ptr, 1, fullyQualifiedNames);
 }
@@ -1463,7 +1458,7 @@ NdbDictionaryImpl::createTable(NdbTableImpl &t)
     return 0;
   // update table def from DICT
   Ndb_local_table_info *info=
-    get_local_table_info(t.m_internalName.c_str(),false);
+    get_local_table_info(t.m_internalName,false);
   if (info == NULL) {
     m_error.code= 709;
     return -1;
@@ -1490,7 +1485,7 @@ NdbDictionaryImpl::createBlobTables(NdbTableImpl &t)
       return -1;
     // Save BLOB table handle
     Ndb_local_table_info *info=
-      get_local_table_info(bt.m_internalName.c_str(), false);
+      get_local_table_info(bt.m_internalName, false);
     if (info == 0) {
       return -1;
     }
@@ -1534,12 +1529,11 @@ NdbDictInterface::createTable(Ndb & ndb,
 
 int NdbDictionaryImpl::alterTable(NdbTableImpl &impl)
 {
-  BaseString internalName = impl.m_internalName;
+  BaseString internalName(impl.m_internalName);
   const char * originalInternalName = internalName.c_str();
-  BaseString externalName = impl.m_externalName;
 
   DBUG_ENTER("NdbDictionaryImpl::alterTable");
-  if(!get_local_table_info(originalInternalName, false)){
+  if(!get_local_table_info(internalName, false)){
     m_error.code= 709;
     DBUG_RETURN(-1);
   }
@@ -1594,14 +1588,14 @@ NdbDictInterface::createOrAlterTable(Ndb & ndb,
   //validate();
   //aggregate();
 
-  const char * internalName = 
-    ndb.internalizeTableName(impl.m_externalName.c_str());
+  const BaseString internalName(
+    ndb.internalize_table_name(impl.m_externalName.c_str()));
   impl.m_internalName.assign(internalName);
   UtilBufferWriter w(m_buffer);
   DictTabInfo::Table tmpTab; tmpTab.init();
   BaseString::snprintf(tmpTab.TableName,
 	   sizeof(tmpTab.TableName),
-	   internalName);
+	   internalName.c_str());
 
   bool haveAutoIncrement = false;
   Uint64 autoIncrementValue = 0;
@@ -1859,10 +1853,10 @@ NdbDictionaryImpl::dropTable(const char * name)
   // If table stored in cache is incompatible with the one in the kernel
   // we must clear the cache and try again
   if (ret == INCOMPATIBLE_VERSION) {
-    const char * internalTableName = m_ndb.internalizeTableName(name);
+    const BaseString internalTableName(m_ndb.internalize_table_name(name));
 
-    DBUG_PRINT("info",("INCOMPATIBLE_VERSION internal_name: %s", internalTableName));
-    m_localHash.drop(internalTableName);
+    DBUG_PRINT("info",("INCOMPATIBLE_VERSION internal_name: %s", internalTableName.c_str()));
+    m_localHash.drop(internalTableName.c_str());
     m_globalHash->lock();
     tab->m_status = NdbDictionary::Object::Invalid;
     m_globalHash->drop(tab);
@@ -2007,13 +2001,14 @@ int
 NdbDictionaryImpl::invalidateObject(NdbTableImpl & impl)
 {
   const char * internalTableName = impl.m_internalName.c_str();
-
+  DBUG_ENTER("NdbDictionaryImpl::invalidateObject");
+  DBUG_PRINT("enter", ("internal_name: %s", internalTableName));
   m_localHash.drop(internalTableName);
   m_globalHash->lock();
   impl.m_status = NdbDictionary::Object::Invalid;
   m_globalHash->drop(&impl);
   m_globalHash->unlock();
-  return 0;
+  DBUG_RETURN(0);
 }
 
 int
@@ -2033,7 +2028,7 @@ NdbDictionaryImpl::removeCachedObject(NdbTableImpl & impl)
  */
 NdbIndexImpl*
 NdbDictionaryImpl::getIndexImpl(const char * externalName,
-				const char * internalName)
+				const BaseString& internalName)
 {
   Ndb_local_table_info * info = get_local_table_info(internalName,
 						     false);
@@ -2049,21 +2044,11 @@ NdbDictionaryImpl::getIndexImpl(const char * externalName,
     return 0;
   }
 
-  /*
-   * internalName may be pointer to m_ndb.theImpl->m_internalname.c_str()
-   * and may get deallocated in next call.
-   *
-   * Passing around pointers to volatile internal members may not be
-   * optimal.  Suggest use BaseString instances passed by value.
-   */
-
-  BaseString save_me(internalName);
   NdbTableImpl* prim = getTable(tab->m_primaryTable.c_str());
   if(prim == 0){
     m_error.code = 4243;
     return 0;
   }
-  internalName = save_me.c_str();
 
   /**
    * Create index impl
@@ -2169,12 +2154,11 @@ NdbDictInterface::createIndex(Ndb & ndb,
     m_error.code = 4241;
     return -1;
   }
-  const char * internalName = 
-    ndb.internalizeIndexName(&table, impl.getName());
-  
+  const BaseString internalName(
+    ndb.internalize_index_name(&table, impl.getName()));
   impl.m_internalName.assign(internalName);
 
-  w.add(DictTabInfo::TableName, internalName);
+  w.add(DictTabInfo::TableName, internalName.c_str());
   w.add(DictTabInfo::TableLoggedFlag, impl.m_logging);
 
   NdbApiSignal tSignal(m_reference);
@@ -2280,13 +2264,13 @@ NdbDictionaryImpl::dropIndex(const char * indexName,
   // If index stored in cache is incompatible with the one in the kernel
   // we must clear the cache and try again
   if (ret == INCOMPATIBLE_VERSION) {
-    const char * internalIndexName = (tableName)
+    const BaseString internalIndexName((tableName)
       ?
-      m_ndb.internalizeIndexName(getTable(tableName), indexName)
+      m_ndb.internalize_index_name(getTable(tableName), indexName)
       :
-      m_ndb.internalizeTableName(indexName); // Index is also a table
+      m_ndb.internalize_table_name(indexName)); // Index is also a table
 
-    m_localHash.drop(internalIndexName);
+    m_localHash.drop(internalIndexName.c_str());
     m_globalHash->lock();
     idx->m_table->m_status = NdbDictionary::Object::Invalid;
     m_globalHash->drop(idx->m_table);
@@ -2309,11 +2293,11 @@ NdbDictionaryImpl::dropIndex(NdbIndexImpl & impl, const char * tableName)
       return -1;
     }
 
-    const char * internalIndexName = (tableName)
+    const BaseString internalIndexName((tableName)
       ?
-      m_ndb.internalizeIndexName(getTable(tableName), indexName)
+      m_ndb.internalize_index_name(getTable(tableName), indexName)
       :
-      m_ndb.internalizeTableName(indexName); // Index is also a table
+      m_ndb.internalize_table_name(indexName)); // Index is also a table
 
     if(impl.m_status == NdbDictionary::Object::New){
       return dropIndex(indexName, tableName);
@@ -2321,7 +2305,7 @@ NdbDictionaryImpl::dropIndex(NdbIndexImpl & impl, const char * tableName)
 
     int ret = m_receiver.dropIndex(impl, *timpl);
     if(ret == 0){
-      m_localHash.drop(internalIndexName);
+      m_localHash.drop(internalIndexName.c_str());
       m_globalHash->lock();
       impl.m_table->m_status = NdbDictionary::Object::Invalid;
       m_globalHash->drop(impl.m_table);
@@ -2526,8 +2510,12 @@ NdbDictInterface::createEvent(class Ndb & ndb,
   w.add(SimpleProperties::StringValue, evnt.m_externalName.c_str());
 
   if (getFlag == 0)
+  {
+    const BaseString internal_tabname(
+      ndb.internalize_table_name(evnt.m_tableName.c_str()));
     w.add(SimpleProperties::StringValue,
-	  ndb.internalizeTableName(evnt.m_tableName.c_str()));
+	 internal_tabname.c_str());
+  }
 
   LinearSectionPtr ptr[1];
   ptr[0].p = (Uint32*)m_buffer.get_data();

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 {
@@ -408,11 +405,10 @@ public:
   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
@@ -639,25 +637,26 @@ NdbDictionaryImpl::getImpl(const NdbDictionary::Dictionary & t){
 
 inline
 NdbTableImpl *
-NdbDictionaryImpl::getTable(const char * tableName, void **data)
+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

@@ -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)); 
   }