MySQL Lists are EOL. Please join:

List:Commits« Previous MessageNext Message »
From:pekka Date:May 17 2006 10:40am
Subject:bk commit into 5.0 tree (pekka:1.2127) BUG#14509
View as plain text  
Below is the list of changes that have just been committed into a local
5.0 repository of pekka. When pekka does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet
  1.2127 06/05/17 12:40:10 pekka@stripped +6 -0
  ndb -  bug#14509 [related] re-do auto-incr error handling

  sql/ha_ndbcluster.cc
    1.247 06/05/17 12:30:57 pekka@stripped +21 -15
    make auto-incr methods return int 0/-1

  ndb/tools/restore/consumer_restore.cpp
    1.23 06/05/17 12:30:57 pekka@stripped +6 -3
    make auto-incr methods return int 0/-1

  ndb/test/ndbapi/testDict.cpp
    1.23 06/05/17 12:30:57 pekka@stripped +7 -3
    make auto-incr methods return int 0/-1

  ndb/src/ndbapi/NdbDictionaryImpl.cpp
    1.90 06/05/17 12:30:57 pekka@stripped +1 -1
    make auto-incr methods return int 0/-1

  ndb/src/ndbapi/Ndb.cpp
    1.59 06/05/17 12:30:57 pekka@stripped +90 -68
    make auto-incr methods return int 0/-1

  ndb/include/ndbapi/Ndb.hpp
    1.46 06/05/17 12:30:57 pekka@stripped +20 -15
    make auto-incr methods return int 0/-1

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	pekka
# Host:	orca.ndb.mysql.com
# Root:	/space/pekka/ndb/version/my50-bug14509

--- 1.45/ndb/include/ndbapi/Ndb.hpp	2006-05-16 12:44:11 +02:00
+++ 1.46/ndb/include/ndbapi/Ndb.hpp	2006-05-17 12:30:57 +02:00
@@ -1432,23 +1432,28 @@
    *
    * @param cacheSize number of values to cache in this Ndb object
    *
-   * @return tuple id or ~(Uint64)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);
-  Uint64 setAutoIncrementValue(const char* aTableName, Uint64 val, 
-			      bool increase = false);
-  Uint64 setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, 
-			      bool increase = false);
+  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:
-  Uint64 getTupleIdFromNdb(Ndb_local_table_info* info, Uint32 cacheSize);
-  Uint64 readTupleIdFromNdb(Ndb_local_table_info* info);
-  Uint64 setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase);
-  Uint64 opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op);
+  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:
 
   /**

--- 1.58/ndb/src/ndbapi/Ndb.cpp	2006-05-16 16:14:36 +02:00
+++ 1.59/ndb/src/ndbapi/Ndb.cpp	2006-05-17 12:30:57 +02:00
@@ -760,27 +760,30 @@
                 The TupleId comes from SYSTAB_0 where SYSKEY_0 = TableId.
                 It is initialized to (TableId << 48) + 1 in NdbcntrMain.cpp.
 ****************************************************************************/
-Uint64
-Ndb::getAutoIncrementValue(const char* aTableName, Uint32 cacheSize)
+int
+Ndb::getAutoIncrementValue(const char* aTableName,
+                           Uint64 & tupleId, Uint32 cacheSize)
 {
-  DBUG_ENTER("getAutoIncrementValue");
+  DBUG_ENTER("Ndb::getAutoIncrementValue");
   BaseString internal_tabname(internalize_table_name(aTableName));
 
   Ndb_local_table_info *info=
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  Uint64 tupleId = getTupleIdFromNdb(info, cacheSize);
+  if (getTupleIdFromNdb(info, tupleId, cacheSize) == -1)
+    DBUG_RETURN(-1);
   DBUG_PRINT("info", ("value %llu", (ulonglong)tupleId));
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::getAutoIncrementValue(const NdbDictionary::Table * aTable, Uint32 cacheSize)
+int
+Ndb::getAutoIncrementValue(const NdbDictionary::Table * aTable,
+                           Uint64 & tupleId, Uint32 cacheSize)
 {
-  DBUG_ENTER("getAutoIncrementValue");
+  DBUG_ENTER("Ndb::getAutoIncrementValue");
   assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
@@ -789,18 +792,19 @@
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  Uint64 tupleId = getTupleIdFromNdb(info, cacheSize);
+  if (getTupleIdFromNdb(info, tupleId, cacheSize) == -1)
+    DBUG_RETURN(-1);
   DBUG_PRINT("info", ("value %llu", (ulonglong)tupleId));
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::getTupleIdFromNdb(Ndb_local_table_info* info, Uint32 cacheSize)
+int
+Ndb::getTupleIdFromNdb(Ndb_local_table_info* info,
+                       Uint64 & tupleId, Uint32 cacheSize)
 {
-  DBUG_ENTER("getTupleIdFromNdb");
-  Uint64 tupleId;
+  DBUG_ENTER("Ndb::getTupleIdFromNdb");
   if (info->m_first_tuple_id != info->m_last_tuple_id)
   {
     assert(info->m_first_tuple_id < info->m_last_tuple_id);
@@ -816,32 +820,38 @@
      * reserve next cacheSize entries in db.  adds cacheSize to NEXTID
      * and returns first tupleId in the new range.
      */
-    tupleId = opTupleIdOnNdb(info, cacheSize, 0);
+    Uint64 opValue = cacheSize;
+    if (opTupleIdOnNdb(info, opValue, 0) == -1)
+      DBUG_RETURN(-1);
+    tupleId = opValue;
   }
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::readAutoIncrementValue(const char* aTableName)
+int
+Ndb::readAutoIncrementValue(const char* aTableName,
+                            Uint64 & tupleId)
 {
-  DBUG_ENTER("readAutoIncrementValue");
+  DBUG_ENTER("Ndb::readAutoIncrementValue");
   BaseString internal_tabname(internalize_table_name(aTableName));
 
   Ndb_local_table_info *info=
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  Uint64 tupleId = readTupleIdFromNdb(info);
+  if (readTupleIdFromNdb(info, tupleId) == -1)
+    DBUG_RETURN(-1);
   DBUG_PRINT("info", ("value %llu", (ulonglong)tupleId));
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable)
+int
+Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable,
+                            Uint64 & tupleId)
 {
-  DBUG_ENTER("readAutoIncrementValue");
+  DBUG_ENTER("Ndb::readAutoIncrementValue");
   assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
@@ -850,18 +860,19 @@
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  Uint64 tupleId = readTupleIdFromNdb(info);
+  if (readTupleIdFromNdb(info, tupleId) == -1)
+    DBUG_RETURN(-1);
   DBUG_PRINT("info", ("value %llu", (ulonglong)tupleId));
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::readTupleIdFromNdb(Ndb_local_table_info* info)
+int
+Ndb::readTupleIdFromNdb(Ndb_local_table_info* info,
+                        Uint64 & tupleId)
 {
   DBUG_ENTER("Ndb::readTupleIdFromNdb");
-  Uint64 tupleId;
   if (info->m_first_tuple_id != info->m_last_tuple_id)
   {
     assert(info->m_first_tuple_id < info->m_last_tuple_id);
@@ -873,30 +884,37 @@
      * peek at NEXTID.  does not reserve it so the value is valid
      * only if no other transactions are allowed.
      */
-    tupleId = opTupleIdOnNdb(info, 0, 3);
+    Uint64 opValue = 0;
+    if (opTupleIdOnNdb(info, opValue, 3) == -1)
+      DBUG_RETURN(-1);
+    tupleId = opValue;
   }
-  DBUG_RETURN(tupleId);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
+int
+Ndb::setAutoIncrementValue(const char* aTableName,
+                           Uint64 tupleId, bool increase)
 {
-  DBUG_ENTER("setAutoIncrementValue");
+  DBUG_ENTER("Ndb::setAutoIncrementValue");
   BaseString internal_tabname(internalize_table_name(aTableName));
 
   Ndb_local_table_info *info=
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  DBUG_RETURN(setTupleIdInNdb(info, val, increase));
+  if (setTupleIdInNdb(info, tupleId, increase) == -1)
+    DBUG_RETURN(-1);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool increase)
+int
+Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable,
+                           Uint64 tupleId, bool increase)
 {
-  DBUG_ENTER("setAutoIncrementValue");
+  DBUG_ENTER("Ndb::setAutoIncrementValue");
   assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
@@ -905,46 +923,54 @@
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(~(Uint64)0);
+    DBUG_RETURN(-1);
   }
-  DBUG_RETURN(setTupleIdInNdb(info, val, increase));
+  if (setTupleIdInNdb(info, tupleId, increase) == -1)
+    DBUG_RETURN(-1);
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase)
+int
+Ndb::setTupleIdInNdb(Ndb_local_table_info* info,
+                     Uint64 tupleId, bool increase)
 {
-  DBUG_ENTER("setTupleIdInNdb");
+  DBUG_ENTER("Ndb::setTupleIdInNdb");
   if (increase)
   {
     if (info->m_first_tuple_id != info->m_last_tuple_id)
     {
       assert(info->m_first_tuple_id < info->m_last_tuple_id);
-      if (val <= info->m_first_tuple_id + 1)
-	DBUG_RETURN(val);
-      if (val <= info->m_last_tuple_id)
+      if (tupleId <= info->m_first_tuple_id + 1)
+	DBUG_RETURN(0);
+      if (tupleId <= info->m_last_tuple_id)
       {
-	info->m_first_tuple_id = val - 1;
+	info->m_first_tuple_id = tupleId - 1;
         DBUG_PRINT("info", 
                    ("Setting next auto increment cached value to %llu",
-                    (ulonglong)val));  
-	DBUG_RETURN(val);
+                    (ulonglong)tupleId));  
+	DBUG_RETURN(0);
       }
     }
     /*
-     * if value <= NEXTID, do nothing.  otherwise update NEXTID to
-     * value and set cached range to first = last = value - 1.
+     * if tupleId <= NEXTID, do nothing.  otherwise update NEXTID to
+     * tupleId and set cached range to first = last = tupleId - 1.
      */
-    DBUG_RETURN((opTupleIdOnNdb(info, val, 2)));
+    if (opTupleIdOnNdb(info, tupleId, 2) == -1)
+      DBUG_RETURN(-1);
   }
   else
+  {
     /*
      * update NEXTID to given value.  reset cached range.
      */
-    DBUG_RETURN((opTupleIdOnNdb(info, val, 1)));
+    if (opTupleIdOnNdb(info, tupleId, 1) == -1)
+      DBUG_RETURN(-1);
+  }
+  DBUG_RETURN(0);
 }
 
-Uint64
-Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op)
+int
+Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 & opValue, Uint32 op)
 {
   DBUG_ENTER("Ndb::opTupleIdOnNdb");
   Uint32 aTableId = info->m_table_impl->m_tableId;
@@ -954,7 +980,6 @@
   NdbOperation*      tOperation= 0; // Compiler warning if not initialized
   Uint64             tValue;
   NdbRecAttr*        tRecAttrResult;
-  Uint64 ret = ~(Uint64)0;
 
   CHECK_STATUS_MACRO_ZERO;
 
@@ -989,7 +1014,7 @@
 
       info->m_first_tuple_id = tValue - opValue;
       info->m_last_tuple_id  = tValue - 1;
-      ret = info->m_first_tuple_id;
+      opValue = info->m_first_tuple_id; // out
       break;
     case 1:
       // create on first use
@@ -1002,7 +1027,6 @@
 
       info->m_first_tuple_id = ~(Uint64)0;
       info->m_last_tuple_id  = ~(Uint64)0;
-      ret = opValue;
       break;
     case 2:
       tOperation->interpretedUpdateTuple();
@@ -1020,7 +1044,6 @@
       {
         if (tConnection->theError.code != 9999)
           goto error_handler;
-        ret = opValue;
       }
       else
       {
@@ -1028,7 +1051,6 @@
                    ("Setting next auto increment value (db) to %llu",
                     (ulonglong)opValue));  
         info->m_first_tuple_id = info->m_last_tuple_id = opValue - 1;
-	ret = opValue;
       }
       break;
     case 3:
@@ -1037,7 +1059,7 @@
       tRecAttrResult = tOperation->getValue("NEXTID");
       if (tConnection->execute( Commit ) == -1 )
         goto error_handler;
-      ret = tRecAttrResult->u_64_value();
+      opValue = tRecAttrResult->u_64_value(); // out
       break;
     default:
       goto error_handler;
@@ -1049,7 +1071,7 @@
   setDatabaseName(currentDb.c_str());
   setDatabaseSchemaName(currentSchema.c_str());
 
-  DBUG_RETURN(ret);
+  DBUG_RETURN(0);
 
   error_handler:
     theError.code = tConnection->theError.code;
@@ -1063,7 +1085,7 @@
              theError.code,
              tConnection ? tConnection->theError.code : -1,
              tOperation ? tOperation->theError.code : -1));
-  DBUG_RETURN(~(Uint64)0);
+  DBUG_RETURN(-1);
 }
 
 Uint32

--- 1.89/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2006-05-16 12:44:11 +02:00
+++ 1.90/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2006-05-17 12:30:57 +02:00
@@ -1743,7 +1743,7 @@
 
     if (haveAutoIncrement) {
       if (ndb.setAutoIncrementValue(impl.m_externalName.c_str(),
-				    autoIncrementValue) == ~(Uint64)0) {
+				    autoIncrementValue, false) == -1) {
         DBUG_ASSERT(ndb.theError.code != 0);
         m_error= ndb.theError;
 	ret = -1;

--- 1.22/ndb/test/ndbapi/testDict.cpp	2005-06-07 18:06:46 +02:00
+++ 1.23/ndb/test/ndbapi/testDict.cpp	2006-05-17 12:30:57 +02:00
@@ -1139,9 +1139,13 @@
 
     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;

--- 1.246/sql/ha_ndbcluster.cc	2006-05-16 12:44:11 +02:00
+++ 1.247/sql/ha_ndbcluster.cc	2006-05-17 12:30:57 +02:00
@@ -73,7 +73,6 @@
   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 @@
   {
     // 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());
@@ -2200,7 +2200,7 @@
                ("Trying to set next auto increment value to %llu",
                 (ulonglong) next_val));
     if (ndb->setAutoIncrementValue((const NDBTAB *) m_table, next_val, TRUE)
-        == ~(Uint64)0)
+        == -1)
       ERR_RETURN(ndb->getNdbError());
   }
   m_skip_auto_increment= TRUE;
@@ -3047,8 +3047,14 @@
     {
       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;
@@ -4360,17 +4366,17 @@
            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",

--- 1.22/ndb/tools/restore/consumer_restore.cpp	2006-05-16 12:44:11 +02:00
+++ 1.23/ndb/tools/restore/consumer_restore.cpp	2006-05-17 12:30:57 +02:00
@@ -148,9 +148,12 @@
   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)0;
+    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;
 }
Thread
bk commit into 5.0 tree (pekka:1.2127) BUG#14509pekka17 May