Below is the list of changes that have just been committed into a local
5.0 repository of msvensson. When msvensson 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.1841 05/06/02 14:57:46 msvensson@neptunus.(none) +2 -0
Merge neptunus.(none):/home/msvensson/mysql/mysql-5.0-ndb
into neptunus.(none):/home/msvensson/mysql/bug9626
ndb/src/ndbapi/NdbDictionaryImpl.cpp
1.80 05/06/02 14:57:45 msvensson@neptunus.(none) +0 -0
Auto merged
ndb/src/ndbapi/Ndb.cpp
1.53 05/06/02 14:57:45 msvensson@neptunus.(none) +0 -0
Auto merged
# 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: msvensson
# Host: neptunus.(none)
# Root: /home/msvensson/mysql/bug9626/RESYNC
--- 1.52/ndb/src/ndbapi/Ndb.cpp 2005-05-20 15:14:30 +02:00
+++ 1.53/ndb/src/ndbapi/Ndb.cpp 2005-06-02 14:57:45 +02:00
@@ -751,16 +751,14 @@
The TupleId comes from SYSTAB_0 where SYSKEY_0 = TableId.
It is initialized to (TableId << 48) + 1 in NdbcntrMain.cpp.
****************************************************************************/
-#define DEBUG_TRACE(msg) \
-// ndbout << __FILE__ << " line: " << __LINE__ << " msg: " << msg << endl
-
Uint64
Ndb::getAutoIncrementValue(const char* aTableName, Uint32 cacheSize)
{
DBUG_ENTER("getAutoIncrementValue");
- const char * internalTableName = internalizeTableName(aTableName);
+ BaseString internal_tabname(internalize_table_name(aTableName));
+
Ndb_local_table_info *info=
- theDictionary->get_local_table_info(internalTableName, false);
+ theDictionary->get_local_table_info(internal_tabname, false);
if (info == 0)
DBUG_RETURN(~(Uint64)0);
const NdbTableImpl *table= info->m_table_impl;
@@ -812,7 +810,7 @@
Uint64
Ndb::readAutoIncrementValue(const char* aTableName)
{
- DBUG_ENTER("readtAutoIncrementValue");
+ DBUG_ENTER("readAutoIncrementValue");
const NdbTableImpl* table = theDictionary->getTable(aTableName);
if (table == 0) {
theError= theDictionary->getNdbError();
@@ -826,7 +824,7 @@
Uint64
Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable)
{
- DBUG_ENTER("readtAutoIncrementValue");
+ DBUG_ENTER("readAutoIncrementValue");
if (aTable == 0)
DBUG_RETURN(~(Uint64)0);
const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
@@ -848,62 +846,63 @@
bool
Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
{
- DEBUG_TRACE("setAutoIncrementValue " << val);
- const char * internalTableName= internalizeTableName(aTableName);
+ DBUG_ENTER("setAutoIncrementValue");
+ BaseString internal_tabname(internalize_table_name(aTableName));
+
Ndb_local_table_info *info=
- theDictionary->get_local_table_info(internalTableName, false);
+ theDictionary->get_local_table_info(internal_tabname, false);
if (info == 0) {
theError= theDictionary->getNdbError();
- return false;
+ DBUG_RETURN(false);
}
const NdbTableImpl* table= info->m_table_impl;
- return setTupleIdInNdb(table->m_tableId, val, increase);
+ DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
}
bool
Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool increase)
{
- DEBUG_TRACE("setAutoIncrementValue " << val);
+ DBUG_ENTER("setAutoIncrementValue");
if (aTable == 0)
- return ~(Uint64)0;
+ DBUG_RETURN(~(Uint64)0);
const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
- return setTupleIdInNdb(table->m_tableId, val, increase);
+ DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
}
-bool
+bool
Ndb::setTupleIdInNdb(const char* aTableName, Uint64 val, bool increase )
{
- DEBUG_TRACE("setTupleIdInNdb");
+ DBUG_ENTER("setTupleIdInNdb(const char*, ...)");
const NdbTableImpl* table = theDictionary->getTable(aTableName);
if (table == 0) {
theError= theDictionary->getNdbError();
- return false;
+ DBUG_RETURN(false);
}
- return setTupleIdInNdb(table->m_tableId, val, increase);
+ DBUG_RETURN(setTupleIdInNdb(table->m_tableId, val, increase));
}
bool
Ndb::setTupleIdInNdb(Uint32 aTableId, Uint64 val, bool increase )
{
- DEBUG_TRACE("setTupleIdInNdb");
+ DBUG_ENTER("setTupleIdInNdb(Uint32, ...)");
if (increase)
{
if (theFirstTupleId[aTableId] != theLastTupleId[aTableId])
{
// We have a cache sequence
if (val <= theFirstTupleId[aTableId]+1)
- return false;
+ DBUG_RETURN(false);
if (val <= theLastTupleId[aTableId])
{
theFirstTupleId[aTableId] = val - 1;
- return true;
+ DBUG_RETURN(true);
}
// else continue;
- }
- return (opTupleIdOnNdb(aTableId, val, 2) == val);
+ }
+ DBUG_RETURN((opTupleIdOnNdb(aTableId, val, 2) == val));
}
else
- return (opTupleIdOnNdb(aTableId, val, 1) == val);
+ DBUG_RETURN((opTupleIdOnNdb(aTableId, val, 1) == val));
}
Uint64
@@ -1143,24 +1142,62 @@
return externalizeIndexName(internalIndexName, usingFullyQualifiedNames());
}
-const char *
-Ndb::internalizeTableName(const char * externalTableName)
+
+const BaseString
+Ndb::internalize_table_name(const char *external_name) const
{
+ BaseString ret;
+ DBUG_ENTER("internalize_table_name");
+ DBUG_PRINT("enter", ("external_name: %s", external_name));
+
if (fullyQualifiedNames)
- return theImpl->internalize_table_name(externalTableName);
+ {
+ /* Internal table name format <db>/<schema>/<table>
+ <db>/<schema> is already available in m_prefix
+ so just concat the two strings
+ */
+ ret.assfmt("%s%s",
+ theImpl->m_prefix.c_str(),
+ external_name);
+ }
else
- return externalTableName;
+ ret.assign(external_name);
+
+ DBUG_PRINT("exit", ("internal_name: %s", ret.c_str()));
+ DBUG_RETURN(ret);
}
-
-const char *
-Ndb::internalizeIndexName(const NdbTableImpl * table,
- const char * externalIndexName)
-{
+
+
+const BaseString
+Ndb::internalize_index_name(const NdbTableImpl * table,
+ const char * external_name) const
+{
+ BaseString ret;
+ DBUG_ENTER("internalize_index_name");
+ DBUG_PRINT("enter", ("external_name: %s, table_id: %d",
+ external_name, table ? table->m_tableId : ~0));
+ if (!table)
+ {
+ DBUG_PRINT("error", ("!table"));
+ return ret;
+ }
+
if (fullyQualifiedNames)
- return theImpl->internalize_index_name(table, externalIndexName);
+ {
+ /* Internal index name format <db>/<schema>/<tabid>/<table> */
+ ret.assfmt("%s%d%c%s",
+ theImpl->m_prefix.c_str(),
+ table->m_tableId,
+ table_name_separator,
+ external_name);
+ }
else
- return externalIndexName;
+ ret.assign(external_name);
+
+ DBUG_PRINT("exit", ("internal_name: %s", ret.c_str()));
+ DBUG_RETURN(ret);
}
+
const BaseString
Ndb::getDatabaseFromInternalName(const char * internalName)
--- 1.79/ndb/src/ndbapi/NdbDictionaryImpl.cpp 2005-05-26 14:02:30 +02:00
+++ 1.80/ndb/src/ndbapi/NdbDictionaryImpl.cpp 2005-06-02 14:57:45 +02:00
@@ -735,19 +735,19 @@
}
Ndb_local_table_info *
-NdbDictionaryImpl::fetchGlobalTableImpl(const char * internalTableName)
+NdbDictionaryImpl::fetchGlobalTableImpl(const BaseString& internalTableName)
{
NdbTableImpl *impl;
m_globalHash->lock();
- impl = m_globalHash->get(internalTableName);
+ impl = m_globalHash->get(internalTableName.c_str());
m_globalHash->unlock();
if (impl == 0){
impl = m_receiver.getTable(internalTableName,
m_ndb.usingFullyQualifiedNames());
m_globalHash->lock();
- m_globalHash->put(internalTableName, impl);
+ m_globalHash->put(internalTableName.c_str(), impl);
m_globalHash->unlock();
if(impl == 0){
@@ -758,7 +758,7 @@
Ndb_local_table_info *info=
Ndb_local_table_info::create(impl, m_local_table_data_size);
- m_localHash.put(internalTableName, info);
+ m_localHash.put(internalTableName.c_str(), info);
m_ndb.theFirstTupleId[impl->getTableId()] = ~0;
m_ndb.theLastTupleId[impl->getTableId()] = ~0;
@@ -806,14 +806,13 @@
return false;
}
-NdbTableImpl *
-NdbDictionaryImpl::getIndexTable(NdbIndexImpl * index,
+NdbTableImpl *
+NdbDictionaryImpl::getIndexTable(NdbIndexImpl * index,
NdbTableImpl * table)
{
- const char * internalName =
- m_ndb.internalizeIndexName(table, index->getName());
-
- return getTable(m_ndb.externalizeTableName(internalName));
+ const BaseString internalName(
+ m_ndb.internalize_index_name(table, index->getName()));
+ return getTable(m_ndb.externalizeTableName(internalName.c_str()));
}
#if 0
@@ -1055,7 +1054,7 @@
}
DBUG_RETURN(-1);
}
-
+#if 0
/*
Get dictionary information for a table using table id as reference
@@ -1079,6 +1078,7 @@
return getTable(&tSignal, 0, 0, fullyQualifiedNames);
}
+#endif
/*
@@ -1090,36 +1090,31 @@
*/
NdbTableImpl *
-NdbDictInterface::getTable(const char * name, bool fullyQualifiedNames)
+NdbDictInterface::getTable(const BaseString& name, bool fullyQualifiedNames)
{
NdbApiSignal tSignal(m_reference);
GetTabInfoReq* const req = CAST_PTR(GetTabInfoReq, tSignal.getDataPtrSend());
- const Uint32 str_len= strlen(name) + 1; // NULL terminated
- const Uint32 str_len_words= (str_len + 3) / 4; // Size in words
-
- if (str_len > MAX_SECTION_SIZE)
- {
- m_error.code= 4307;
- return 0;
- }
-
- m_namebuf.clear();
- m_namebuf.grow(str_len_words*4); // Word size aligned number of bytes
- m_namebuf.append(name, str_len);
+ const Uint32 namelen= name.length() + 1; // NULL terminated
+ const Uint32 namelen_words= (namelen + 3) >> 2; // Size in words
req->senderRef= m_reference;
req->senderData= 0;
req->requestType=
GetTabInfoReq::RequestByName | GetTabInfoReq::LongSignalConf;
- req->tableNameLen= str_len;
+ req->tableNameLen= namelen;
tSignal.theReceiversBlockNumber= DBDICT;
tSignal.theVerId_signalNumber= GSN_GET_TABINFOREQ;
tSignal.theLength= GetTabInfoReq::SignalLength;
+ // Copy name to m_buffer to get a word sized buffer
+ m_buffer.clear();
+ m_buffer.grow(namelen_words*4);
+ m_buffer.append(name.c_str(), namelen);
+
LinearSectionPtr ptr[1];
- ptr[0].p= (Uint32*)m_namebuf.get_data();
- ptr[0].sz= str_len_words;
+ ptr[0].p= (Uint32*)m_buffer.get_data();
+ ptr[0].sz= namelen_words;
return getTable(&tSignal, ptr, 1, fullyQualifiedNames);
}
@@ -1463,7 +1458,7 @@
return 0;
// update table def from DICT
Ndb_local_table_info *info=
- get_local_table_info(t.m_internalName.c_str(),false);
+ get_local_table_info(t.m_internalName,false);
if (info == NULL) {
m_error.code= 709;
return -1;
@@ -1490,7 +1485,7 @@
return -1;
// Save BLOB table handle
Ndb_local_table_info *info=
- get_local_table_info(bt.m_internalName.c_str(), false);
+ get_local_table_info(bt.m_internalName, false);
if (info == 0) {
return -1;
}
@@ -1534,12 +1529,11 @@
int NdbDictionaryImpl::alterTable(NdbTableImpl &impl)
{
- BaseString internalName = impl.m_internalName;
+ BaseString internalName(impl.m_internalName);
const char * originalInternalName = internalName.c_str();
- BaseString externalName = impl.m_externalName;
DBUG_ENTER("NdbDictionaryImpl::alterTable");
- if(!get_local_table_info(originalInternalName, false)){
+ if(!get_local_table_info(internalName, false)){
m_error.code= 709;
DBUG_RETURN(-1);
}
@@ -1594,14 +1588,14 @@
//validate();
//aggregate();
- const char * internalName =
- ndb.internalizeTableName(impl.m_externalName.c_str());
+ const BaseString internalName(
+ ndb.internalize_table_name(impl.m_externalName.c_str()));
impl.m_internalName.assign(internalName);
UtilBufferWriter w(m_buffer);
DictTabInfo::Table tmpTab; tmpTab.init();
- BaseString::snprintf(tmpTab.TableName,
- sizeof(tmpTab.TableName),
- internalName);
+ BaseString::snprintf(tmpTab.TableName,
+ sizeof(tmpTab.TableName),
+ internalName.c_str());
bool haveAutoIncrement = false;
Uint64 autoIncrementValue = 0;
@@ -1863,14 +1857,14 @@
// If table stored in cache is incompatible with the one in the kernel
// we must clear the cache and try again
if (ret == INCOMPATIBLE_VERSION) {
- const char * internalTableName = m_ndb.internalizeTableName(name);
+ const BaseString internalTableName(m_ndb.internalize_table_name(name));
- DBUG_PRINT("info",("INCOMPATIBLE_VERSION internal_name: %s", internalTableName));
- m_localHash.drop(internalTableName);
+ DBUG_PRINT("info",("INCOMPATIBLE_VERSION internal_name: %s", internalTableName.c_str()));
+ m_localHash.drop(internalTableName.c_str());
m_globalHash->lock();
tab->m_status = NdbDictionary::Object::Invalid;
m_globalHash->drop(tab);
- m_globalHash->unlock();
+ m_globalHash->unlock();
DBUG_RETURN(dropTable(name));
}
@@ -2011,13 +2005,14 @@
NdbDictionaryImpl::invalidateObject(NdbTableImpl & impl)
{
const char * internalTableName = impl.m_internalName.c_str();
-
- m_localHash.drop(internalTableName);
+ DBUG_ENTER("NdbDictionaryImpl::invalidateObject");
+ DBUG_PRINT("enter", ("internal_name: %s", internalTableName));
+ m_localHash.drop(internalTableName);
m_globalHash->lock();
impl.m_status = NdbDictionary::Object::Invalid;
m_globalHash->drop(&impl);
m_globalHash->unlock();
- return 0;
+ DBUG_RETURN(0);
}
int
@@ -2036,8 +2031,8 @@
* Get index info
*/
NdbIndexImpl*
-NdbDictionaryImpl::getIndexImpl(const char * externalName,
- const char * internalName)
+NdbDictionaryImpl::getIndexImpl(const char * externalName,
+ const BaseString& internalName)
{
Ndb_local_table_info * info = get_local_table_info(internalName,
false);
@@ -2053,21 +2048,11 @@
return 0;
}
- /*
- * internalName may be pointer to m_ndb.theImpl->m_internalname.c_str()
- * and may get deallocated in next call.
- *
- * Passing around pointers to volatile internal members may not be
- * optimal. Suggest use BaseString instances passed by value.
- */
-
- BaseString save_me(internalName);
NdbTableImpl* prim = getTable(tab->m_primaryTable.c_str());
if(prim == 0){
m_error.code = 4243;
return 0;
}
- internalName = save_me.c_str();
/**
* Create index impl
@@ -2173,12 +2158,11 @@
m_error.code = 4241;
return -1;
}
- const char * internalName =
- ndb.internalizeIndexName(&table, impl.getName());
-
+ const BaseString internalName(
+ ndb.internalize_index_name(&table, impl.getName()));
impl.m_internalName.assign(internalName);
- w.add(DictTabInfo::TableName, internalName);
+ w.add(DictTabInfo::TableName, internalName.c_str());
w.add(DictTabInfo::TableLoggedFlag, impl.m_logging);
NdbApiSignal tSignal(m_reference);
@@ -2284,20 +2268,20 @@
// If index stored in cache is incompatible with the one in the kernel
// we must clear the cache and try again
if (ret == INCOMPATIBLE_VERSION) {
- const char * internalIndexName = (tableName)
+ const BaseString internalIndexName((tableName)
?
- m_ndb.internalizeIndexName(getTable(tableName), indexName)
+ m_ndb.internalize_index_name(getTable(tableName), indexName)
:
- m_ndb.internalizeTableName(indexName); // Index is also a table
-
- m_localHash.drop(internalIndexName);
+ m_ndb.internalize_table_name(indexName)); // Index is also a table
+
+ m_localHash.drop(internalIndexName.c_str());
m_globalHash->lock();
idx->m_table->m_status = NdbDictionary::Object::Invalid;
m_globalHash->drop(idx->m_table);
- m_globalHash->unlock();
+ m_globalHash->unlock();
return dropIndex(indexName, tableName);
}
-
+
return ret;
}
@@ -2313,19 +2297,19 @@
return -1;
}
- const char * internalIndexName = (tableName)
+ const BaseString internalIndexName((tableName)
?
- m_ndb.internalizeIndexName(getTable(tableName), indexName)
+ m_ndb.internalize_index_name(getTable(tableName), indexName)
:
- m_ndb.internalizeTableName(indexName); // Index is also a table
+ m_ndb.internalize_table_name(indexName)); // Index is also a table
if(impl.m_status == NdbDictionary::Object::New){
return dropIndex(indexName, tableName);
}
-
+
int ret = m_receiver.dropIndex(impl, *timpl);
if(ret == 0){
- m_localHash.drop(internalIndexName);
+ m_localHash.drop(internalIndexName.c_str());
m_globalHash->lock();
impl.m_table->m_status = NdbDictionary::Object::Invalid;
m_globalHash->drop(impl.m_table);
@@ -2530,8 +2514,12 @@
w.add(SimpleProperties::StringValue, evnt.m_externalName.c_str());
if (getFlag == 0)
+ {
+ const BaseString internal_tabname(
+ ndb.internalize_table_name(evnt.m_tableName.c_str()));
w.add(SimpleProperties::StringValue,
- ndb.internalizeTableName(evnt.m_tableName.c_str()));
+ internal_tabname.c_str());
+ }
LinearSectionPtr ptr[1];
ptr[0].p = (Uint32*)m_buffer.get_data();
| Thread |
|---|
| • bk commit into 5.0 tree (msvensson:1.1841) | msvensson | 2 Jun |
