Merge tulin@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb

into poseidon.ndb.mysql.com:/home/tomas/mysql-5.0-ndb

ndb/src/common/util/Bitmask.cpp

@@ -17,6 +17,7 @@ void print(const Uint32 src[], Uint32 len, Uint32 pos = 0)
 }
 
 #ifndef __TEST_BITMASK__
+
 void
 BitmaskImpl::getFieldImpl(const Uint32 src[],
 			  unsigned shiftL, unsigned len, Uint32 dst[])
@@ -32,8 +33,15 @@ BitmaskImpl::getFieldImpl(const Uint32 src[],
     len -= 32;
   }
   
-  * dst++ |= (* src) << shiftL;
-  * dst = ((* src) >> shiftR) & ((1 << len) - 1) & undefined;
+  if(len < shiftR)
+  {
+    * dst |= ((* src) & ((1 << len) - 1)) << shiftL;
+  }
+  else
+  {
+    * dst++ |= ((* src) << shiftL);
+    * dst = ((* src) >> shiftR) & ((1 << (len - shiftR)) - 1) & undefined;
+  }
 }
 
 void
@@ -57,10 +65,16 @@ BitmaskImpl::setFieldImpl(Uint32 dst[],
   
   Uint32 mask = ((1 << len) -1);
   * dst = (* dst & ~mask);
-  * dst |= ((* src++) >> shiftL) & mask;
-  * dst |= ((* src) << shiftR) & mask & undefined;
+  if(len < shiftR)
+  {
+    * dst |= ((* src++) >> shiftL) & mask;
+  }
+  else
+  {
+    * dst |= ((* src++) >> shiftL);
+    * dst |= ((* src) & ((1 << (len - shiftR)) - 1)) << shiftR ;
+  }
 }
-
 #else
 
 #define DEBUG 0
@@ -121,7 +135,7 @@ static
 void rand(Uint32 dst[], Uint32 len)
 {
   for(int i = 0; i<len; i++)
-    BitmaskImpl::set((len + 31) >> 5, dst, i,  (lrand() % 1000) > 500);
+    BitmaskImpl::set((len + 31) >> 5, dst, i, (lrand() % 1000) > 500);
 }
 
 static
@@ -135,9 +149,9 @@ void simple(int pos, int size)
   const Uint32 sz = 4 * sz32;
   
   Uint32 zero = 0;
-  _mask.fill(sz32, zero);
-  _src.fill(sz32, zero);
-  _dst.fill(sz32, zero);
+  _mask.fill(sz32+1, zero);
+  _src.fill(sz32+1, zero);
+  _dst.fill(sz32+1, zero);
 
   Uint32 * src = _src.getBase();
   Uint32 * dst = _dst.getBase();
@@ -149,18 +163,18 @@ void simple(int pos, int size)
   rand(src, size);
   BitmaskImpl::setField(sz32, mask, pos, size, src);
   BitmaskImpl::getField(sz32, mask, pos, size, dst);
-  printf("src: "); print(src, size); printf("\n");
-  printf("msk: "); print(mask, sz32 << 5); printf("\n");
-  printf("dst: "); print(dst, size); printf("\n");
-  require(cmp(src, dst, size));
+  printf("src: "); print(src, size+31); printf("\n");
+  printf("msk: "); print(mask, (sz32 << 5) + 31); printf("\n");
+  printf("dst: "); print(dst, size+31); printf("\n");
+  require(cmp(src, dst, size+31));
 };
 
 static void 
 do_test(int bitmask_size)
 {
-#if 0
+#if 1
   simple(rand() % 33, (rand() % 63)+1);
-#else
+//#else
   Vector<Alloc> alloc_list;
   bitmask_size = (bitmask_size + 31) & ~31;
   Uint32 sz32 = (bitmask_size >> 5);
@@ -235,8 +249,10 @@ do_test(int bitmask_size)
 	    !BitmaskImpl::get(sz32, alloc_mask.getBase(), pos+free))
 	free++;
 
-      Uint32 sz = (lrand() % free); 
+      Uint32 sz = 
+	(free <= 64 && ((lrand() % 100) > 80)) ? free : (lrand() % free); 
       sz = sz ? sz : 1;
+      sz = pos + sz == bitmask_size ? sz - 1 : sz;
       Alloc a;
       a.pos = pos;
       a.size = sz;

ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp

@@ -1149,7 +1149,7 @@ Dbtup::updateBitsNULLable(Uint32* inBuffer,
 			  inBuffer+indexBuf+1);
     
     Uint32 newIndex = indexBuf + 1 + ((bitCount + 31) >> 5);
-    tInBufLen = newIndex;
+    tInBufIndex = newIndex;
     return true;
   } else {
     Uint32 newIndex = tInBufIndex + 1;

ndb/src/ndbapi/NdbDictionaryImpl.cpp

@@ -621,9 +621,11 @@ NdbDictionaryImpl::~NdbDictionaryImpl()
       delete NdbDictionary::Column::FRAGMENT; 
       delete NdbDictionary::Column::ROW_COUNT;
       delete NdbDictionary::Column::COMMIT_COUNT;
+      delete NdbDictionary::Column::ROW_SIZE;
       NdbDictionary::Column::FRAGMENT= 0;
       NdbDictionary::Column::ROW_COUNT= 0;
       NdbDictionary::Column::COMMIT_COUNT= 0;
+      NdbDictionary::Column::ROW_SIZE= 0;
     }
     m_globalHash->unlock();
   } else {
@@ -690,6 +692,8 @@ NdbDictionaryImpl::setTransporter(class Ndb* ndb,
 	NdbColumnImpl::create_psuedo("NDB$ROW_COUNT");
       NdbDictionary::Column::COMMIT_COUNT= 
 	NdbColumnImpl::create_psuedo("NDB$COMMIT_COUNT");
+      NdbDictionary::Column::ROW_SIZE=
+	NdbColumnImpl::create_psuedo("NDB$ROW_SIZE");
     }
     m_globalHash->unlock();
     return true;

ndb/test/include/HugoCalculator.hpp

@@ -38,7 +38,7 @@ public:
   float calcValue(int record, int attrib, int updates) const;
   double calcValue(int record, int attrib, int updates) const;
 #endif
-  const char* calcValue(int record, int attrib, int updates, char* buf) const;
+  const char* calcValue(int record, int attrib, int updates, char* buf, int len) const;
 
   int verifyRowValues(NDBT_ResultRow* const  pRow) const;
   int getIdValue(NDBT_ResultRow* const pRow) const;

ndb/test/ndbapi/testBitfield.cpp

@@ -3,6 +3,7 @@
 #include <ndb_opts.h>
 #include <NDBT.hpp>
 #include <NdbApi.hpp>
+#include <HugoTransactions.hpp>
 
 static const char* opt_connect_str= 0;
 static const char* _dbname = "TEST_DB";
@@ -129,13 +130,61 @@ static
 const NdbDictionary::Table* 
 create_random_table(Ndb* pNdb)
 {
+  NdbDictionary::Table tab;
+  Uint32 cols = 1 + (rand() % (NDB_MAX_ATTRIBUTES_IN_TABLE - 1));
+  Uint32 keys = NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY;
+  Uint32 length = 4096;
+  Uint32 key_size = NDB_MAX_KEYSIZE_IN_WORDS;
+  
+  BaseString name; 
+  name.assfmt("TAB_%d", rand() & 65535);
+  tab.setName(name.c_str());
+  for(int i = 0; i<cols && length > 0; i++)
+  {
+    NdbDictionary::Column col;
+    name.assfmt("COL_%d", i);
+    col.setName(name.c_str());
+    if(i == 0 || i == 1)
+    {
+      col.setType(NdbDictionary::Column::Unsigned);
+      col.setLength(1); 
+      col.setNullable(false);
+      col.setPrimaryKey(i == 0);
+      tab.addColumn(col);
+      continue;
+    }
+
+    col.setType(NdbDictionary::Column::Bit);
+    
+    Uint32 len = 1 + (rand() % 128); //(length - 1));
+    col.setLength(len); length -= len;
+    col.setNullable((rand() >> 16) & 1);
+    col.setPrimaryKey(false);
+    tab.addColumn(col);
+  }
+
+  ndbout << (NDBT_Table&)tab << endl;
+  if(pNdb->getDictionary()->createTable(tab) == 0)
+  {
+    return pNdb->getDictionary()->getTable(tab.getName());
+  }
   return 0;
 }
+
 static 
 int
 transactions(Ndb* pNdb, const NdbDictionary::Table* tab)
 {
-  return 0;
+  int i = 0;
+  HugoTransactions trans(* tab);
+  i |= trans.loadTable(pNdb, 1000);
+  i |= trans.pkReadRecords(pNdb, 1000, 13); 
+  i |= trans.scanReadRecords(pNdb, 1000, 25);
+  i |= trans.pkUpdateRecords(pNdb, 1000, 37);
+  i |= trans.scanUpdateRecords(pNdb, 1000, 25);
+  i |= trans.pkDelRecords(pNdb, 500, 23);
+  i |= trans.clearTable(pNdb);
+  return i;
 }
 
 static 

ndb/test/src/HugoCalculator.cpp

@@ -85,17 +85,16 @@ const char*
 HugoCalculator::calcValue(int record, 
 			  int attrib, 
 			  int updates, 
-			  char* buf) const {
+			  char* buf,
+			  int len) const {
   const char a[26] = {"UAWBORCTDPEFQGNYHISJMKXLZ"};
   const NdbDictionary::Column* attr = m_tab.getColumn(attrib);
   int val = calcValue(record, attrib, updates);
 
-  int len;
   if (attr->getPrimaryKey()){
     // Create a string where val is printed as chars in the beginning
     // of the string, then fill with other chars
     // The string length is set to the same size as the attribute
-    len = attr->getLength();
     BaseString::snprintf(buf, len, "%d", val);
     for(int i=strlen(buf); i < len; i++)
       buf[i] = a[((val^i)%25)]; 
@@ -104,13 +103,19 @@ HugoCalculator::calcValue(int record,
     // Fill buf with some pattern so that we can detect
     // anomalies in the area that we don't fill with chars
     int i;
-    for (i = 0; i<attr->getLength(); i++)
+    for (i = 0; i<len; i++)
       buf[i] = ((i+2) % 255);
     
     // Calculate length of the string to create. We want the string 
     // length to be varied between max and min of this attribute.
+    Uint32 org = len;
 
-    len = val % (attr->getLength() + 1);
+    if(attr->getType() == NdbDictionary::Column::Varchar)
+      len = val % (len + 1);
+    else
+      if((val % (len + 1)) == 0)
+	len = 0;
+    
     // If len == 0 return NULL if this is a nullable attribute
     if (len == 0){
       if(attr->getNullable() == true)
@@ -121,6 +126,14 @@ HugoCalculator::calcValue(int record,
     for(i=0; i < len; i++)
       buf[i] = a[((val^i)%25)];
     buf[len] = 0;
+
+    if(attr->getType() == NdbDictionary::Column::Bit)
+    {
+      Uint32 bits= attr->getLength();
+      Uint32 pos = bits >> 5;
+      Uint32 size = bits & 31;
+      ((Uint32*)buf)[pos] &= ((1 << size) - 1);
+    }
   }
   return buf;
 }; 
@@ -131,7 +144,8 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 
   id = pRow->attributeStore(m_idCol)->u_32_value();
   updates = pRow->attributeStore(m_updatesCol)->u_32_value();
-
+  int result = 0;	  
+  
   // Check the values of each column
   for (int i = 0; i<m_tab.getNoOfColumns(); i++){
     if (i != m_updatesCol && id != m_idCol) {
@@ -145,9 +159,8 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
       case NdbDictionary::Column::Varchar:
       case NdbDictionary::Column::Binary:
       case NdbDictionary::Column::Varbinary:{
-	int result = 0;	  
 	char* buf = new char[len+1];
-	const char* res = calcValue(id, i, updates, buf);
+	const char* res = calcValue(id, i, updates, buf, len);
 	if (res == NULL){
 	  if (!pRow->attributeStore(i)->isNULL()){
 	    g_err << "|- NULL ERROR: expected a NULL but the column was not null" << endl;
@@ -155,16 +168,13 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 	    result = -1;
 	  }
 	} else{
-	  if (memcmp(res, pRow->attributeStore(i)->aRef(), pRow->attributeStore(i)->arraySize()) != 0){
+	  if (memcmp(res, pRow->attributeStore(i)->aRef(), len) != 0){
 	    //	  if (memcmp(res, pRow->attributeStore(i)->aRef(), pRow->attributeStore(i)->getLength()) != 0){
-	    g_err << "arraySize(): " 
-		   << pRow->attributeStore(i)->arraySize()
-		   << ", NdbDict::Column::getLength(): " << attr->getLength()
-		   << endl;
+	    g_err << "Column: " << attr->getName() << endl;
 	    const char* buf2 = pRow->attributeStore(i)->aRef();
-	    for (Uint32 j = 0; j < pRow->attributeStore(i)->arraySize(); j++)
+	    for (Uint32 j = 0; j < len; j++)
 	    {
-	      g_err << j << ":" << buf[j] << "[" << buf2[j] << "]";
+	      g_err << j << ":" << hex << (int)buf[j] << "[" << hex << (int)buf2[j] << "]";
 	      if (buf[j] != buf2[j])
 	      {
 		g_err << "==>Match failed!";
@@ -173,7 +183,7 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 	    }
 	    g_err << endl;
 	    g_err << "|- Invalid data found in attribute " << i << ": \""
-		   << pRow->attributeStore(i)->aRef()
+		  << pRow->attributeStore(i)->aRef()
 		  << "\" != \"" << res << "\"" << endl
 		  << "Length of expected=" << (unsigned)strlen(res) << endl
 		  << "Lenght of read="
@@ -183,7 +193,6 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 	  }
 	}
 	delete []buf;
-	return result;
       }
 	break;
       case NdbDictionary::Column::Int:
@@ -194,9 +203,9 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 	  g_err << "|- Invalid data found: \"" << val << "\" != \"" 
 		<< cval << "\"" << endl;
 	  g_err << "|- The row: \"" << (* pRow) << "\"" << endl;
-	  return -1;
+	  result = -1;
 	}
-	return 0;
+	break;
       }
       case NdbDictionary::Column::Bigint:
       case NdbDictionary::Column::Bigunsigned:{
@@ -207,9 +216,8 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 		<< cval << "\"" 
 		<< endl;
 	  g_err << "|- The row: \"" << (* pRow) << "\"" << endl;
-	  return -1;
+	  result = -1;
 	}
-	return 0;
       }
 	break;
       case NdbDictionary::Column::Float:{
@@ -217,20 +225,21 @@ HugoCalculator::verifyRowValues(NDBT_ResultRow* const  pRow) const{
 	float val = pRow->attributeStore(i)->float_value();
 	if (val != cval){
 	  g_err << "|- Invalid data found: \"" << val << "\" != \"" 
-		 << cval << "\"" << endl;
+		<< cval << "\"" << endl;
 	  g_err << "|- The row: \"" << (* pRow) << "\"" << endl;
-	  return -1;
+	  result = -1;
 	}
-	return 0;
       }
 	break;
       case NdbDictionary::Column::Undefined:
+      default:
+	assert(0);
+	result = -1;
 	break;
       }
     }
   }
-  assert(0);
-  return -1;
+  return result;
 }
 
 int

ndb/test/src/HugoOperations.cpp

@@ -414,15 +414,18 @@ int HugoOperations::equalForAttr(NdbOperation* pOp,
     return NDBT_FAILED;
   }
     
+  int len = attr->getLength();
   switch (attr->getType()){
   case NdbDictionary::Column::Bit:
+    len = 4 * ((len + 31) >> 5);
   case NdbDictionary::Column::Char:
   case NdbDictionary::Column::Varchar:
   case NdbDictionary::Column::Binary:
   case NdbDictionary::Column::Varbinary:{
     char buf[8000];
     memset(buf, 0, sizeof(buf));
-    check = pOp->equal( attr->getName(), calc.calcValue(rowId, attrId, 0, buf));
+    check = pOp->equal( attr->getName(), 
+			calc.calcValue(rowId, attrId, 0, buf, len));
     break;
   }
   case NdbDictionary::Column::Int:
@@ -451,16 +454,18 @@ int HugoOperations::setValueForAttr(NdbOperation* pOp,
 				      int updateId){
   int check = -1;
   const NdbDictionary::Column* attr = tab.getColumn(attrId);     
-
+  
+  int len = attr->getLength();
   switch (attr->getType()){
   case NdbDictionary::Column::Bit:
+    len = 4 * ((len + 31) >> 5);
   case NdbDictionary::Column::Char:
   case NdbDictionary::Column::Varchar:
   case NdbDictionary::Column::Binary:
   case NdbDictionary::Column::Varbinary:{
     char buf[8000];
     check = pOp->setValue( attr->getName(), 
-			   calc.calcValue(rowId, attrId, updateId, buf));
+			   calc.calcValue(rowId, attrId, updateId, buf, len));
     break;
   }
   case NdbDictionary::Column::Int:{

ndb/test/tools/Makefile.am

 
-ndbtest_PROGRAMS = hugoCalculator hugoLoad hugoFill hugoLockRecords hugoPkDelete hugoPkRead hugoPkReadRecord  hugoPkUpdate hugoScanRead hugoScanUpdate restart verify_index copy_tab create_index  ndb_cpcc
+ndbtest_PROGRAMS = hugoLoad hugoFill hugoLockRecords hugoPkDelete hugoPkRead hugoPkReadRecord  hugoPkUpdate hugoScanRead hugoScanUpdate restart verify_index copy_tab create_index  ndb_cpcc
 
 # transproxy