mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-01 11:31:51 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge neptunus.(none):/home/msvensson/mysql/mysql-5.0-ndb

Browse source 
into neptunus.(none):/home/msvensson/mysql/bug9626


ndb/src/ndbapi/Ndb.cpp:
  Auto merged
ndb/src/ndbapi/NdbDictionaryImpl.cpp:
  Auto merged
This commit is contained in:
unknown 2005-06-02 14:57:46 +02:00
commit f44acb04a9
15 changed files with 305 additions and 216 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ndb/include/kernel/AttributeList.hpp
View file

@ -17,6 +17,8 @@
#ifndef ATTRIBUTE_LIST_HPP
#define ATTRIBUTE_LIST_HPP
#include "ndb_limits.h"
/**
* Masks and lists used by index and trigger. Must be plain old Uint32 data.
* XXX depends on other headers XXX move to some common file

12
ndb/include/ndbapi/Ndb.hpp
View file

@ -1583,15 +1583,17 @@ private:
void abortTransactionsAfterNodeFailure(Uint16 aNodeId);
static
const char * externalizeTableName(const char * internalTableName, bool fullyQualifiedNames);
const char * externalizeTableName(const char * internalTableName,
bool fullyQualifiedNames);
const char * externalizeTableName(const char * internalTableName);
const char * internalizeTableName(const char * externalTableName);
const BaseString internalize_table_name(const char * external_name) const;
static
const char * externalizeIndexName(const char * internalIndexName, bool fullyQualifiedNames);
const char * externalizeIndexName(const char * internalIndexName,
bool fullyQualifiedNames);
const char * externalizeIndexName(const char * internalIndexName);
const char * internalizeIndexName(const NdbTableImpl * table,
const char * externalIndexName);
const BaseString internalize_index_name(const NdbTableImpl * table,
const char * external_name) const;
static
const BaseString getDatabaseFromInternalName(const char * internalName);

3
ndb/include/transporter/TransporterDefinitions.hpp
View file

@ -45,9 +45,8 @@ enum SendStatus {
* Protocol6 Header +
* (optional signal id) + (optional checksum) + (signal data)
*/
const Uint32 MAX_SECTION_SIZE= 4096;
//const Uint32 MAX_MESSAGE_SIZE = (12+4+4+(4*25));
const Uint32 MAX_MESSAGE_SIZE = (12+4+4+(4*25)+(3*4)+4*MAX_SECTION_SIZE);
const Uint32 MAX_MESSAGE_SIZE = (12+4+4+(4*25)+(3*4)+4*4096);
/**
* TransporterConfiguration

4
ndb/include/util/SimpleProperties.hpp
View file

@ -172,6 +172,8 @@ public:
virtual bool reset() = 0;
virtual bool putWord(Uint32 val) = 0;
virtual bool putWords(const Uint32 * src, Uint32 len) = 0;
private:
bool add(const char* value, int len);
};
};
@ -211,7 +213,7 @@ private:
};
/**
* Writer for linear memory
* Writer for UtilBuffer
*/
class UtilBufferWriter : public SimpleProperties::Writer {
public:

34
ndb/src/common/util/SimpleProperties.cpp
View file

@ -36,6 +36,28 @@ SimpleProperties::Writer::add(Uint16 key, Uint32 value){
return putWord(htonl(value));
}
bool
SimpleProperties::Writer::add(const char * value, int len){
const Uint32 valLen = (len + 3) / 4;
if ((len % 4) == 0)
return putWords((Uint32*)value, valLen);
const Uint32 putLen= valLen - 1;
if (!putWords((Uint32*)value, putLen))
return false;
// Special handling of last bytes
union {
Uint32 lastWord;
char lastBytes[4];
};
memcpy(lastBytes,
value + putLen*4,
len - putLen*4);
return putWord(lastWord);
}
bool
SimpleProperties::Writer::add(Uint16 key, const char * value){
Uint32 head = StringValue;
@ -46,9 +68,9 @@ SimpleProperties::Writer::add(Uint16 key, const char * value){
Uint32 strLen = strlen(value) + 1; // Including NULL-byte
if(!putWord(htonl(strLen)))
return false;
const Uint32 valLen = (strLen + 3) / 4;
return putWords((Uint32*)value, valLen);
return add(value, (int)strLen);
}
bool
@ -60,9 +82,8 @@ SimpleProperties::Writer::add(Uint16 key, const void* value, int len){
return false;
if(!putWord(htonl(len)))
return false;
const Uint32 valLen = (len + 3) / 4;
return putWords((Uint32*)value, valLen);
return add((const char*)value, len);
}
SimpleProperties::Reader::Reader(){
@ -392,6 +413,7 @@ UtilBufferWriter::putWords(const Uint32 * src, Uint32 len){
return (m_buf.append(src, 4 * len) == 0);
}
Uint32
UtilBufferWriter::getWordsUsed() const { return m_buf.length() / 4;}

108
ndb/src/ndbapi/DictCache.cpp
View file

@ -79,11 +79,14 @@ LocalDictCache::drop(const char * name){
* Global cache
*/
GlobalDictCache::GlobalDictCache(){
DBUG_ENTER("GlobalDictCache::GlobalDictCache");
m_tableHash.createHashTable();
m_waitForTableCondition = NdbCondition_Create();
DBUG_VOID_RETURN;
}
GlobalDictCache::~GlobalDictCache(){
DBUG_ENTER("GlobalDictCache::~GlobalDictCache");
NdbElement_t<Vector<TableVersion> > * curr = m_tableHash.getNext(0);
while(curr != 0){
Vector<TableVersion> * vers = curr->theData;
@ -93,20 +96,52 @@ GlobalDictCache::~GlobalDictCache(){
delete (* vers)[i].m_impl;
}
delete curr->theData;
curr->theData= NULL;
curr = m_tableHash.getNext(curr);
}
m_tableHash.releaseHashTable();
NdbCondition_Destroy(m_waitForTableCondition);
DBUG_VOID_RETURN;
}
#include <NdbOut.hpp>
void GlobalDictCache::printCache()
{
DBUG_ENTER("GlobalDictCache::printCache");
NdbElement_t<Vector<TableVersion> > * curr = m_tableHash.getNext(0);
while(curr != 0){
DBUG_PRINT("curr", ("len: %d, hash: %d, lk: %d, str: %s",
curr->len, curr->hash, curr->localkey1, curr->str));
if (curr->theData){
Vector<TableVersion> * vers = curr->theData;
const unsigned sz = vers->size();
for(unsigned i = 0; i<sz ; i++){
TableVersion tv= (*vers)[i];
DBUG_PRINT(" ", ("vers[%d]: ver: %d, refCount: %d, status: %d",
sz, tv.m_version, tv.m_refCount, tv.m_status));
if(tv.m_impl != 0)
{
DBUG_PRINT(" ", ("m_impl: internalname: %s",
tv.m_impl->m_internalName.c_str()));
}
}
}
else
{
DBUG_PRINT(" ", ("NULL"));
}
curr = m_tableHash.getNext(curr);
}
DBUG_VOID_RETURN;
}
NdbTableImpl *
NdbTableImpl *
GlobalDictCache::get(const char * name)
{
DBUG_ENTER("GlobalDictCache::get");
DBUG_PRINT("enter", ("name: %s", name));
const Uint32 len = strlen(name);
Vector<TableVersion> * versions = 0;
Vector<TableVersion> * versions = 0;
versions = m_tableHash.getData(name, len);
if(versions == 0){
versions = new Vector<TableVersion>(2);
@ -121,7 +156,7 @@ GlobalDictCache::get(const char * name)
switch(ver->m_status){
case OK:
ver->m_refCount++;
return ver->m_impl;
DBUG_RETURN(ver->m_impl);
case DROPPED:
retreive = true; // Break loop
break;
@ -140,24 +175,28 @@ GlobalDictCache::get(const char * name)
tmp.m_status = RETREIVING;
tmp.m_refCount = 1; // The one retreiving it
versions->push_back(tmp);
return 0;
DBUG_RETURN(0);
}
NdbTableImpl *
GlobalDictCache::put(const char * name, NdbTableImpl * tab)
{
DBUG_ENTER("GlobalDictCache::put");
DBUG_PRINT("enter", ("name: %s, internal_name: %s",
name, tab ? tab->m_internalName.c_str() : "tab NULL"));
const Uint32 len = strlen(name);
Vector<TableVersion> * vers = m_tableHash.getData(name, len);
if(vers == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
const Uint32 sz = vers->size();
if(sz == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
@ -170,7 +209,7 @@ GlobalDictCache::put(const char * name, NdbTableImpl * tab)
}
if(tab == 0){
// No table found in db
DBUG_PRINT("info", ("No table found in db"));
vers->erase(sz - 1);
} else {
ver.m_impl = tab;
@ -179,74 +218,84 @@ GlobalDictCache::put(const char * name, NdbTableImpl * tab)
}
NdbCondition_Broadcast(m_waitForTableCondition);
return tab;
DBUG_RETURN(tab);
}
void
GlobalDictCache::drop(NdbTableImpl * tab)
{
DBUG_ENTER("GlobalDictCache::drop");
DBUG_PRINT("enter", ("internal_name: %s", tab->m_internalName.c_str()));
unsigned i;
const Uint32 len = strlen(tab->m_internalName.c_str());
Vector<TableVersion> * vers =
m_tableHash.getData(tab->m_internalName.c_str(), len);
if(vers == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
const Uint32 sz = vers->size();
if(sz == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
for(i = 0; i < sz; i++){
TableVersion & ver = (* vers)[i];
if(ver.m_impl == tab){
if(ver.m_refCount == 0 || ver.m_status == RETREIVING ||
if(ver.m_refCount == 0 || ver.m_status == RETREIVING ||
ver.m_version != tab->m_version){
ndbout_c("Dropping with refCount=%d status=%d impl=%p",
ver.m_refCount, ver.m_status, ver.m_impl);
DBUG_PRINT("info", ("Dropping with refCount=%d status=%d impl=%p",
ver.m_refCount, ver.m_status, ver.m_impl));
break;
}
DBUG_PRINT("info", ("Found table to drop, i: %d, name: %s",
i, ver.m_impl->m_internalName.c_str()));
ver.m_refCount--;
ver.m_status = DROPPED;
if(ver.m_refCount == 0){
DBUG_PRINT("info", ("refCount is zero, deleting m_impl"))
delete ver.m_impl;
vers->erase(i);
}
return;
DBUG_VOID_RETURN;
}
}
for(i = 0; i<sz; i++){
TableVersion & ver = (* vers)[i];
ndbout_c("%d: version: %d refCount: %d status: %d impl: %p",
i, ver.m_version, ver.m_refCount, ver.m_status, ver.m_impl);
DBUG_PRINT("info", ("%d: version: %d refCount: %d status: %d impl: %p",
i, ver.m_version, ver.m_refCount,
ver.m_status, ver.m_impl));
}
abort();
}
void
GlobalDictCache::release(NdbTableImpl * tab){
GlobalDictCache::release(NdbTableImpl * tab)
{
DBUG_ENTER("GlobalDictCache::release");
DBUG_PRINT("enter", ("internal_name: %s", tab->m_internalName.c_str()));
unsigned i;
const Uint32 len = strlen(tab->m_internalName.c_str());
Vector<TableVersion> * vers =
m_tableHash.getData(tab->m_internalName.c_str(), len);
if(vers == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
const Uint32 sz = vers->size();
if(sz == 0){
// Should always tried to retreive it first
// and then there should be a record
// and thus there should be a record
abort();
}
@ -255,20 +304,21 @@ GlobalDictCache::release(NdbTableImpl * tab){
if(ver.m_impl == tab){
if(ver.m_refCount == 0 || ver.m_status == RETREIVING ||
ver.m_version != tab->m_version){
ndbout_c("Releasing with refCount=%d status=%d impl=%p",
ver.m_refCount, ver.m_status, ver.m_impl);
DBUG_PRINT("info", ("Releasing with refCount=%d status=%d impl=%p",
ver.m_refCount, ver.m_status, ver.m_impl));
break;
}
ver.m_refCount--;
return;
DBUG_VOID_RETURN;
}
}
for(i = 0; i<sz; i++){
TableVersion & ver = (* vers)[i];
ndbout_c("%d: version: %d refCount: %d status: %d impl: %p",
i, ver.m_version, ver.m_refCount, ver.m_status, ver.m_impl);
DBUG_PRINT("info", ("%d: version: %d refCount: %d status: %d impl: %p",
i, ver.m_version, ver.m_refCount,
ver.m_status, ver.m_impl));
}
abort();

2
ndb/src/ndbapi/DictCache.hpp
View file

@ -76,6 +76,8 @@ public:
};
private:
void printCache();
struct TableVersion {
Uint32 m_version;
Uint32 m_refCount;

107
ndb/src/ndbapi/Ndb.cpp
View file

@ -751,16 +751,14 @@ 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.
****************************************************************************/
#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 @@ Ndb::getTupleIdFromNdb(Uint32 aTableId, Uint32 cacheSize)
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 @@ Ndb::readAutoIncrementValue(const char* aTableName)
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 @@ Ndb::readTupleIdFromNdb(Uint32 aTableId)
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,25 +1142,63 @@ Ndb::externalizeIndexName(const char * internalIndexName)
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)
{

4
ndb/src/ndbapi/NdbDictionary.cpp
View file

@ -773,9 +773,11 @@ NdbDictionary::Dictionary::getTable(const char * name) const
void
NdbDictionary::Dictionary::invalidateTable(const char * name){
DBUG_ENTER("NdbDictionaryImpl::invalidateTable");
NdbTableImpl * t = m_impl.getTable(name);
if(t)
m_impl.invalidateObject(* t);
DBUG_VOID_RETURN;
}
void
@ -811,11 +813,13 @@ NdbDictionary::Dictionary::getIndex(const char * indexName,
void
NdbDictionary::Dictionary::invalidateIndex(const char * indexName,
const char * tableName){
DBUG_ENTER("NdbDictionaryImpl::invalidateIndex");
NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
if(i) {
assert(i->m_table != 0);
m_impl.invalidateObject(* i->m_table);
}
DBUG_VOID_RETURN;
}
void

134
ndb/src/ndbapi/NdbDictionaryImpl.cpp
View file

@ -735,19 +735,19 @@ NdbDictionaryImpl::~NdbDictionaryImpl()
}
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 @@ NdbDictionaryImpl::fetchGlobalTableImpl(const char * internalTableName)
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 @@ NdbDictionaryImpl::setTransporter(class Ndb* ndb,
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 @@ NdbDictInterface::dictSignal(NdbApiSignal* signal,
}
DBUG_RETURN(-1);
}
#if 0
/*
Get dictionary information for a table using table id as reference
@ -1079,6 +1078,7 @@ NdbDictInterface::getTable(int tableId, bool fullyQualifiedNames)
return getTable(&tSignal, 0, 0, fullyQualifiedNames);
}
#endif
/*
@ -1090,36 +1090,31 @@ NdbDictInterface::getTable(int tableId, bool fullyQualifiedNames)
*/
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 @@ NdbDictionaryImpl::createTable(NdbTableImpl &t)
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 @@ NdbDictionaryImpl::createBlobTables(NdbTableImpl &t)
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 @@ NdbDictInterface::createTable(Ndb & ndb,
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 @@ NdbDictInterface::createOrAlterTable(Ndb & ndb,
//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 @@ NdbDictionaryImpl::dropTable(const char * name)
// 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 @@ int
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 @@ NdbDictionaryImpl::removeCachedObject(NdbTableImpl & impl)
* 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 @@ NdbDictionaryImpl::getIndexImpl(const char * externalName,
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 @@ NdbDictInterface::createIndex(Ndb & ndb,
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 @@ NdbDictionaryImpl::dropIndex(const char * indexName,
// 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 @@ NdbDictionaryImpl::dropIndex(NdbIndexImpl & impl, const char * tableName)
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 @@ NdbDictInterface::createEvent(class Ndb & ndb,
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();

78
ndb/src/ndbapi/NdbDictionaryImpl.hpp
View file

@ -19,7 +19,6 @@
#include <ndb_types.h>
#include <kernel_types.h>
#include <ndb_limits.h>
#include <NdbError.hpp>
#include <BaseString.hpp>
#include <Vector.hpp>
@ -309,8 +308,8 @@ public:
int listObjects(NdbDictionary::Dictionary::List& list, Uint32 requestData, bool fullyQualifiedNames);
int listObjects(NdbApiSignal* signal);
NdbTableImpl * getTable(int tableId, bool fullyQualifiedNames);
NdbTableImpl * getTable(const char * name, bool fullyQualifiedNames);
/* NdbTableImpl * getTable(int tableId, bool fullyQualifiedNames); */
NdbTableImpl * getTable(const BaseString& name, bool fullyQualifiedNames);
NdbTableImpl * getTable(class NdbApiSignal * signal,
LinearSectionPtr ptr[3],
Uint32 noOfSections, bool fullyQualifiedNames);
@ -368,8 +367,6 @@ private:
Uint32 m_fragmentId;
UtilBuffer m_buffer;
// Buffer used when requesting a table by name
UtilBuffer m_namebuf;
};
class NdbDictionaryImpl : public NdbDictionary::Dictionary {
@ -406,13 +403,12 @@ public:
int listObjects(List& list, NdbDictionary::Object::Type type);
int listIndexes(List& list, Uint32 indexId);
NdbTableImpl * getTable(const char * tableName, void **data= 0);
Ndb_local_table_info * get_local_table_info(const char * internalName,
bool do_add_blob_tables);
Ndb_local_table_info* get_local_table_info(
const BaseString& internalTableName, bool do_add_blob_tables);
NdbIndexImpl * getIndex(const char * indexName,
const char * tableName);
NdbIndexImpl * getIndexImpl(const char * name, const char * internalName);
NdbEventImpl * getEvent(const char * eventName);
NdbEventImpl * getEventImpl(const char * internalName);
@ -430,7 +426,9 @@ public:
NdbDictInterface m_receiver;
Ndb & m_ndb;
private:
Ndb_local_table_info * fetchGlobalTableImpl(const char * internalName);
NdbIndexImpl * getIndexImpl(const char * name,
const BaseString& internalName);
Ndb_local_table_info * fetchGlobalTableImpl(const BaseString& internalName);
};
inline
@ -638,26 +636,27 @@ NdbDictionaryImpl::getImpl(const NdbDictionary::Dictionary & t){
*/
inline
NdbTableImpl *
NdbDictionaryImpl::getTable(const char * tableName, void **data)
NdbTableImpl *
NdbDictionaryImpl::getTable(const char * table_name, void **data)
{
const BaseString internal_tabname(m_ndb.internalize_table_name(table_name));
Ndb_local_table_info *info=
get_local_table_info(m_ndb.internalizeTableName(tableName), true);
if (info == 0) {
get_local_table_info(internal_tabname, true);
if (info == 0)
return 0;
}
if (data) {
if (data)
*data= info->m_local_data;
}
return info->m_table_impl;
}
inline
Ndb_local_table_info *
NdbDictionaryImpl::get_local_table_info(const char * internalTableName,
NdbDictionaryImpl::get_local_table_info(const BaseString& internalTableName,
bool do_add_blob_tables)
{
Ndb_local_table_info *info= m_localHash.get(internalTableName);
Ndb_local_table_info *info= m_localHash.get(internalTableName.c_str());
if (info == 0) {
info= fetchGlobalTableImpl(internalTableName);
if (info == 0) {
@ -672,34 +671,35 @@ NdbDictionaryImpl::get_local_table_info(const char * internalTableName,
inline
NdbIndexImpl *
NdbDictionaryImpl::getIndex(const char * indexName,
const char * tableName)
NdbDictionaryImpl::getIndex(const char * index_name,
const char * table_name)
{
if (tableName || m_ndb.usingFullyQualifiedNames()) {
const char * internalIndexName = 0;
if (tableName) {
NdbTableImpl * t = getTable(tableName);
if (t != 0)
internalIndexName = m_ndb.internalizeIndexName(t, indexName);
} else {
internalIndexName =
m_ndb.internalizeTableName(indexName); // Index is also a table
}
if (internalIndexName) {
Ndb_local_table_info * info = get_local_table_info(internalIndexName,
false);
if (info) {
NdbTableImpl * tab = info->m_table_impl;
if (table_name || m_ndb.usingFullyQualifiedNames())
{
const BaseString internal_indexname(
(table_name)
?
m_ndb.internalize_index_name(getTable(table_name), index_name)
:
m_ndb.internalize_table_name(index_name)); // Index is also a table
if (internal_indexname.length())
{
Ndb_local_table_info * info=
get_local_table_info(internal_indexname, false);
if (info)
{
NdbTableImpl * tab= info->m_table_impl;
if (tab->m_index == 0)
tab->m_index = getIndexImpl(indexName, internalIndexName);
tab->m_index= getIndexImpl(index_name, internal_indexname);
if (tab->m_index != 0)
tab->m_index->m_table = tab;
tab->m_index->m_table= tab;
return tab->m_index;
}
}
}
m_error.code = 4243;
m_error.code= 4243;
return 0;
}

18
ndb/src/ndbapi/NdbImpl.hpp
View file

@ -65,7 +65,6 @@ public:
BaseString m_schemaname; // Schema name
BaseString m_prefix; // Buffer for preformatted internal name <db>/<schema>/
BaseString m_internalname;
void update_prefix()
{
@ -73,23 +72,6 @@ public:
m_schemaname.c_str(), table_name_separator);
}
const char* internalize_table_name(const char* ext_name)
{
// Internal table name format <db>/<schema>/<table>
return m_internalname.assign(m_prefix).append(ext_name).c_str();
}
const char* internalize_index_name(const NdbTableImpl *table,
const char* ext_name)
{
// Internal index name format <db>/<schema>/<tabid>/<table>
return m_internalname.assign(m_prefix).appfmt("%d%c%s",
table->m_tableId,
table_name_separator,
ext_name).c_str();
}
};
#ifdef VM_TRACE

5
ndb/src/ndbapi/NdbLinHash.hpp
View file

@ -192,7 +192,7 @@ template <class C>
inline
Int32
NdbLinHash<C>::insertKey( const char* str, Uint32 len, Uint32 lkey1, C* data )
{
{
const Uint32 hash = Hash(str, len);
int dir, seg;
getBucket(hash, &dir, &seg);
@ -219,8 +219,9 @@ NdbLinHash<C>::insertKey( const char* str, Uint32 len, Uint32 lkey1, C* data )
chain->localkey1 = lkey1;
chain->next = 0;
chain->theData = data;
len++; // Null terminated
chain->str = new Uint32[((len + 3) >> 2)];
memcpy( &chain->str[0], str, len );
memcpy( &chain->str[0], str, len);
if (oldChain != 0)
oldChain->next = chain;
else

8
ndb/src/ndbapi/NdbTransaction.cpp
View file

@ -25,7 +25,6 @@
#include "TransporterFacade.hpp"
#include "API.hpp"
#include "NdbBlob.hpp"
#include <ndb_limits.h>
#include <signaldata/TcKeyConf.hpp>
#include <signaldata/TcIndx.hpp>
@ -1287,10 +1286,9 @@ NdbTransaction::getNdbIndexOperation(const char* anIndexName,
{
// This unique index is defined from SQL level
static const char* uniqueSuffix= "$unique";
char uniqueIndexName[MAX_TAB_NAME_SIZE];
strxnmov(uniqueIndexName, MAX_TAB_NAME_SIZE, anIndexName, uniqueSuffix, NullS);
index = theNdb->theDictionary->getIndex(uniqueIndexName,
BaseString uniqueIndexName(anIndexName);
uniqueIndexName.append(uniqueSuffix);
index = theNdb->theDictionary->getIndex(uniqueIndexName.c_str(),
aTableName);
}
else

2
sql/ha_ndbcluster.cc
View file

@ -4709,7 +4709,7 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path,
List_iterator_fast<char> it2(create_list);
while ((file_name=it2++))
{
DBUG_PRINT("info", ("Table %s need discovery", name));
DBUG_PRINT("info", ("Table %s need discovery", file_name));
if (ha_create_table_from_engine(thd, db, file_name, TRUE) == 0)
files->push_back(thd->strdup(file_name));
}