mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-14 19:07:15 +02:00
Code Issues Projects Releases Packages Wiki Activity

Merge mskold@bk-internal.mysql.com:/home/bk/mysql-4.1-ndb

Browse source 
into mysql.com:/usr/local/home/marty/MySQL/mysql-4.1-ndb


ndb/src/ndbapi/NdbConnection.cpp:
  Auto merged
This commit is contained in:
unknown 2004-08-19 11:13:49 +02:00
commit 149d9e2f4d
13 changed files with 380 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1416,9 +1416,14 @@ public:
*/
Uint64 getAutoIncrementValue(const char* aTableName,
Uint32 cacheSize = 1);
Uint64 getAutoIncrementValue(NdbDictionary::Table * aTable,
Uint32 cacheSize = 1);
Uint64 readAutoIncrementValue(const char* aTableName);
Uint64 readAutoIncrementValue(NdbDictionary::Table * aTable);
bool setAutoIncrementValue(const char* aTableName, Uint64 val,
bool increase = false);
bool setAutoIncrementValue(NdbDictionary::Table * aTable, Uint64 val,
bool increase = false);
Uint64 getTupleIdFromNdb(const char* aTableName,
Uint32 cacheSize = 1000);
Uint64 getTupleIdFromNdb(Uint32 aTableId,

11
ndb/include/ndbapi/NdbConnection.hpp
View file

@ -19,6 +19,7 @@
#include <ndb_types.h>
#include <NdbError.hpp>
#include <NdbDictionary.hpp>
class NdbConnection;
class NdbOperation;
@ -440,6 +441,14 @@ public:
*/
int executePendingBlobOps(Uint8 flags = 0xFF);
// Fast path calls for MySQL ha_ndbcluster
NdbOperation* getNdbOperation(NdbDictionary::Table * table);
NdbIndexOperation* getNdbIndexOperation(NdbDictionary::Index * index,
NdbDictionary::Table * table);
NdbScanOperation* getNdbScanOperation(NdbDictionary::Table * table);
NdbIndexScanOperation* getNdbIndexScanOperation(NdbDictionary::Index * index,
NdbDictionary::Table * table);
private:
/**
* Release completed operations
@ -553,6 +562,8 @@ private:
NdbIndexOperation* getNdbIndexOperation(class NdbIndexImpl* anIndex,
class NdbTableImpl* aTable,
NdbOperation* aNextOp = 0);
NdbIndexScanOperation* getNdbIndexScanOperation(NdbIndexImpl* index,
NdbTableImpl* table);
void handleExecuteCompletion();

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

@ -736,6 +736,17 @@ Ndb::getAutoIncrementValue(const char* aTableName, Uint32 cacheSize)
return tupleId;
}
Uint64
Ndb::getAutoIncrementValue(NdbDictionary::Table * aTable, Uint32 cacheSize)
{
DEBUG_TRACE("getAutoIncrementValue");
if (aTable == 0)
return ~0;
const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
Uint64 tupleId = getTupleIdFromNdb(table->m_tableId, cacheSize);
return tupleId;
}
Uint64
Ndb::getTupleIdFromNdb(const char* aTableName, Uint32 cacheSize)
{
@ -770,6 +781,17 @@ Ndb::readAutoIncrementValue(const char* aTableName)
return tupleId;
}
Uint64
Ndb::readAutoIncrementValue(NdbDictionary::Table * aTable)
{
DEBUG_TRACE("readtAutoIncrementValue");
if (aTable == 0)
return ~0;
const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
Uint64 tupleId = readTupleIdFromNdb(table->m_tableId);
return tupleId;
}
Uint64
Ndb::readTupleIdFromNdb(Uint32 aTableId)
{
@ -790,6 +812,16 @@ Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
return setTupleIdInNdb(table->m_tableId, val, increase);
}
bool
Ndb::setAutoIncrementValue(NdbDictionary::Table * aTable, Uint64 val, bool increase)
{
DEBUG_TRACE("setAutoIncrementValue " << val);
if (aTable == 0)
return ~0;
const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
return setTupleIdInNdb(table->m_tableId, val, increase);
}
bool
Ndb::setTupleIdInNdb(const char* aTableName, Uint64 val, bool increase )
{

62
ndb/src/ndbapi/NdbConnection.cpp
View file

@ -995,6 +995,14 @@ NdbConnection::getNdbOperation(NdbTableImpl * tab, NdbOperation* aNextOp)
return NULL;
}//NdbConnection::getNdbOperation()
NdbOperation* NdbConnection::getNdbOperation(NdbDictionary::Table * table)
{
if (table)
return getNdbOperation(& NdbTableImpl::getImpl(*table));
else
return NULL;
}//NdbConnection::getNdbOperation()
// NdbScanOperation
/*****************************************************************************
NdbScanOperation* getNdbScanOperation(const char* aTableName);
@ -1037,15 +1045,24 @@ Remark: Get an operation from NdbScanOperation idlelist and get the NdbC
NdbIndexScanOperation*
NdbConnection::getNdbIndexScanOperation(const char* anIndexName,
const char* aTableName)
{
NdbIndexImpl* index =
theNdb->theDictionary->getIndex(anIndexName, aTableName);
NdbTableImpl* table = theNdb->theDictionary->getTable(aTableName);
return getNdbIndexScanOperation(index, table);
}
NdbIndexScanOperation*
NdbConnection::getNdbIndexScanOperation(NdbIndexImpl* index,
NdbTableImpl* table)
{
if (theCommitStatus == Started){
NdbIndexImpl* index =
theNdb->theDictionary->getIndex(anIndexName, aTableName);
NdbTableImpl* table = theNdb->theDictionary->getTable(aTableName);
NdbTableImpl* indexTable =
theNdb->theDictionary->getIndexTable(index, table);
const NdbTableImpl * indexTable = index->getIndexTable();
if (indexTable != 0){
NdbIndexScanOperation* tOp = getNdbScanOperation(indexTable);
NdbIndexScanOperation* tOp =
getNdbScanOperation((NdbTableImpl *) indexTable);
tOp->m_currentTable = table;
if(tOp) tOp->m_cursor_type = NdbScanOperation::IndexCursor;
return tOp;
} else {
@ -1056,7 +1073,18 @@ NdbConnection::getNdbIndexScanOperation(const char* anIndexName,
setOperationErrorCodeAbort(4114);
return NULL;
}//NdbConnection::getNdbScanOperation()
}//NdbConnection::getNdbIndexScanOperation()
NdbIndexScanOperation*
NdbConnection::getNdbIndexScanOperation(NdbDictionary::Index * index,
NdbDictionary::Table * table)
{
if (index && table)
return getNdbIndexScanOperation(& NdbIndexImpl::getImpl(*index),
& NdbTableImpl::getImpl(*table));
else
return NULL;
}//NdbConnection::getNdbIndexScanOperation()
/*****************************************************************************
NdbScanOperation* getNdbScanOperation(int aTableId);
@ -1097,6 +1125,14 @@ getNdbOp_error1:
return NULL;
}//NdbConnection::getNdbScanOperation()
NdbScanOperation*
NdbConnection::getNdbScanOperation(NdbDictionary::Table * table)
{
if (table)
return getNdbScanOperation(& NdbTableImpl::getImpl(*table));
else
return NULL;
}//NdbConnection::getNdbScanOperation()
// IndexOperation
@ -1191,6 +1227,18 @@ NdbConnection::getNdbIndexOperation(NdbIndexImpl * anIndex,
return NULL;
}//NdbConnection::getNdbIndexOperation()
NdbIndexOperation*
NdbConnection::getNdbIndexOperation(NdbDictionary::Index * index,
NdbDictionary::Table * table)
{
if (index && table)
return getNdbIndexOperation(& NdbIndexImpl::getImpl(*index),
& NdbTableImpl::getImpl(*table));
else
return NULL;
}//NdbConnection::getNdbIndexOperation()
/*******************************************************************************
int receiveDIHNDBTAMPER(NdbApiSignal* aSignal)

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

@ -492,6 +492,12 @@ NdbIndexImpl::getTable() const
return m_tableName.c_str();
}
const NdbTableImpl *
NdbIndexImpl::getIndexTable() const
{
return m_table;
}
/**
* NdbEventImpl
*/

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

@ -170,6 +170,7 @@ public:
const char * getName() const;
void setTable(const char * table);
const char * getTable() const;
const NdbTableImpl * getIndexTable() const;
Uint32 m_indexId;
BaseString m_internalName;

15
ndb/src/ndbapi/NdbScanOperation.cpp
View file

@ -188,12 +188,15 @@ NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
m_keyInfo = lockExcl;
bool range = false;
if (m_currentTable->m_indexType == NdbDictionary::Index::OrderedIndex ||
m_currentTable->m_indexType == NdbDictionary::Index::UniqueOrderedIndex){
assert(m_currentTable == m_accessTable);
m_currentTable = theNdb->theDictionary->
getTable(m_currentTable->m_primaryTable.c_str());
assert(m_currentTable != NULL);
if (m_accessTable->m_indexType == NdbDictionary::Index::OrderedIndex ||
m_accessTable->m_indexType == NdbDictionary::Index::UniqueOrderedIndex){
if (m_currentTable == m_accessTable){
// Old way of scanning indexes, should not be allowed
m_currentTable = theNdb->theDictionary->
getTable(m_currentTable->m_primaryTable.c_str());
assert(m_currentTable != NULL);
}
assert (m_currentTable != m_accessTable);
// Modify operation state
theStatus = SetBound;
theOperationType = OpenRangeScanRequest;