Merge mysql.com:/space/pekka/ndb/version/my50

into  mysql.com:/space/pekka/ndb/version/my50-bug14509


ndb/src/ndbapi/DictCache.cpp:
  Auto merged
ndb/src/ndbapi/DictCache.hpp:
  Auto merged
sql/ha_ndbcluster.cc:
  Auto merged

mysql-test/r/ndb_alter_table.result

-DROP TABLE IF EXISTS t1;
+DROP TABLE IF EXISTS t1, t2;
 drop database if exists mysqltest;
 CREATE TABLE t1 (
 a INT NOT NULL,
@@ -315,3 +315,24 @@ unique key tx1 (c002, c003, c004, c005)) engine=ndb;
 create index tx2 
 on t1 (c010, c011, c012, c013);
 drop table t1;
+create table t1 (a int primary key auto_increment, b int) engine=ndb;
+insert into t1 (b) values (101),(102),(103);
+select * from t1 where a = 3;
+a	b
+3	103
+alter table t1 rename t2;
+insert into t2 (b) values (201),(202),(203);
+select * from t2 where a = 6;
+a	b
+6	203
+alter table t2 add c int;
+insert into t2 (b) values (301),(302),(303);
+select * from t2 where a = 9;
+a	b	c
+9	303	NULL
+alter table t2 rename t1;
+insert into t1 (b) values (401),(402),(403);
+select * from t1 where a = 12;
+a	b	c
+12	403	NULL
+drop table t1;

mysql-test/t/ndb_alter_table.test

@@ -3,7 +3,7 @@
 -- source include/not_embedded.inc
 
 --disable_warnings
-DROP TABLE IF EXISTS t1;
+DROP TABLE IF EXISTS t1, t2;
 drop database if exists mysqltest;
 --enable_warnings
 
@@ -326,5 +326,20 @@ on t1 (c010, c011, c012, c013);
 
 drop table t1;
 
+# simple test that auto incr is not lost at rename or alter
+create table t1 (a int primary key auto_increment, b int) engine=ndb;
+insert into t1 (b) values (101),(102),(103);
+select * from t1 where a = 3;
+alter table t1 rename t2;
+insert into t2 (b) values (201),(202),(203);
+select * from t2 where a = 6;
+alter table t2 add c int;
+insert into t2 (b) values (301),(302),(303);
+select * from t2 where a = 9;
+alter table t2 rename t1;
+insert into t1 (b) values (401),(402),(403);
+select * from t1 where a = 12;
+drop table t1;
+
 # End of 4.1 tests
 

ndb/include/ndbapi/Ndb.hpp

@@ -984,6 +984,7 @@ class BaseString;
 class NdbEventOperation;
 class NdbBlob;
 class NdbReceiver;
+class Ndb_local_table_info;
 template <class T> struct Ndb_free_list_t;
 
 typedef void (* NdbEventCallback)(NdbEventOperation*, Ndb*, void*);
@@ -1431,27 +1432,29 @@ public:
    *
    * @param cacheSize number of values to cache in this Ndb object
    *
-   * @return tuple id or 0 on error
+   * @return 0 or -1 on error, and tupleId in out parameter
    */
-  Uint64 getAutoIncrementValue(const char* aTableName, 
-			       Uint32 cacheSize = 1);
-  Uint64 getAutoIncrementValue(const NdbDictionary::Table * aTable, 
-			       Uint32 cacheSize = 1);
-  Uint64 readAutoIncrementValue(const char* aTableName);
-  Uint64 readAutoIncrementValue(const NdbDictionary::Table * aTable);
-  bool setAutoIncrementValue(const char* aTableName, Uint64 val, 
-			     bool increase = false);
-  bool setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, 
-			     bool increase = false);
-  Uint64 getTupleIdFromNdb(const char* aTableName, 
-			   Uint32 cacheSize = 1000);
-  Uint64 getTupleIdFromNdb(Uint32 aTableId, 
-			   Uint32 cacheSize = 1000);
-  Uint64 readTupleIdFromNdb(Uint32 aTableId);
-  bool setTupleIdInNdb(const char* aTableName, Uint64 val, 
-		       bool increase);
-  bool setTupleIdInNdb(Uint32 aTableId, Uint64 val, bool increase);
-  Uint64 opTupleIdOnNdb(Uint32 aTableId, Uint64 opValue, Uint32 op);
+  int getAutoIncrementValue(const char* aTableName, 
+                            Uint64 & tupleId, Uint32 cacheSize);
+  int getAutoIncrementValue(const NdbDictionary::Table * aTable, 
+                            Uint64 & tupleId, Uint32 cacheSize);
+  int readAutoIncrementValue(const char* aTableName,
+                             Uint64 & tupleId);
+  int readAutoIncrementValue(const NdbDictionary::Table * aTable,
+                             Uint64 & tupleId);
+  int setAutoIncrementValue(const char* aTableName,
+                            Uint64 tupleId, bool increase);
+  int setAutoIncrementValue(const NdbDictionary::Table * aTable,
+                            Uint64 tupleId, bool increase);
+private:
+  int getTupleIdFromNdb(Ndb_local_table_info* info,
+                        Uint64 & tupleId, Uint32 cacheSize);
+  int readTupleIdFromNdb(Ndb_local_table_info* info,
+                         Uint64 & tupleId);
+  int setTupleIdInNdb(Ndb_local_table_info* info,
+                      Uint64 tupleId, bool increase);
+  int opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 & opValue, Uint32 op);
+public:
 
   /**
    */
@@ -1651,11 +1654,6 @@ private:
   Uint64               the_last_check_time;
   Uint64               theFirstTransId;
 
-  // The tupleId is retreived from DB the 
-  // tupleId is unique for each tableid. 
-  Uint64               theFirstTupleId[2048]; 
-  Uint64               theLastTupleId[2048];           
-
   Uint32		theRestartGCI;	// the Restart GCI used by DIHNDBTAMPER
   
   NdbError              theError;

ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp

@@ -1607,10 +1607,9 @@ void Ndbcntr::systemErrorLab(Signal* signal, int line)
 /*       |-2048| # 1 00000001    |                                           */
 /*       |  :  |   :             |                                           */
 /*       | -1  | # 1 00000001    |                                           */
-/*       |  0  |   0             |                                           */
-/*       |  1  |   0             |                                           */
-/*       |  :  |   :             |                                           */
-/*       | 2047|   0             |                                           */
+/*       |  1  |   0             | tupleid sequence now created on first use */
+/*       |  :  |   :             |                   v                       */
+/*       | 2048|   0             |                   v                       */
 /*---------------------------------------------------------------------------*/
 void Ndbcntr::createSystableLab(Signal* signal, unsigned index)
 {
@@ -1819,8 +1818,7 @@ void Ndbcntr::crSystab8Lab(Signal* signal)
     jam();
     ckey = 1;
     ctransidPhase = ZFALSE;
-    crSystab7Lab(signal);
-    return;
+    // skip 2nd loop - tupleid sequence now created on first use
   }//if
   signal->theData[0] = ctcConnectionP;
   signal->theData[1] = reference();

ndb/src/ndbapi/DictCache.cpp

@@ -45,6 +45,8 @@ void Ndb_local_table_info::destroy(Ndb_local_table_info *info)
 Ndb_local_table_info::Ndb_local_table_info(NdbTableImpl *table_impl)
 {
   m_table_impl= table_impl;
+  m_first_tuple_id = ~(Uint64)0;
+  m_last_tuple_id = ~(Uint64)0;
 }
 
 Ndb_local_table_info::~Ndb_local_table_info()

ndb/src/ndbapi/DictCache.hpp

@@ -33,6 +33,11 @@ public:
   static Ndb_local_table_info *create(NdbTableImpl *table_impl, Uint32 sz=0);
   static void destroy(Ndb_local_table_info *);
   NdbTableImpl *m_table_impl;
+
+  // range of cached tuple ids per thread
+  Uint64 m_first_tuple_id;
+  Uint64 m_last_tuple_id;
+
   Uint64 m_local_data[1]; // Must be last member. Used to access extra space.
 private:
   Ndb_local_table_info(NdbTableImpl *table_impl);

ndb/src/ndbapi/NdbDictionaryImpl.cpp

@@ -759,10 +759,6 @@ NdbDictionaryImpl::fetchGlobalTableImpl(const BaseString& internalTableName)
     Ndb_local_table_info::create(impl, m_local_table_data_size);
 
   m_localHash.put(internalTableName.c_str(), info);
-
-  m_ndb.theFirstTupleId[impl->getTableId()] = ~0;
-  m_ndb.theLastTupleId[impl->getTableId()]  = ~0;
-  
   return info;
 }
 
@@ -1746,14 +1742,11 @@ NdbDictInterface::createOrAlterTable(Ndb & ndb,
       DBUG_RETURN(ret);
 
     if (haveAutoIncrement) {
-      if (!ndb.setAutoIncrementValue(impl.m_externalName.c_str(),
-				     autoIncrementValue)) {
-	if (ndb.theError.code == 0) {
-	  m_error.code= 4336;
-	  ndb.theError = m_error;
-	} else
+      if (ndb.setAutoIncrementValue(impl.m_externalName.c_str(),
+				    autoIncrementValue, false) == -1) {
+        DBUG_ASSERT(ndb.theError.code != 0);
         m_error= ndb.theError;
-	ret = -1; // errorcode set in initialize_autoincrement
+	ret = -1;
       }
     }
   }

ndb/src/ndbapi/Ndbinit.cpp

@@ -96,10 +96,6 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
   for (i = 0; i < MAX_NDB_NODES ; i++) {
     theConnectionArray[i] = NULL;
   }//forg
-  for (i = 0; i < 2048 ; i++) {
-    theFirstTupleId[i] = 0;
-    theLastTupleId[i] = 0;
-  }//for
 
   theImpl->m_dbname.assign(aDataBase);
   theImpl->m_schemaname.assign(aSchema);

ndb/test/ndbapi/testDict.cpp

@@ -1139,9 +1139,13 @@ runCreateAutoincrementTable(NDBT_Context* ctx, NDBT_Step* step){
 
     for (int i = 0; i < 16; i++) {
 
-      Uint64 value = myNdb->getAutoIncrementValue(tabname, 1);
-
-      if (value != (startvalue+i)) {
+      Uint64 value;
+      if (myNdb->getAutoIncrementValue(tabname, value, 1) == -1) {
+        g_err << "getAutoIncrementValue failed on " << tabname << endl;
+        APIERROR(myNdb->getNdbError());
+        return NDBT_FAILED;
+      }
+      else if (value != (startvalue+i)) {
         g_err << "value = " << value << " expected " << startvalue+i << endl;;
         APIERROR(myNdb->getNdbError());
         //      ret = NDBT_FAILED;

ndb/tools/restore/consumer_restore.cpp

@@ -148,9 +148,12 @@ BackupRestore::finalize_table(const TableS & table){
   if (table.have_auto_inc())
   {
     Uint64 max_val= table.get_max_auto_val();
-    Uint64 auto_val= m_ndb->readAutoIncrementValue(get_table(table.m_dictTable));
-    if (max_val+1 > auto_val || auto_val == ~(Uint64)0)
-      ret= m_ndb->setAutoIncrementValue(get_table(table.m_dictTable), max_val+1, false);
+    Uint64 auto_val;
+    int r= m_ndb->readAutoIncrementValue(get_table(table.m_dictTable), auto_val);
+    if (r == -1 && m_ndb->getNdbError().code != 626)
+      ret= false;
+    else if (r == -1 || max_val+1 > auto_val)
+      ret= m_ndb->setAutoIncrementValue(get_table(table.m_dictTable), max_val+1, false) != -1;
   }
   return ret;
 }

sql/ha_ndbcluster.cc

@@ -73,7 +73,6 @@ handlerton ndbcluster_hton = {
   HTON_NO_FLAGS
 };
 
-#define NDB_FAILED_AUTO_INCREMENT ~(Uint64)0
 #define NDB_AUTO_INCREMENT_RETRIES 10
 
 #define NDB_INVALID_SCHEMA_OBJECT 241
@@ -2112,14 +2111,15 @@ int ha_ndbcluster::write_row(byte *record)
   {
     // Table has hidden primary key
     Ndb *ndb= get_ndb();
-    Uint64 auto_value= NDB_FAILED_AUTO_INCREMENT;
+    int ret;
+    Uint64 auto_value;
     uint retries= NDB_AUTO_INCREMENT_RETRIES;
     do {
-      auto_value= ndb->getAutoIncrementValue((const NDBTAB *) m_table);
-    } while (auto_value == NDB_FAILED_AUTO_INCREMENT && 
+      ret= ndb->getAutoIncrementValue((const NDBTAB *) m_table, auto_value, 1);
+    } while (ret == -1 && 
              --retries &&
              ndb->getNdbError().status == NdbError::TemporaryError);
-    if (auto_value == NDB_FAILED_AUTO_INCREMENT)
+    if (ret == -1)
       ERR_RETURN(ndb->getNdbError());
     if (set_hidden_key(op, table->s->fields, (const byte*)&auto_value))
       ERR_RETURN(op->getNdbError());
@@ -2197,11 +2197,11 @@ int ha_ndbcluster::write_row(byte *record)
     Ndb *ndb= get_ndb();
     Uint64 next_val= (Uint64) table->next_number_field->val_int() + 1;
     DBUG_PRINT("info", 
-               ("Trying to set next auto increment value to %lu",
-                (ulong) next_val));
-    if (ndb->setAutoIncrementValue((const NDBTAB *) m_table, next_val, TRUE))
-      DBUG_PRINT("info", 
-                 ("Setting next auto increment value to %u", next_val));  
+               ("Trying to set next auto increment value to %llu",
+                (ulonglong) next_val));
+    if (ndb->setAutoIncrementValue((const NDBTAB *) m_table, next_val, TRUE)
+        == -1)
+      ERR_RETURN(ndb->getNdbError());
   }
   m_skip_auto_increment= TRUE;
 
@@ -3047,8 +3047,14 @@ void ha_ndbcluster::info(uint flag)
     {
       Ndb *ndb= get_ndb();
       
-      auto_increment_value= 
-        ndb->readAutoIncrementValue((const NDBTAB *) m_table);
+      if (ndb->readAutoIncrementValue((const NDBTAB *) m_table,
+                                      auto_increment_value) == -1)
+      {
+        const NdbError err= ndb->getNdbError();
+        sql_print_error("Error %lu in readAutoIncrementValue(): %s",
+                        (ulong) err.code, err.message);
+        auto_increment_value= ~(Uint64)0;
+      }
     }
   }
   DBUG_VOID_RETURN;
@@ -4375,17 +4381,17 @@ ulonglong ha_ndbcluster::get_auto_increment()
            m_rows_to_insert - m_rows_inserted :
            ((m_rows_to_insert > m_autoincrement_prefetch) ?
             m_rows_to_insert : m_autoincrement_prefetch));
-  auto_value= NDB_FAILED_AUTO_INCREMENT;
+  int ret;
   uint retries= NDB_AUTO_INCREMENT_RETRIES;
   do {
-    auto_value=
-      (m_skip_auto_increment) ? 
-      ndb->readAutoIncrementValue((const NDBTAB *) m_table)
-      : ndb->getAutoIncrementValue((const NDBTAB *) m_table, cache_size);
-  } while (auto_value == NDB_FAILED_AUTO_INCREMENT && 
+    ret=
+      m_skip_auto_increment ? 
+      ndb->readAutoIncrementValue((const NDBTAB *) m_table, auto_value) :
+      ndb->getAutoIncrementValue((const NDBTAB *) m_table, auto_value, cache_size);
+  } while (ret == -1 && 
            --retries &&
            ndb->getNdbError().status == NdbError::TemporaryError);
-  if (auto_value == NDB_FAILED_AUTO_INCREMENT)
+  if (ret == -1)
   {
     const NdbError err= ndb->getNdbError();
     sql_print_error("Error %lu in ::get_auto_increment(): %s",