Commit 60eb775c authored by unknown's avatar unknown
Browse files

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

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


storage/ndb/test/ndbapi/testDict.cpp:
  Auto merged
storage/ndb/tools/restore/consumer_restore.cpp:
  Auto merged
sql/ha_ndbcluster.cc:
  manual merge
storage/ndb/include/ndbapi/Ndb.hpp:
  SCCS merged
storage/ndb/src/ndbapi/Ndb.cpp:
  SCCS merged
storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp:
  use local, weird diff
parents caa335bc 4e6efa10

sql/ha_ndbcluster.cc

+21 −15
Original line number Diff line number Diff line
@@ -106,7 +106,6 @@ static uint ndbcluster_alter_table_flags(uint flags) 


}



#define NDB_FAILED_AUTO_INCREMENT ~(Uint64)0

#define NDB_AUTO_INCREMENT_RETRIES 10



#define ERR_PRINT(err) \
@@ -2461,14 +2460,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(m_table);

    } while (auto_value == NDB_FAILED_AUTO_INCREMENT && 

      ret= ndb->getAutoIncrementValue(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_share->fields, (const byte*)&auto_value))

      ERR_RETURN(op->getNdbError());
@@ -2566,7 +2566,7 @@ int ha_ndbcluster::write_row(byte *record) 
               ("Trying to set next auto increment value to %llu",

                (ulonglong) next_val));

    if (ndb->setAutoIncrementValue(m_table, next_val, TRUE)

        == ~(Uint64)0)

        == -1)

      ERR_RETURN(ndb->getNdbError());

  }

  m_skip_auto_increment= TRUE;
@@ -3529,8 +3529,14 @@ void ha_ndbcluster::info(uint flag) 
    {

      Ndb *ndb= get_ndb();

      

      auto_increment_value= 

        ndb->readAutoIncrementValue(m_table);

      if (ndb->readAutoIncrementValue(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;
@@ -5222,17 +5228,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(m_table)

      : ndb->getAutoIncrementValue(m_table, cache_size);

  } while (auto_value == NDB_FAILED_AUTO_INCREMENT && 

    ret=

      m_skip_auto_increment ? 

      ndb->readAutoIncrementValue(m_table, auto_value) :

      ndb->getAutoIncrementValue(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",

storage/ndb/include/ndbapi/Ndb.hpp

+20 −15
Original line number Diff line number Diff line
@@ -1469,25 +1469,30 @@ public: 
   *

   * @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

   */

  int initAutoIncrement();



  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:



  /**

storage/ndb/src/ndbapi/Ndb.cpp

+90 −68
Original line number Diff line number Diff line
@@ -747,27 +747,30 @@ 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.

****************************************************************************/

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

  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;
@@ -776,18 +779,19 @@ Ndb::getAutoIncrementValue(const NdbDictionary::Table * aTable, Uint32 cacheSize 
    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);
@@ -803,32 +807,38 @@ Ndb::getTupleIdFromNdb(Ndb_local_table_info* info, Uint32 cacheSize) 
     * 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;
@@ -837,18 +847,19 @@ Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable) 
    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);
@@ -860,30 +871,37 @@ Ndb::readTupleIdFromNdb(Ndb_local_table_info* info) 
     * 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);

  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;
@@ -892,42 +910,50 @@ 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(~(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);

}



int Ndb::initAutoIncrement()
@@ -951,8 +977,8 @@ int Ndb::initAutoIncrement() 
  return (m_sys_tab_0 == NULL);

}



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;
@@ -962,7 +988,6 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 
  NdbOperation*      tOperation= 0; // Compiler warning if not initialized

  Uint64             tValue;

  NdbRecAttr*        tRecAttrResult;

  Uint64 ret = ~(Uint64)0;



  CHECK_STATUS_MACRO_ZERO;
@@ -992,7 +1017,7 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 


      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
@@ -1005,7 +1030,6 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 


      info->m_first_tuple_id = ~(Uint64)0;

      info->m_last_tuple_id  = ~(Uint64)0;

      ret = opValue;

      break;

    case 2:

      tOperation->interpretedUpdateTuple();
@@ -1023,7 +1047,6 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 
      {

        if (tConnection->theError.code != 9999)

          goto error_handler;

        ret = opValue;

      }

      else

      {
@@ -1031,7 +1054,6 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 
                   ("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:
@@ -1040,7 +1062,7 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 
      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;
@@ -1048,7 +1070,7 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 


  this->closeTransaction(tConnection);



  DBUG_RETURN(ret);

  DBUG_RETURN(0);



  error_handler:

    theError.code = tConnection->theError.code;
@@ -1058,7 +1080,7 @@ Ndb::opTupleIdOnNdb(Ndb_local_table_info* info, Uint64 opValue, Uint32 op) 
             theError.code,

             tConnection ? tConnection->theError.code : -1,

             tOperation ? tOperation->theError.code : -1));

  DBUG_RETURN(~(Uint64)0);

  DBUG_RETURN(-1);

}



Uint32

storage/ndb/test/ndbapi/testDict.cpp

+7 −3
Original line number Diff line number Diff line
@@ -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;

storage/ndb/tools/restore/consumer_restore.cpp

+6 −3
Original line number Diff line number Diff line
@@ -151,9 +151,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)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;

}