ndb - bug#14509 [related] setAutoIncrement: add error handling

ndb/include/ndbapi/Ndb.hpp

@@ -1432,7 +1432,7 @@ public:
    *
    * @param cacheSize number of values to cache in this Ndb object
    *
-   * @return tuple id or 0 on error
+   * @return tuple id or ~(Uint64)0 on error.
    */
   Uint64 getAutoIncrementValue(const char* aTableName, 
 			       Uint32 cacheSize = 1);
@@ -1440,14 +1440,14 @@ public:
 			       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 setAutoIncrementValue(const char* aTableName, Uint64 val, 
+			      bool increase = false);
+  Uint64 setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, 
+			      bool increase = false);
 private:
   Uint64 getTupleIdFromNdb(Ndb_local_table_info* info, Uint32 cacheSize);
   Uint64 readTupleIdFromNdb(Ndb_local_table_info* info);
-  bool setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase);
+  Uint64 setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase);
   Uint64 opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op);
 public:
 

ndb/src/ndbapi/Ndb.cpp

@@ -781,8 +781,7 @@ Uint64
 Ndb::getAutoIncrementValue(const NdbDictionary::Table * aTable, Uint32 cacheSize)
 {
   DBUG_ENTER("getAutoIncrementValue");
-  if (aTable == 0)
-    DBUG_RETURN(~(Uint64)0);
+  assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
 
@@ -843,8 +842,7 @@ Uint64
 Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable)
 {
   DBUG_ENTER("readAutoIncrementValue");
-  if (aTable == 0)
-    DBUG_RETURN(~(Uint64)0);
+  assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
 
@@ -880,7 +878,7 @@ Ndb::readTupleIdFromNdb(Ndb_local_table_info* info)
   DBUG_RETURN(tupleId);
 }
 
-bool
+Uint64
 Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
 {
   DBUG_ENTER("setAutoIncrementValue");
@@ -890,17 +888,16 @@ Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(false);
+    DBUG_RETURN(~(Uint64)0);
   }
   DBUG_RETURN(setTupleIdInNdb(info, val, increase));
 }
 
-bool
+Uint64
 Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool increase)
 {
   DBUG_ENTER("setAutoIncrementValue");
-  if (aTable == 0)
-    DBUG_RETURN(false);
+  assert(aTable != 0);
   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
   const BaseString& internal_tabname = table->m_internalName;
 
@@ -908,12 +905,12 @@ Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool
     theDictionary->get_local_table_info(internal_tabname, false);
   if (info == 0) {
     theError.code = theDictionary->getNdbError().code;
-    DBUG_RETURN(false);
+    DBUG_RETURN(~(Uint64)0);
   }
   DBUG_RETURN(setTupleIdInNdb(info, val, increase));
 }
 
-bool
+Uint64
 Ndb::setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase)
 {
   DBUG_ENTER("setTupleIdInNdb");
@@ -923,11 +920,14 @@ Ndb::setTupleIdInNdb(Ndb_local_table_info* info, Uint64 val, bool increase)
     {
       assert(info->m_first_tuple_id < info->m_last_tuple_id);
       if (val <= info->m_first_tuple_id + 1)
-	DBUG_RETURN(false);
+	DBUG_RETURN(val);
       if (val <= info->m_last_tuple_id)
       {
 	info->m_first_tuple_id = val - 1;
-	DBUG_RETURN(true);
+        DBUG_PRINT("info", 
+                   ("Setting next auto increment cached value to %llu",
+                    (ulonglong)val));  
+	DBUG_RETURN(val);
       }
     }
     /*
@@ -954,8 +954,7 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op)
   NdbOperation*      tOperation= 0; // Compiler warning if not initialized
   Uint64             tValue;
   NdbRecAttr*        tRecAttrResult;
-  int                result;
-  Uint64 ret;
+  Uint64 ret = ~(Uint64)0;
 
   CHECK_STATUS_MACRO_ZERO;
 
@@ -1017,17 +1016,17 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op)
       tOperation->def_label(0);
       tOperation->interpret_exit_nok(9999);
       
-      if ( (result = tConnection->execute( Commit )) == -1 )
+      if (tConnection->execute( Commit ) == -1)
       {
         if (tConnection->theError.code != 9999)
           goto error_handler;
-
-        // NEXTID >= opValue, return ~(Uint64)0 for now since
-        // there is no error check...
-        ret = ~(Uint64)0;
+        ret = opValue;
       }
       else
       {
+        DBUG_PRINT("info", 
+                   ("Setting next auto increment value (db) to %llu",
+                    (ulonglong)opValue));  
         info->m_first_tuple_id = info->m_last_tuple_id = opValue - 1;
 	ret = opValue;
       }

ndb/src/ndbapi/NdbDictionaryImpl.cpp

@@ -1742,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
-	  m_error= ndb.theError;
-	ret = -1; // errorcode set in initialize_autoincrement
+      if (ndb.setAutoIncrementValue(impl.m_externalName.c_str(),
+				    autoIncrementValue) == ~(Uint64)0) {
+        DBUG_ASSERT(ndb.theError.code != 0);
+        m_error= ndb.theError;
+	ret = -1;
       }
     }
   }

ndb/tools/restore/consumer_restore.cpp

@@ -150,7 +150,7 @@ BackupRestore::finalize_table(const TableS & table){
     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);
+      ret= m_ndb->setAutoIncrementValue(get_table(table.m_dictTable), max_val+1, false) != ~(Uint64)0;
   }
   return ret;
 }

sql/ha_ndbcluster.cc

@@ -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)
+        == ~(Uint64)0)
+      ERR_RETURN(ndb->getNdbError());
   }
   m_skip_auto_increment= TRUE;