From 4c90c593af42920263c79718b98dc726123788f5 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 26 May 2004 13:24:14 +0200
Subject: [PATCH 001/579] wl1671 - Sorted scan
---
.../kernel/signaldata/CreateFragmentation.hpp | 2 +-
ndb/include/kernel/signaldata/DictTabInfo.hpp | 2 +
ndb/include/kernel/signaldata/DropTab.hpp | 3 +-
ndb/include/kernel/signaldata/KeyInfo.hpp | 1 +
ndb/include/kernel/signaldata/PrepDropTab.hpp | 6 +-
ndb/include/kernel/signaldata/ScanTab.hpp | 81 +-
ndb/include/kernel/signaldata/TcCommit.hpp | 1 +
ndb/include/kernel/signaldata/TcKeyReq.hpp | 1 +
ndb/include/ndbapi/Ndb.hpp | 18 +-
ndb/include/ndbapi/NdbApi.hpp | 2 +
ndb/include/ndbapi/NdbConnection.hpp | 149 +-
ndb/include/ndbapi/NdbCursorOperation.hpp | 73 -
ndb/include/ndbapi/NdbIndexOperation.hpp | 2 +-
ndb/include/ndbapi/NdbIndexScanOperation.hpp | 140 ++
ndb/include/ndbapi/NdbOperation.hpp | 238 +--
ndb/include/ndbapi/NdbRecAttr.hpp | 51 +-
ndb/include/ndbapi/NdbReceiver.hpp | 69 +-
ndb/include/ndbapi/NdbResultSet.hpp | 49 +-
ndb/include/ndbapi/NdbScanOperation.hpp | 227 +--
.../debugger/signaldata/DictTabInfo.cpp | 2 +
.../common/debugger/signaldata/ScanTab.cpp | 49 +-
ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp | 2 +
ndb/src/kernel/blocks/dbdict/Dbdict.cpp | 57 +-
ndb/src/kernel/blocks/dbdict/Dbdict.hpp | 2 +-
ndb/src/kernel/blocks/dbdih/DbdihInit.cpp | 1 +
ndb/src/kernel/blocks/dbdih/DbdihMain.cpp | 19 +
ndb/src/kernel/blocks/dblqh/DblqhMain.cpp | 179 +-
ndb/src/kernel/blocks/dbtc/Dbtc.hpp | 253 ++-
ndb/src/kernel/blocks/dbtc/DbtcInit.cpp | 38 +-
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 1458 +++++----------
ndb/src/kernel/blocks/dbtup/Dbtup.hpp | 9 +-
ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp | 295 ++-
.../kernel/blocks/dbtup/DbtupExecQuery.cpp | 50 +-
ndb/src/kernel/blocks/dbtup/DbtupGen.cpp | 2 -
ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp | 2 +-
ndb/src/ndbapi/Makefile | 14 +-
ndb/src/ndbapi/Ndb.cpp | 53 +-
ndb/src/ndbapi/NdbApiSignal.cpp | 3 +-
ndb/src/ndbapi/NdbConnection.cpp | 492 ++---
ndb/src/ndbapi/NdbConnectionScan.cpp | 532 +-----
ndb/src/ndbapi/NdbCursorOperation.cpp | 6 -
ndb/src/ndbapi/NdbDictionaryImpl.cpp | 9 +-
ndb/src/ndbapi/NdbDictionaryImpl.hpp | 4 +-
ndb/src/ndbapi/NdbEventOperationImpl.cpp | 26 +-
ndb/src/ndbapi/NdbImpl.hpp | 11 +-
ndb/src/ndbapi/NdbIndexOperation.cpp | 6 +-
ndb/src/ndbapi/NdbOperation.cpp | 59 +-
ndb/src/ndbapi/NdbOperationDefine.cpp | 121 +-
ndb/src/ndbapi/NdbOperationExec.cpp | 379 +---
ndb/src/ndbapi/NdbOperationInt.cpp | 28 +-
ndb/src/ndbapi/NdbOperationScan.cpp | 560 ------
ndb/src/ndbapi/NdbRecAttr.cpp | 18 +
ndb/src/ndbapi/NdbReceiver.cpp | 172 +-
ndb/src/ndbapi/NdbResultSet.cpp | 31 +-
ndb/src/ndbapi/NdbScanOperation.cpp | 1653 ++++++++++++-----
ndb/src/ndbapi/Ndbif.cpp | 264 ++-
ndb/src/ndbapi/Ndblist.cpp | 39 +-
ndb/src/ndbapi/ObjectMap.hpp | 41 +-
ndb/src/ndbapi/ScanOperation.txt | 46 +
ndb/test/include/HugoTransactions.hpp | 30 +-
ndb/test/include/UtilTransactions.hpp | 14 +-
ndb/test/ndbapi/Makefile | 4 +-
ndb/test/ndbapi/testBackup/Makefile | 1 -
ndb/test/ndbapi/testBackup/testBackup.cpp | 5 +-
.../testDataBuffers/testDataBuffers.cpp | 10 +-
ndb/test/ndbapi/testGrep/Makefile | 1 -
ndb/test/ndbapi/testGrep/testGrep.cpp | 7 +-
ndb/test/ndbapi/testGrep/verify/Makefile | 1 -
ndb/test/ndbapi/testIndex/testIndex.cpp | 2 +-
ndb/test/ndbapi/testOIBasic/testOIBasic.cpp | 20 +-
ndb/test/ndbapi/testScan/ScanFunctions.hpp | 72 +-
.../testScanInterpreter/ScanInterpretTest.hpp | 52 +-
ndb/test/src/HugoOperations.cpp | 4 +
ndb/test/src/HugoTransactions.cpp | 174 +-
ndb/test/src/NDBT_Tables.cpp | 2 +-
ndb/test/src/UtilTransactions.cpp | 270 +--
ndb/tools/create_index/create_index.cpp | 20 +-
ndb/tools/select_all/select_all.cpp | 64 +-
78 files changed, 3523 insertions(+), 5330 deletions(-)
create mode 100644 ndb/include/ndbapi/NdbIndexScanOperation.hpp
diff --git a/ndb/include/kernel/signaldata/CreateFragmentation.hpp b/ndb/include/kernel/signaldata/CreateFragmentation.hpp
index a2f45a9580d..7d53dd91154 100644
--- a/ndb/include/kernel/signaldata/CreateFragmentation.hpp
+++ b/ndb/include/kernel/signaldata/CreateFragmentation.hpp
@@ -88,7 +88,7 @@ class CreateFragmentationConf {
friend bool printCREATE_FRAGMENTATION_CONF(FILE *,
const Uint32 *, Uint32, Uint16);
public:
- STATIC_CONST( SignalLength = 3 );
+ STATIC_CONST( SignalLength = 4 );
SECTION( FRAGMENTS = 0 );
private:
diff --git a/ndb/include/kernel/signaldata/DictTabInfo.hpp b/ndb/include/kernel/signaldata/DictTabInfo.hpp
index 791388d5df8..813b0063d35 100644
--- a/ndb/include/kernel/signaldata/DictTabInfo.hpp
+++ b/ndb/include/kernel/signaldata/DictTabInfo.hpp
@@ -100,6 +100,7 @@ public:
CustomTriggerId = 25,
FrmLen = 26,
FrmData = 27,
+ FragmentCount = 128, // No of fragments in table (!fragment replicas)
TableEnd = 999,
AttributeName = 1000, // String, Mandatory
@@ -277,6 +278,7 @@ public:
Uint32 CustomTriggerId;
Uint32 FrmLen;
char FrmData[MAX_FRM_DATA_SIZE];
+ Uint32 FragmentCount;
void init();
};
diff --git a/ndb/include/kernel/signaldata/DropTab.hpp b/ndb/include/kernel/signaldata/DropTab.hpp
index 906f952d852..dd3946d8cc0 100644
--- a/ndb/include/kernel/signaldata/DropTab.hpp
+++ b/ndb/include/kernel/signaldata/DropTab.hpp
@@ -101,7 +101,8 @@ public:
NoSuchTable = 1,
DropWoPrep = 2, // Calling Drop with first calling PrepDrop
PrepDropInProgress = 3,
- DropInProgress = 4
+ DropInProgress = 4,
+ NF_FakeErrorREF = 5
};
private:
diff --git a/ndb/include/kernel/signaldata/KeyInfo.hpp b/ndb/include/kernel/signaldata/KeyInfo.hpp
index b839a2c2035..a4c698f89b2 100644
--- a/ndb/include/kernel/signaldata/KeyInfo.hpp
+++ b/ndb/include/kernel/signaldata/KeyInfo.hpp
@@ -25,6 +25,7 @@ class KeyInfo {
*/
friend class DbUtil;
friend class NdbOperation;
+ friend class NdbScanOperation;
/**
* Reciver(s)
diff --git a/ndb/include/kernel/signaldata/PrepDropTab.hpp b/ndb/include/kernel/signaldata/PrepDropTab.hpp
index e9cc28fed0c..c54b2474aa3 100644
--- a/ndb/include/kernel/signaldata/PrepDropTab.hpp
+++ b/ndb/include/kernel/signaldata/PrepDropTab.hpp
@@ -88,7 +88,8 @@ public:
NoSuchTable = 1,
PrepDropInProgress = 2,
DropInProgress = 3,
- InvalidTableState = 4
+ InvalidTableState = 4,
+ NF_FakeErrorREF = 5
};
private:
@@ -137,7 +138,8 @@ public:
enum ErrorCode {
NoSuchTable = 1,
IllegalTableState = 2,
- DropInProgress = 3
+ DropInProgress = 3,
+ NF_FakeErrorREF = 4
};
Uint32 tableId;
diff --git a/ndb/include/kernel/signaldata/ScanTab.hpp b/ndb/include/kernel/signaldata/ScanTab.hpp
index efd8a4918ab..6cef4381c07 100644
--- a/ndb/include/kernel/signaldata/ScanTab.hpp
+++ b/ndb/include/kernel/signaldata/ScanTab.hpp
@@ -33,8 +33,8 @@ class ScanTabReq {
/**
* Sender(s)
*/
- friend class NdbOperation;
friend class NdbConnection;
+ friend class NdbScanOperation;
/**
* For printing
@@ -73,6 +73,7 @@ private:
static Uint8 getHoldLockFlag(const UintR & requestInfo);
static Uint8 getReadCommittedFlag(const UintR & requestInfo);
static Uint8 getRangeScanFlag(const UintR & requestInfo);
+ static Uint8 getScanBatch(const UintR & requestInfo);
/**
* Set:ers for requestInfo
@@ -83,7 +84,7 @@ private:
static void setHoldLockFlag(UintR & requestInfo, Uint32 flag);
static void setReadCommittedFlag(UintR & requestInfo, Uint32 flag);
static void setRangeScanFlag(UintR & requestInfo, Uint32 flag);
-
+ static void setScanBatch(Uint32& requestInfo, Uint32 sz);
};
/**
@@ -94,10 +95,11 @@ private:
h = Hold lock mode - 1 Bit 10
c = Read Committed - 1 Bit 11
x = Range Scan (TUX) - 1 Bit 15
+ b = Scan batch - 5 Bit 16-19 (max 15)
1111111111222222222233
01234567890123456789012345678901
- ppppppppl hc x
+ ppppppppl hc xbbbbb
*/
#define PARALLELL_SHIFT (0)
@@ -115,6 +117,9 @@ private:
#define RANGE_SCAN_SHIFT (15)
#define RANGE_SCAN_MASK (1)
+#define SCAN_BATCH_SHIFT (16)
+#define SCAN_BATCH_MASK (31)
+
inline
Uint8
ScanTabReq::getParallelism(const UintR & requestInfo){
@@ -145,6 +150,12 @@ ScanTabReq::getRangeScanFlag(const UintR & requestInfo){
return (Uint8)((requestInfo >> RANGE_SCAN_SHIFT) & RANGE_SCAN_MASK);
}
+inline
+Uint8
+ScanTabReq::getScanBatch(const Uint32 & requestInfo){
+ return (Uint8)((requestInfo >> SCAN_BATCH_SHIFT) & SCAN_BATCH_MASK);
+}
+
inline
void
ScanTabReq::clearRequestInfo(UintR & requestInfo){
@@ -186,6 +197,12 @@ ScanTabReq::setRangeScanFlag(UintR & requestInfo, Uint32 flag){
requestInfo |= (flag << RANGE_SCAN_SHIFT);
}
+inline
+void
+ScanTabReq::setScanBatch(Uint32 & requestInfo, Uint32 flag){
+ ASSERT_MAX(flag, SCAN_BATCH_MASK, "ScanTabReq::setScanBatch");
+ requestInfo |= (flag << SCAN_BATCH_SHIFT);
+}
/**
*
@@ -213,7 +230,8 @@ public:
* Length of signal
*/
STATIC_CONST( SignalLength = 4 );
-
+ static const Uint32 EndOfData = (1 << 31);
+
private:
// Type definitions
@@ -225,29 +243,15 @@ private:
UintR requestInfo; // DATA 1
UintR transId1; // DATA 2
UintR transId2; // DATA 3
-#if 0
- UintR operLenAndIdx[16]; // DATA 4-19
-
- /**
- * Get:ers for operLenAndIdx
- */
- static Uint32 getLen(const UintR & operLenAndIdx);
- static Uint8 getIdx(const UintR & operLenAndIdx);
-#endif
-
- /**
- * Get:ers for requestInfo
- */
- static Uint8 getOperations(const UintR & reqInfo);
- static Uint8 getScanStatus(const UintR & reqInfo);
-
- /**
- * Set:ers for requestInfo
- */
- static void setOperations(UintR & reqInfo, Uint32 ops);
- static void setScanStatus(UintR & reqInfo, Uint32 stat);
+ struct OpData {
+ Uint32 apiPtrI;
+ Uint32 tcPtrI;
+ Uint32 info;
+ };
+ static Uint32 getLength(Uint32 opDataInfo) { return opDataInfo >> 5; };
+ static Uint32 getRows(Uint32 opDataInfo) { return opDataInfo & 31;}
};
/**
@@ -267,33 +271,6 @@ private:
#define STATUS_SHIFT (8)
#define STATUS_MASK (0xFF)
-inline
-Uint8
-ScanTabConf::getOperations(const UintR & reqInfo){
- return (Uint8)((reqInfo >> OPERATIONS_SHIFT) & OPERATIONS_MASK);
-}
-
-inline
-void
-ScanTabConf::setOperations(UintR & requestInfo, Uint32 ops){
- ASSERT_MAX(ops, OPERATIONS_MASK, "ScanTabConf::setOperations");
- requestInfo |= (ops << OPERATIONS_SHIFT);
-}
-
-inline
-Uint8
-ScanTabConf::getScanStatus(const UintR & reqInfo){
- return (Uint8)((reqInfo >> STATUS_SHIFT) & STATUS_MASK);
-}
-
-inline
-void
-ScanTabConf::setScanStatus(UintR & requestInfo, Uint32 stat){
- ASSERT_MAX(stat, STATUS_MASK, "ScanTabConf::setScanStatus");
- requestInfo |= (stat << STATUS_SHIFT);
-}
-
-
/**
*
* SENDER: Dbtc, API
diff --git a/ndb/include/kernel/signaldata/TcCommit.hpp b/ndb/include/kernel/signaldata/TcCommit.hpp
index 43eb7be1c39..b7f3fbbb361 100644
--- a/ndb/include/kernel/signaldata/TcCommit.hpp
+++ b/ndb/include/kernel/signaldata/TcCommit.hpp
@@ -33,6 +33,7 @@ class TcCommitConf {
* Reciver(s)
*/
friend class Ndb;
+ friend class NdbConnection;
public:
STATIC_CONST( SignalLength = 3 );
diff --git a/ndb/include/kernel/signaldata/TcKeyReq.hpp b/ndb/include/kernel/signaldata/TcKeyReq.hpp
index df0a00da3e0..f7d3c2e3282 100644
--- a/ndb/include/kernel/signaldata/TcKeyReq.hpp
+++ b/ndb/include/kernel/signaldata/TcKeyReq.hpp
@@ -38,6 +38,7 @@ class TcKeyReq {
friend class Ndbcntr;
friend class NdbOperation;
friend class NdbIndexOperation;
+ friend class NdbScanOperation;
friend class DbUtil;
/**
diff --git a/ndb/include/ndbapi/Ndb.hpp b/ndb/include/ndbapi/Ndb.hpp
index fd6e827ceb4..b02675da4e1 100644
--- a/ndb/include/ndbapi/Ndb.hpp
+++ b/ndb/include/ndbapi/Ndb.hpp
@@ -868,6 +868,7 @@ class NdbObjectIdMap;
class NdbOperation;
class NdbEventOperationImpl;
class NdbScanOperation;
+class NdbIndexScanOperation;
class NdbIndexOperation;
class NdbConnection;
class NdbSchemaOp;
@@ -878,7 +879,6 @@ class NdbLabel;
class NdbBranch;
class NdbSubroutine;
class NdbCall;
-class NdbScanReceiver;
class Table;
class BaseString;
class NdbEventOperation;
@@ -965,8 +965,9 @@ class Ndb
friend class NdbSchemaCon;
friend class Table;
friend class NdbApiSignal;
- friend class NdbScanReceiver;
friend class NdbIndexOperation;
+ friend class NdbScanOperation;
+ friend class NdbIndexScanOperation;
friend class NdbDictionaryImpl;
friend class NdbDictInterface;
@@ -1455,7 +1456,7 @@ private:
NdbConnection* doConnect(Uint32 nodeId);
void doDisconnect();
- NdbScanReceiver* getNdbScanRec();// Get a NdbScanReceiver from idle list
+ NdbReceiver* getNdbScanRec();// Get a NdbScanReceiver from idle list
NdbLabel* getNdbLabel(); // Get a NdbLabel from idle list
NdbBranch* getNdbBranch(); // Get a NdbBranch from idle list
NdbSubroutine* getNdbSubroutine();// Get a NdbSubroutine from idle
@@ -1464,21 +1465,21 @@ private:
NdbRecAttr* getRecAttr(); // Get a receeive attribute object from
// idle list of the Ndb object.
NdbOperation* getOperation(); // Get an operation from idle list
- NdbScanOperation* getScanOperation(); // Get a scan operation from idle
+ NdbIndexScanOperation* getScanOperation(); // Get a scan operation from idle
NdbIndexOperation* getIndexOperation();// Get an index operation from idle
class NdbGlobalEventBufferHandle* getGlobalEventBufferHandle();
void releaseSignal(NdbApiSignal* anApiSignal);
void releaseSignalsInList(NdbApiSignal** pList);
- void releaseNdbScanRec(NdbScanReceiver* aNdbScanRec);
+ void releaseNdbScanRec(NdbReceiver* aNdbScanRec);
void releaseNdbLabel(NdbLabel* anNdbLabel);
void releaseNdbBranch(NdbBranch* anNdbBranch);
void releaseNdbSubroutine(NdbSubroutine* anNdbSubroutine);
void releaseNdbCall(NdbCall* anNdbCall);
void releaseRecAttr (NdbRecAttr* aRecAttr);
void releaseOperation(NdbOperation* anOperation);
- void releaseScanOperation(NdbScanOperation* aScanOperation);
+ void releaseScanOperation(NdbIndexScanOperation*);
void check_send_timeout();
void remove_sent_list(Uint32);
@@ -1574,7 +1575,6 @@ private:
void* int2void (Uint32 val);
NdbReceiver* void2rec (void* val);
NdbConnection* void2con (void* val);
- NdbScanReceiver* void2rec_srec(void* val);
NdbOperation* void2rec_op (void* val);
NdbIndexOperation* void2rec_iop (void* val);
@@ -1614,7 +1614,7 @@ private:
NdbOperation* theOpIdleList; // First operation in the idle list.
- NdbScanOperation* theScanOpIdleList; // First scan operation in the idle list.
+ NdbIndexScanOperation* theScanOpIdleList; // First scan operation in the idle list.
NdbIndexOperation* theIndexOpIdleList; // First index operation in the idle list.
NdbSchemaCon* theSchemaConIdleList; // First schemaCon in idle list.
@@ -1627,7 +1627,7 @@ private:
NdbBranch* theBranchList; // First branch descriptor in list
NdbSubroutine* theSubroutineList; // First subroutine descriptor in
NdbCall* theCallList; // First call descriptor in list
- NdbScanReceiver* theScanList;
+ NdbReceiver* theScanList;
Uint32 theMyRef; // My block reference
Uint32 theNode; // The node number of our node
diff --git a/ndb/include/ndbapi/NdbApi.hpp b/ndb/include/ndbapi/NdbApi.hpp
index e5efc9756ce..cdc48dad039 100644
--- a/ndb/include/ndbapi/NdbApi.hpp
+++ b/ndb/include/ndbapi/NdbApi.hpp
@@ -23,6 +23,8 @@
#include "NdbOperation.hpp"
#include "NdbScanOperation.hpp"
#include "NdbIndexOperation.hpp"
+#include "NdbIndexScanOperation.hpp"
+#include "NdbScanFilter.hpp"
#include "NdbSchemaCon.hpp"
#include "NdbSchemaOp.hpp"
#include "NdbRecAttr.hpp"
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp
index 0245859a632..b6f5aef5947 100644
--- a/ndb/include/ndbapi/NdbConnection.hpp
+++ b/ndb/include/ndbapi/NdbConnection.hpp
@@ -23,12 +23,11 @@
class NdbConnection;
class NdbOperation;
-class NdbCursorOperation;
class NdbScanOperation;
+class NdbIndexScanOperation;
class NdbIndexOperation;
class NdbApiSignal;
class Ndb;
-class NdbScanReceiver;
/**
@@ -131,7 +130,7 @@ class NdbConnection
friend class NdbOperation;
friend class NdbScanOperation;
friend class NdbIndexOperation;
- friend class NdbScanReceiver;
+ friend class NdbIndexScanOperation;
public:
@@ -147,57 +146,32 @@ public:
*/
NdbOperation* getNdbOperation(const char* aTableName);
- /**
- * Get an NdbOperation for index scan of a table.
- * Note that the operation has to be defined before it is executed.
- *
- * @note All operations within the same transaction need to
- * be initialized with this method.
- *
- * @param anIndexName The index name.
- * @param aTableName The table name.
- * @return Pointer to an NdbOperation object if successful, otherwise NULL.
- */
- NdbOperation* getNdbOperation(const char* anIndexName,
- const char* aTableName);
-
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
* Get an operation from NdbScanOperation idlelist and
* get the NdbConnection object which
* was fetched by startTransaction pointing to this operation.
- * This operation will set the theTableId
- * in the NdbOperation object.synchronous.
*
* @param aTableName a table name.
* @return pointer to an NdbOperation object if successful, otherwise NULL
*/
NdbScanOperation* getNdbScanOperation(const char* aTableName);
-#endif
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
* Get an operation from NdbScanOperation idlelist and
* get the NdbConnection object which
* was fetched by startTransaction pointing to this operation.
- * This operation will set the theTableId
- * in the NdbOperation object.synchronous.
*
* @param anIndexName The index name.
* @param aTableName a table name.
* @return pointer to an NdbOperation object if successful, otherwise NULL
*/
- NdbScanOperation* getNdbScanOperation(const char* anIndexName,
- const char* aTableName);
-#endif
-
-
+ NdbIndexScanOperation* getNdbIndexScanOperation(const char* anIndexName,
+ const char* aTableName);
+
/**
* Get an operation from NdbIndexOperation idlelist and
* get the NdbConnection object that
* was fetched by startTransaction pointing to this operation.
- * This operation will set the theTableId
- * in the NdbOperation object. Synchronous.
*
* @param indexName An index name (as created by createIndex).
* @param tableName A table name.
@@ -309,75 +283,6 @@ public:
/** @} *********************************************************************/
- /**
- * @name Scan Transactions
- * @{
- */
-
- /**
- * Execute a scan transaction. This will define
- * and start the scan transaction in the NDB kernel.
- *
- * @return 0 if successful otherwise -1.
- */
- int executeScan();
-
- /**
- * Get the next tuple in a scan transaction.
- *
- * After each call to NdbConnection::nextScanResult
- * the buffers and NdbRecAttr objects defined in
- * NdbOperation::getValue are updated with values
- * from the scanned tuple.
- *
- * @param fetchAllowed If set to false, then fetching is disabled
- *
- * The NDB API will contact the NDB Kernel for more tuples
- * when necessary to do so unless you set the fetchAllowed
- * to false.
- * This will force NDB to process any records it
- * already has in it's caches. When there are no more cached
- * records it will return 2. You must then call nextScanResult
- * with fetchAllowed = true in order to contact NDB for more
- * records.
- *
- * fetchAllowed = false is useful when you want to update or
- * delete all the records fetched in one transaction(This will save a
- * lot of round trip time and make updates or deletes of scanned
- * records a lot faster).
- * While nextScanResult(false)
- * returns 0 take over the record to another transaction. When
- * nextScanResult(false) returns 2 you must execute and commit the other
- * transaction. This will cause the locks to be transferred to the
- * other transaction, updates or deletes will be made and then the
- * locks will be released.
- * After that, call nextScanResult(true) which will fetch new records and
- * cache them in the NdbApi.
- *
- * @note If you don't take over the records to another transaction the
- * locks on those records will be released the next time NDB Kernel
- * is contacted for more records.
- *
- * @note Please contact for examples of efficient scan
- * updates and deletes.
- *
- * @return
- * - -1: if unsuccessful,
- * - 0: if another tuple was received, and
- * - 1: if there are no more tuples to scan.
- * - 2: if there are no more cached records in NdbApi
- */
- int nextScanResult(bool fetchAllowed = true);
-
- /**
- * Stops the scan. Used if no more tuples are wanted.
- * The transaction should still be closed with
- * Ndb::closeTransaction.
- *
- * @return 0 if successful otherwise -1.
- */
- int stopScan();
-
/**
* @name Meta Information
* @{
@@ -536,13 +441,7 @@ private:
int receiveTCINDXCONF(const class TcIndxConf *, Uint32 aDataLength);
int receiveTCINDXREF(NdbApiSignal*);
int receiveSCAN_TABREF(NdbApiSignal*);
- int receiveSCAN_TABCONF(NdbApiSignal*);
- int receiveSCAN_TABINFO(NdbApiSignal*);
-
- int checkNextScanResultComplete();
- int sendScanStart();
- int sendScanNext(bool stopScanFlag);
- int fetchNextScanResult();
+ int receiveSCAN_TABCONF(NdbApiSignal*, const Uint32*, Uint32 len);
int doSend(); // Send all operations
int sendROLLBACK(); // Send of an ROLLBACK
@@ -565,7 +464,7 @@ private:
// Release all cursor operations in connection
void releaseOps(NdbOperation*);
- void releaseCursorOperations(NdbCursorOperation*);
+ void releaseScanOperations(NdbIndexScanOperation*);
// Set the transaction identity of the transaction
void setTransactionId(Uint64 aTransactionId);
@@ -581,7 +480,7 @@ private:
int checkMagicNumber(); // Verify correct object
NdbOperation* getNdbOperation(class NdbTableImpl* aTable);
- NdbScanOperation* getNdbScanOperation(class NdbTableImpl* aTable);
+ NdbIndexScanOperation* getNdbScanOperation(class NdbTableImpl* aTable);
NdbIndexOperation* getNdbIndexOperation(class NdbIndexImpl* anIndex,
class NdbTableImpl* aTable);
@@ -622,7 +521,6 @@ private:
Uint32 theNoOfOpSent; // How many operations have been sent
Uint32 theNoOfOpCompleted; // How many operations have completed
Uint32 theNoOfOpFetched; // How many operations was actually fetched
- Uint32 theNoOfSCANTABCONFRecv; // How many SCAN_TABCONF have been received
Uint32 theMyRef; // Our block reference
Uint32 theTCConPtr; // Transaction Co-ordinator connection pointer.
Uint64 theTransactionId; // theTransactionId of the transaction
@@ -647,20 +545,16 @@ private:
Uint32 theNodeSequence; // The sequence no of the db node
bool theReleaseOnClose;
- // Cursor operations
- bool m_waitForReply;
- NdbCursorOperation* m_theFirstCursorOperation;
- NdbCursorOperation* m_theLastCursorOperation;
-
- NdbCursorOperation* m_firstExecutedCursorOp;
// Scan operations
- bool theScanFinished;
+ bool m_waitForReply;
+ NdbIndexScanOperation* m_theFirstScanOperation;
+ NdbIndexScanOperation* m_theLastScanOperation;
+
+ NdbIndexScanOperation* m_firstExecutedScanOp;
- NdbScanReceiver* theCurrentScanRec; // The current operation to
- // distribute to the app.
- NdbScanReceiver* thePreviousScanRec; // The previous operation read by
- // nextScanResult.
- NdbOperation* theScanningOp; // The operation actually performing the scan
+ // Scan operations
+ // The operation actually performing the scan
+ NdbScanOperation* theScanningOp;
Uint32 theBuddyConPtr;
static void sendTC_COMMIT_ACK(NdbApiSignal *,
@@ -671,6 +565,17 @@ private:
#ifdef VM_TRACE
void printState();
#endif
+
+ bool checkState_TransId(const Uint32 * transId) const {
+ const Uint32 tTmp1 = transId[0];
+ const Uint32 tTmp2 = transId[1];
+ Uint64 tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
+ bool b = theStatus == Connected && theTransactionId == tRecTransId;
+#ifdef NDB_NO_DROPPED_SIGNAL
+ if(!b) abort();
+#endif
+ return b;
+ }
};
inline
diff --git a/ndb/include/ndbapi/NdbCursorOperation.hpp b/ndb/include/ndbapi/NdbCursorOperation.hpp
index cd76b045ea2..e7eeb54ba2d 100644
--- a/ndb/include/ndbapi/NdbCursorOperation.hpp
+++ b/ndb/include/ndbapi/NdbCursorOperation.hpp
@@ -17,77 +17,4 @@
#ifndef NdbCursorOperation_H
#define NdbCursorOperation_H
-#include
-
-class NdbResultSet;
-
-/**
- * @class NdbCursorOperation
- * @brief Operation using cursors
- */
-class NdbCursorOperation : public NdbOperation
-{
- friend class NdbResultSet;
- friend class NdbConnection;
-
-public:
- /**
- * Type of cursor
- */
- enum CursorType {
- NoCursor = 0,
- ScanCursor = 1,
- IndexCursor = 2
- };
-
- /**
- * Lock when performing scan
- */
- enum LockMode {
- LM_Read = 0,
- LM_Exclusive = 1,
- LM_CommittedRead = 2,
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
- LM_Dirty = 2
-#endif
- };
-
- virtual CursorType cursorType() = 0;
-
- /**
- * readTuples returns a NdbResultSet where tuples are stored.
- * Tuples are not stored in NdbResultSet until execute(NoCommit)
- * has been executed and nextResult has been called.
- *
- * @param parallel Scan parallelism
- * @param LockMode Scan lock handling
- * @returns NdbResultSet.
- */
- virtual NdbResultSet* readTuples(unsigned parallel = 0,
- LockMode = LM_Read ) = 0;
-
- inline NdbResultSet* readTuplesExclusive(int parallell = 0){
- return readTuples(parallell, LM_Exclusive);
- }
-
-protected:
- NdbCursorOperation(Ndb* aNdb);
-
- ~NdbCursorOperation();
-
- void cursInit();
-
- virtual int executeCursor(int ProcessorId) = 0;
-
- NdbResultSet* getResultSet();
- NdbResultSet* m_resultSet;
-
-private:
-
- virtual int nextResult(bool fetchAllowed) = 0;
-
- virtual void closeScan() = 0;
-};
-
-
#endif
diff --git a/ndb/include/ndbapi/NdbIndexOperation.hpp b/ndb/include/ndbapi/NdbIndexOperation.hpp
index 3b8e5f7a888..934dbbe6dee 100644
--- a/ndb/include/ndbapi/NdbIndexOperation.hpp
+++ b/ndb/include/ndbapi/NdbIndexOperation.hpp
@@ -29,7 +29,7 @@
#ifndef NdbIndexOperation_H
#define NdbIndexOperation_H
-#include
+#include "NdbOperation.hpp"
class Index;
class NdbResultSet;
diff --git a/ndb/include/ndbapi/NdbIndexScanOperation.hpp b/ndb/include/ndbapi/NdbIndexScanOperation.hpp
new file mode 100644
index 00000000000..3f64880bbc0
--- /dev/null
+++ b/ndb/include/ndbapi/NdbIndexScanOperation.hpp
@@ -0,0 +1,140 @@
+/* Copyright (C) 2003 MySQL AB
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#ifndef NdbIndexScanOperation_H
+#define NdbIndexScanOperation_H
+
+#include
+
+/**
+ * @class NdbIndexScanOperation
+ * @brief Class of scan operations for use to scan ordered index
+ */
+class NdbIndexScanOperation : public NdbScanOperation {
+ friend class Ndb;
+ friend class NdbConnection;
+ friend class NdbResultSet;
+ friend class NdbOperation;
+ friend class NdbScanOperation;
+public:
+ /**
+ * readTuples returns a NdbResultSet where tuples are stored.
+ * Tuples are not stored in NdbResultSet until execute(NoCommit)
+ * has been executed and nextResult has been called.
+ *
+ * @param parallel Scan parallelism
+ * @param batch No of rows to fetch from each fragment at a time
+ * @param LockMode Scan lock handling
+ * @param order_by Order result set in index order
+ * @returns NdbResultSet.
+ * @see NdbScanOperation::readTuples
+ */
+ NdbResultSet* readTuples(LockMode = LM_Read,
+ Uint32 batch = 0,
+ Uint32 parallel = 0,
+ bool order_by = false);
+
+ inline NdbResultSet* readTuples(int parallell){
+ return readTuples(LM_Read, 0, parallell, false);
+ }
+
+ inline NdbResultSet* readTuplesExclusive(int parallell = 0){
+ return readTuples(LM_Exclusive, 0, parallell, false);
+ }
+
+ /**
+ * @name Define Range Scan
+ *
+ * A range scan is a scan on an ordered index. The operation is on
+ * the index table but tuples are returned from the primary table.
+ * The index contains all tuples where at least one index key has not
+ * null value.
+ *
+ * A range scan is currently opened via a normal open scan method.
+ * Bounds can be defined for each index key. After setting bounds,
+ * usual scan methods can be used (get value, interpreter, take over).
+ * These operate on the primary table.
+ *
+ * @{
+ */
+
+ /**
+ * Type of ordered index key bound. The values (0-4) will not change
+ * and can be used explicitly (e.g. they could be computed).
+ */
+ enum BoundType {
+ BoundLE = 0, ///< lower bound,
+ BoundLT = 1, ///< lower bound, strict
+ BoundGE = 2, ///< upper bound
+ BoundGT = 3, ///< upper bound, strict
+ BoundEQ = 4 ///< equality
+ };
+
+ /**
+ * Define bound on index key in range scan.
+ *
+ * Each index key can have not null lower and/or upper bound, or can
+ * be set equal to not null value. The bounds can be defined in any
+ * order but a duplicate definition is an error.
+ *
+ * The scan is most effective when bounds are given for an initial
+ * sequence of non-nullable index keys, and all but the last one is an
+ * equality. In this case the scan returns a contiguous range from
+ * each ordered index fragment.
+ *
+ * @note This release implements only the case described above,
+ * except for the non-nullable limitation. Other sets of
+ * bounds return error or empty result set.
+ *
+ * @note In this release a null key value satisfies any lower
+ * bound and no upper bound. This may change.
+ *
+ * @param attrName Attribute name, alternatively:
+ * @param anAttrId Index column id (starting from 0).
+ * @param type Type of bound
+ * @param value Pointer to bound value
+ * @param len Value length in bytes.
+ * Fixed per datatype and can be omitted
+ * @return 0 if successful otherwise -1
+ */
+ int setBound(const char* attr, int type, const void* aValue, Uint32 len = 0);
+
+ /**
+ * Define bound on index key in range scan using index column id.
+ * See the other setBound() method for details.
+ */
+ int setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len = 0);
+
+ /** @} *********************************************************************/
+
+private:
+ NdbIndexScanOperation(Ndb* aNdb);
+ virtual ~NdbIndexScanOperation();
+
+ int setBound(const NdbColumnImpl*, int type, const void* aValue, Uint32 len);
+
+ virtual int equal_impl(const NdbColumnImpl*, const char*, Uint32);
+ virtual NdbRecAttr* getValue_impl(const NdbColumnImpl*, char*);
+
+ void fix_get_values();
+ int next_result_ordered(bool fetchAllowed);
+ int send_next_scan_ordered(Uint32 idx);
+ int compare(Uint32 key, Uint32 cols, const NdbReceiver*, const NdbReceiver*);
+
+ Uint32 m_sort_columns;
+};
+
+#endif
diff --git a/ndb/include/ndbapi/NdbOperation.hpp b/ndb/include/ndbapi/NdbOperation.hpp
index 0706afa5cb3..c8e4ac3b6a5 100644
--- a/ndb/include/ndbapi/NdbOperation.hpp
+++ b/ndb/include/ndbapi/NdbOperation.hpp
@@ -42,7 +42,8 @@ class NdbOperation
friend class NdbScanReceiver;
friend class NdbScanFilter;
friend class NdbScanFilterImpl;
-
+ friend class NdbReceiver;
+
public:
/**
* @name Define Standard Operation Type
@@ -195,197 +196,8 @@ public:
*/
virtual int interpretedDeleteTuple();
- /**
- * Scan a table to read tuples.
- *
- * The operation only sets a temporary read lock while
- * reading the tuple.
- * The tuple lock is released when the result of the read reaches the
- * application.
- *
- * @param Parallelism Number of parallel tuple reads are performed
- * in the scan.
- * Currently a maximum of 256 parallel tuple
- * reads are allowed.
- * The parallelism can in reality be lower
- * than specified
- * depending on the number of nodes
- * in the cluster
- * @return 0 if successful otherwise -1.
- */
- int openScanRead(Uint32 Parallelism = 16 );
-
- /**
- * Scan a table to write or update tuples.
- *
- * The operation sets an exclusive lock on the tuple and sends the result
- * to the application.
- * Thus when the application reads the data, the tuple is
- * still locked with an exclusive lock.
- *
- * @param parallelism Number of parallel tuple reads are performed
- * in the scan.
- * Currently a maximum of 256 parallel tuple
- * reads are allowed.
- * The parallelism can in reality be lower
- * than specified depending on the number
- * of nodes in the cluster
- * @return 0 if successful otherwise -1.
- *
- */
- int openScanExclusive(Uint32 parallelism = 16);
-
- /**
- * Scan a table to read tuples.
- *
- * The operation only sets a read lock while
- * reading the tuple.
- * Thus when the application reads the data, the tuple is
- * still locked with a read lock.
- *
- * @param parallelism Number of parallel tuple reads are performed
- * in the scan.
- * Currently a maximum of 256 parallel tuple
- * reads are allowed.
- * The parallelism can in reality be lower
- * than specified
- * depending on the number of nodes
- * in the cluster
- * @return 0 if successful otherwise -1.
- */
- int openScanReadHoldLock(Uint32 parallelism = 16);
-
- /**
- * Scan a table to read tuples.
- *
- * The operation does not wait for locks held by other transactions
- * but returns the latest committed tuple instead.
- *
- * @param parallelism Number of parallel tuple reads are performed
- * in the scan.
- * Currently a maximum of 256 parallel tuple
- * reads are allowed.
- * The parallelism can in reality be lower
- * than specified
- * depending on the number of nodes
- * in the cluster
- * @return 0 if successful otherwise -1.
- */
- int openScanReadCommitted(Uint32 parallelism = 16);
-
/** @} *********************************************************************/
- /**
- * @name Define Range Scan
- *
- * A range scan is a scan on an ordered index. The operation is on
- * the index table but tuples are returned from the primary table.
- * The index contains all tuples where at least one index key has not
- * null value.
- *
- * A range scan is currently opened via a normal open scan method.
- * Bounds can be defined for each index key. After setting bounds,
- * usual scan methods can be used (get value, interpreter, take over).
- * These operate on the primary table.
- *
- * @{
- */
-
- /**
- * Type of ordered index key bound. The values (0-4) will not change
- * and can be used explicitly (e.g. they could be computed).
- */
- enum BoundType {
- BoundLE = 0, ///< lower bound,
- BoundLT = 1, ///< lower bound, strict
- BoundGE = 2, ///< upper bound
- BoundGT = 3, ///< upper bound, strict
- BoundEQ = 4 ///< equality
- };
-
- /**
- * Define bound on index key in range scan.
- *
- * Each index key can have not null lower and/or upper bound, or can
- * be set equal to not null value. The bounds can be defined in any
- * order but a duplicate definition is an error.
- *
- * The scan is most effective when bounds are given for an initial
- * sequence of non-nullable index keys, and all but the last one is an
- * equality. In this case the scan returns a contiguous range from
- * each ordered index fragment.
- *
- * @note This release implements only the case described above,
- * except for the non-nullable limitation. Other sets of
- * bounds return error or empty result set.
- *
- * @note In this release a null key value satisfies any lower
- * bound and no upper bound. This may change.
- *
- * @param attrName Attribute name, alternatively:
- * @param anAttrId Index column id (starting from 0).
- * @param type Type of bound
- * @param value Pointer to bound value
- * @param len Value length in bytes.
- * Fixed per datatype and can be omitted
- * @return 0 if successful otherwise -1
- */
- int setBound(const char* anAttrName, int type, const void* aValue, Uint32 len = 0);
-
- /**
- * Define bound on index key in range scan using index column id.
- * See the other setBound() method for details.
- */
- int setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len = 0);
-
- /** @} *********************************************************************/
-
- /**
- * Validate parallelism parameter by checking the number
- * against number of executing Ndb nodes.
- *
- * @param Parallelism
- * @return 0 if correct parallelism value, otherwise -1.
- *
- */
- int checkParallelism(Uint32 Parallelism);
-
- /**
- * Transfer scan operation to an updating transaction. Use this function
- * when a scan has found a record that you want to update.
- * 1. Start a new transaction.
- * 2. Call the function takeOverForUpdate using your new transaction
- * as parameter, all the properties of the found record will be copied
- * to the new transaction.
- * 3. When you execute the new transaction, the lock held by the scan will
- * be transferred to the new transaction(it's taken over).
- *
- * @note You must have started the scan with openScanExclusive
- * to be able to update the found tuple.
- *
- * @param updateTrans the update transaction connection.
- * @return an NdbOperation or NULL.
- */
- NdbOperation* takeOverForUpdate(NdbConnection* updateTrans);
-
- /**
- * Transfer scan operation to a deleting transaction. Use this function
- * when a scan has found a record that you want to delete.
- * 1. Start a new transaction.
- * 2. Call the function takeOverForDelete using your new transaction
- * as parameter, all the properties of the found record will be copied
- * to the new transaction.
- * 3. When you execute the new transaction, the lock held by the scan will
- * be transferred to the new transaction(its taken over).
- *
- * @note You must have started the scan with openScanExclusive
- * to be able to delete the found tuple.
- *
- * @param deleteTrans the delete transaction connection.
- * @return an NdbOperation or NULL.
- */
- NdbOperation* takeOverForDelete(NdbConnection* deleteTrans);
-
/**
* @name Specify Search Conditions
* @{
@@ -850,16 +662,7 @@ protected:
// Initialise after allocating operation to a transaction
//--------------------------------------------------------------
int init(class NdbTableImpl*, NdbConnection* aCon);
-
- void initScan(); // Initialise after allocating operation
- // to a scan transaction
- virtual void releaseScan(); // Release scan parts of transaction
- void releaseSignals();
- void releaseScanSignals();
- void prepareNextScanResult();
-
- // Common part for Read and Exclusive
- int openScan(Uint32 aParallelism, bool, bool, bool);
+ void initInterpreter();
void next(NdbOperation*); // Set next pointer
@@ -891,11 +694,6 @@ protected:
*****************************************************************************/
int doSend(int ProcessorId, Uint32 lastFlag);
- int doSendScan(int ProcessorId);
-
- int prepareSendScan(Uint32 TC_ConnectPtr,
- Uint64 TransactionId);
-
virtual int prepareSend(Uint32 TC_ConnectPtr,
Uint64 TransactionId);
virtual void setLastFlag(NdbApiSignal* signal, Uint32 lastFlag);
@@ -922,7 +720,7 @@ protected:
virtual int equal_impl(const NdbColumnImpl* anAttrObject,
const char* aValue,
Uint32 len);
- NdbRecAttr* getValue(const NdbColumnImpl* anAttrObject, char* aValue = 0);
+ NdbRecAttr* getValue_impl(const NdbColumnImpl* anAttrObject, char* aValue = 0);
int setValue(const NdbColumnImpl* anAttrObject, const char* aValue, Uint32 len);
int incValue(const NdbColumnImpl* anAttrObject, Uint32 aValue);
int incValue(const NdbColumnImpl* anAttrObject, Uint64 aValue);
@@ -933,15 +731,12 @@ protected:
int branch_reg_reg(Uint32 type, Uint32, Uint32, Uint32);
int branch_col(Uint32 type, Uint32, const char *, Uint32, bool, Uint32 Label);
int branch_col_null(Uint32 type, Uint32 col, Uint32 Label);
- int setBound(const NdbColumnImpl* anAttrObject, int type, const void* aValue, Uint32 len);
// Handle ATTRINFO signals
int receiveREAD_AI(Uint32* aDataPtr, Uint32 aLength);
int insertATTRINFO(Uint32 aData);
int insertATTRINFOloop(const Uint32* aDataPtr, Uint32 aLength);
- int getFirstATTRINFOScan();
- int saveBoundATTRINFO();
int insertKEYINFO(const char* aValue,
Uint32 aStartPosition,
@@ -965,9 +760,6 @@ protected:
Uint32 ptr2int() { return theReceiver.getId(); };
- NdbOperation*
- takeOverScanOp(OperationType opType, NdbConnection* updateTrans);
-
/******************************************************************************
* These are the private variables that are defined in the operation objects.
*****************************************************************************/
@@ -980,7 +772,6 @@ protected:
Ndb* theNdb; // Point back to the Ndb object.
NdbConnection* theNdbCon; // Point back to the connection object.
NdbOperation* theNext; // Next pointer to operation.
- NdbOperation* theNextScanOp;
NdbApiSignal* theTCREQ; // The TC[KEY/INDX]REQ signal object
NdbApiSignal* theFirstATTRINFO; // The first ATTRINFO signal object
NdbApiSignal* theCurrentATTRINFO; // The current ATTRINFO signal object
@@ -991,9 +782,6 @@ protected:
NdbApiSignal* theFirstKEYINFO; // The first KEYINFO signal object
NdbApiSignal* theLastKEYINFO; // The first KEYINFO signal object
- NdbRecAttr* theFirstRecAttr; // The first receive attribute object
- NdbRecAttr* theCurrentRecAttr; // The current receive attribute object
-
class NdbLabel* theFirstLabel;
class NdbLabel* theLastLabel;
class NdbBranch* theFirstBranch;
@@ -1008,15 +796,6 @@ protected:
Uint32* theKEYINFOptr; // Pointer to where to write KEYINFO
Uint32* theATTRINFOptr; // Pointer to where to write ATTRINFO
- Uint32 theTotalRecAI_Len; // The total length received according
- // to the TCKEYCONF signal
- Uint32 theCurrRecAI_Len; // The currently received length
- Uint32 theAI_ElementLen; // How many words long is this element
- Uint32* theCurrElemPtr; // The current pointer to the element
- //Uint32 theTableId; // Table id.
- //Uint32 theAccessTableId; // The id of table for initial access,
- // changed by NdbIndexOperation
- //Uint32 theSchemaVersion; // The schema version on the table.
class NdbTableImpl* m_currentTable; // The current table
class NdbTableImpl* m_accessTable;
@@ -1059,15 +838,6 @@ protected:
Uint16 m_keyInfoGSN;
Uint16 m_attrInfoGSN;
- // Scan related variables
- Uint32 theParallelism;
- NdbScanReceiver** theScanReceiversArray;
- NdbApiSignal* theSCAN_TABREQ;
- NdbApiSignal* theFirstSCAN_TABINFO_Send;
- NdbApiSignal* theLastSCAN_TABINFO_Send;
- NdbApiSignal* theFirstSCAN_TABINFO_Recv;
- NdbApiSignal* theLastSCAN_TABINFO_Recv;
- NdbApiSignal* theSCAN_TABCONF_Recv;
// saveBoundATTRINFO() moves ATTRINFO here when setBound() is ready
NdbApiSignal* theBoundATTRINFO;
Uint32 theTotalBoundAI_Len;
diff --git a/ndb/include/ndbapi/NdbRecAttr.hpp b/ndb/include/ndbapi/NdbRecAttr.hpp
index 7eeff88671d..ece288ba1c4 100644
--- a/ndb/include/ndbapi/NdbRecAttr.hpp
+++ b/ndb/include/ndbapi/NdbRecAttr.hpp
@@ -75,8 +75,9 @@ class AttrInfo;
class NdbRecAttr
{
friend class NdbOperation;
+ friend class NdbIndexScanOperation;
friend class NdbEventOperationImpl;
- friend class NdbScanReceiver;
+ friend class NdbReceiver;
friend class Ndb;
public:
@@ -247,9 +248,8 @@ private:
NdbRecAttr();
Uint32 attrId() const; /* Get attribute id */
- void setNULL(); /* Set NULL indicator */
- void setNotNULL(); /* Set Not NULL indicator */
- void setUNDEFINED(); /* Set UNDEFINED indicator */
+ bool setNULL(); /* Set NULL indicator */
+ bool receive_data(const Uint32*, Uint32);
void release(); /* Release memory if allocated */
void init(); /* Initialise object when allocated */
@@ -257,6 +257,7 @@ private:
void next(NdbRecAttr* aRecAttr);
NdbRecAttr* next() const;
+
int setup(const class NdbColumnImpl* anAttrInfo, char* aValue);
/* Set up attributes and buffers */
bool copyoutRequired() const; /* Need to copy data to application */
@@ -271,6 +272,7 @@ private:
Uint32 theAttrId; /* The attribute id */
int theNULLind;
+ bool m_nullable;
Uint32 theAttrSize;
Uint32 theArraySize;
const NdbDictionary::Column* m_column;
@@ -291,29 +293,7 @@ NdbRecAttr::getColumn() const {
inline
Uint32
NdbRecAttr::attrSize() const {
-
- switch(getType()){
- case NdbDictionary::Column::Int:
- case NdbDictionary::Column::Unsigned:
- case NdbDictionary::Column::Float:
- return 4;
- case NdbDictionary::Column::Decimal:
- case NdbDictionary::Column::Char:
- case NdbDictionary::Column::Varchar:
- case NdbDictionary::Column::Binary:
- case NdbDictionary::Column::Varbinary:
- return 1;
- case NdbDictionary::Column::Bigint:
- case NdbDictionary::Column::Bigunsigned:
- case NdbDictionary::Column::Double:
- case NdbDictionary::Column::Datetime:
- return 8;
- case NdbDictionary::Column::Timespec:
- return 12;
- case NdbDictionary::Column::Undefined:
- default:
- return 0;
- }
+ return theAttrSize;
}
inline
@@ -478,24 +458,11 @@ NdbRecAttr::attrId() const
}
inline
-void
+bool
NdbRecAttr::setNULL()
{
theNULLind = 1;
-}
-
-inline
-void
-NdbRecAttr::setNotNULL()
-{
- theNULLind = 0;
-}
-
-inline
-void
-NdbRecAttr::setUNDEFINED()
-{
- theNULLind = -1;
+ return m_nullable;
}
inline
diff --git a/ndb/include/ndbapi/NdbReceiver.hpp b/ndb/include/ndbapi/NdbReceiver.hpp
index a1a08a9735a..5f69887f402 100644
--- a/ndb/include/ndbapi/NdbReceiver.hpp
+++ b/ndb/include/ndbapi/NdbReceiver.hpp
@@ -23,6 +23,12 @@
class Ndb;
class NdbReceiver
{
+ friend class Ndb;
+ friend class NdbOperation;
+ friend class NdbScanOperation;
+ friend class NdbIndexOperation;
+ friend class NdbIndexScanOperation;
+ friend class NdbConnection;
public:
enum ReceiverType { NDB_UNINITIALIZED,
NDB_OPERATION = 1,
@@ -31,7 +37,8 @@ public:
};
NdbReceiver(Ndb *aNdb);
- void init(ReceiverType type, void* owner);
+ void init(ReceiverType type, void* owner, bool keyInfo);
+ void release();
~NdbReceiver();
Uint32 getId(){
@@ -42,18 +49,51 @@ public:
return m_type;
}
+ inline NdbConnection * getTransaction();
void* getOwner(){
return m_owner;
}
bool checkMagicNumber() const;
+ inline void next(NdbReceiver* next) { m_next = next;}
+ inline NdbReceiver* next() { return m_next; }
+
private:
Uint32 theMagicNumber;
Ndb* m_ndb;
Uint32 m_id;
+ Uint32 m_tcPtrI;
+ Uint32 m_key_info;
ReceiverType m_type;
void* m_owner;
+ NdbReceiver* m_next;
+
+ /**
+ * At setup
+ */
+ class NdbRecAttr * getValue(const class NdbColumnImpl*, char * user_dst_ptr);
+ void do_get_value(NdbReceiver*, Uint32 rows, Uint32 key_size);
+ void prepareSend();
+
+ int execKEYINFO20(Uint32 info, const Uint32* ptr, Uint32 len);
+ int execTRANSID_AI(const Uint32* ptr, Uint32 len);
+ int execTCOPCONF(Uint32 len);
+ int execSCANOPCONF(Uint32 tcPtrI, Uint32 len, Uint32 rows);
+ class NdbRecAttr* theFirstRecAttr;
+ class NdbRecAttr* theCurrentRecAttr;
+ class NdbRecAttr** m_rows;
+
+ Uint32 m_list_index; // When using multiple
+ Uint32 m_current_row;
+ Uint32 m_result_rows;
+ Uint32 m_defined_rows;
+
+ Uint32 m_expected_result_length;
+ Uint32 m_received_result_length;
+
+ bool nextResult() const { return m_current_row < m_result_rows; }
+ void copyout(NdbReceiver&);
};
#ifdef NDB_NO_DROPPED_SIGNAL
@@ -72,5 +112,32 @@ NdbReceiver::checkMagicNumber() const {
return retVal;
}
+inline
+void
+NdbReceiver::prepareSend(){
+ m_current_row = 0;
+ m_received_result_length = 0;
+ m_expected_result_length = 0;
+ theCurrentRecAttr = theFirstRecAttr;
+}
+
+inline
+int
+NdbReceiver::execTCOPCONF(Uint32 len){
+ Uint32 tmp = m_received_result_length;
+ m_expected_result_length = len;
+ return (tmp == len ? 1 : 0);
+}
+
+inline
+int
+NdbReceiver::execSCANOPCONF(Uint32 tcPtrI, Uint32 len, Uint32 rows){
+ m_tcPtrI = tcPtrI;
+ m_result_rows = rows;
+ Uint32 tmp = m_received_result_length;
+ m_expected_result_length = len;
+ return (tmp == len ? 1 : 0);
+}
+
#endif
#endif
diff --git a/ndb/include/ndbapi/NdbResultSet.hpp b/ndb/include/ndbapi/NdbResultSet.hpp
index d48df01214e..7cf18a6685d 100644
--- a/ndb/include/ndbapi/NdbResultSet.hpp
+++ b/ndb/include/ndbapi/NdbResultSet.hpp
@@ -30,17 +30,15 @@
#define NdbResultSet_H
-#include
-#include
#include
/**
* @class NdbResultSet
- * @brief NdbResultSet contains a NdbCursorOperation.
+ * @brief NdbResultSet contains a NdbScanOperation.
*/
class NdbResultSet
{
- friend class NdbCursorOperation;
+ friend class NdbScanOperation;
public:
@@ -93,22 +91,57 @@ public:
*/
int nextResult(bool fetchAllowed = true);
+ /**
+ * Close result set (scan)
+ */
void close();
+ /**
+ * Transfer scan operation to an updating transaction. Use this function
+ * when a scan has found a record that you want to update.
+ * 1. Start a new transaction.
+ * 2. Call the function takeOverForUpdate using your new transaction
+ * as parameter, all the properties of the found record will be copied
+ * to the new transaction.
+ * 3. When you execute the new transaction, the lock held by the scan will
+ * be transferred to the new transaction(it's taken over).
+ *
+ * @note You must have started the scan with openScanExclusive
+ * to be able to update the found tuple.
+ *
+ * @param updateTrans the update transaction connection.
+ * @return an NdbOperation or NULL.
+ */
NdbOperation* updateTuple();
- NdbOperation* updateTuple(NdbConnection* takeOverTransaction);
-
+ NdbOperation* updateTuple(NdbConnection* updateTrans);
+
+ /**
+ * Transfer scan operation to a deleting transaction. Use this function
+ * when a scan has found a record that you want to delete.
+ * 1. Start a new transaction.
+ * 2. Call the function takeOverForDelete using your new transaction
+ * as parameter, all the properties of the found record will be copied
+ * to the new transaction.
+ * 3. When you execute the new transaction, the lock held by the scan will
+ * be transferred to the new transaction(its taken over).
+ *
+ * @note You must have started the scan with openScanExclusive
+ * to be able to delete the found tuple.
+ *
+ * @param deleteTrans the delete transaction connection.
+ * @return an NdbOperation or NULL.
+ */
int deleteTuple();
int deleteTuple(NdbConnection* takeOverTransaction);
private:
- NdbResultSet(NdbCursorOperation*);
+ NdbResultSet(NdbScanOperation*);
~NdbResultSet();
void init();
- NdbCursorOperation* m_operation;
+ NdbScanOperation* m_operation;
};
#endif
diff --git a/ndb/include/ndbapi/NdbScanOperation.hpp b/ndb/include/ndbapi/NdbScanOperation.hpp
index f83669fb616..8ff640dc6ec 100644
--- a/ndb/include/ndbapi/NdbScanOperation.hpp
+++ b/ndb/include/ndbapi/NdbScanOperation.hpp
@@ -29,67 +29,74 @@
#ifndef NdbScanOperation_H
#define NdbScanOperation_H
-
#include
-#include
/**
* @class NdbScanOperation
* @brief Class of scan operations for use in transactions.
*/
-class NdbScanOperation : public NdbCursorOperation
-{
+class NdbScanOperation : public NdbOperation {
friend class Ndb;
friend class NdbConnection;
friend class NdbResultSet;
friend class NdbOperation;
public:
+ /**
+ * Type of cursor
+ */
+ enum CursorType {
+ NoCursor = 0,
+ ScanCursor = 1,
+ IndexCursor = 2
+ };
+
+ /**
+ * Lock when performing scan
+ */
+ enum LockMode {
+ LM_Read = 0,
+ LM_Exclusive = 1,
+ LM_CommittedRead = 2,
+#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
+ LM_Dirty = 2
+#endif
+ };
+
+ /**
+ * Type of cursor
+ */
+ CursorType get_cursor_type() const;
+
/**
* readTuples returns a NdbResultSet where tuples are stored.
* Tuples are not stored in NdbResultSet until execute(NoCommit)
* has been executed and nextResult has been called.
*
* @param parallel Scan parallelism
+ * @param batch No of rows to fetch from each fragment at a time
* @param LockMode Scan lock handling
* @returns NdbResultSet.
+ * @note specifying 0 for batch and parallall means max performance
*/
- virtual NdbResultSet* readTuples(unsigned parallel = 0,
- LockMode = LM_Read );
+ NdbResultSet* readTuples(LockMode = LM_Read,
+ Uint32 batch = 0, Uint32 parallel = 0);
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
+ inline NdbResultSet* readTuples(int parallell){
+ return readTuples(LM_Read, 0, parallell);
+ }
+
+ inline NdbResultSet* readTuplesExclusive(int parallell = 0){
+ return readTuples(LM_Exclusive, 0, parallell);
+ }
+
+protected:
+ CursorType m_cursor_type;
- int updateTuples();
- int updateTuples(Uint32 parallelism);
-
- int deleteTuples();
- int deleteTuples(Uint32 parallelism);
-
- // Overload setValue for updateTuples
- int setValue(const char* anAttrName, const char* aValue, Uint32 len = 0);
- int setValue(const char* anAttrName, Int32 aValue);
- int setValue(const char* anAttrName, Uint32 aValue);
- int setValue(const char* anAttrName, Int64 aValue);
- int setValue(const char* anAttrName, Uint64 aValue);
- int setValue(const char* anAttrName, float aValue);
- int setValue(const char* anAttrName, double aValue);
-
- int setValue(Uint32 anAttrId, const char* aValue, Uint32 len = 0);
- int setValue(Uint32 anAttrId, Int32 aValue);
- int setValue(Uint32 anAttrId, Uint32 aValue);
- int setValue(Uint32 anAttrId, Int64 aValue);
- int setValue(Uint32 anAttrId, Uint64 aValue);
- int setValue(Uint32 anAttrId, float aValue);
- int setValue(Uint32 anAttrId, double aValue);
-#endif
-private:
NdbScanOperation(Ndb* aNdb);
-
~NdbScanOperation();
- NdbCursorOperation::CursorType cursorType();
-
- virtual int nextResult(bool fetchAllowed = true);
+ int nextResult(bool fetchAllowed = true);
virtual void release();
void closeScan();
@@ -105,125 +112,51 @@ private:
virtual void setErrorCode(int aErrorCode);
virtual void setErrorCodeAbort(int aErrorCode);
- virtual int equal_impl(const NdbColumnImpl* anAttrObject,
- const char* aValue,
- Uint32 len);
-private:
+ NdbResultSet * m_resultSet;
+ NdbResultSet* getResultSet();
NdbConnection *m_transConnection;
- bool m_autoExecute;
- bool m_updateOp;
- bool m_writeOp;
- bool m_deleteOp;
- class SetValueRecList* m_setValueList;
-};
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
-class AttrInfo;
-class SetValueRecList;
+ // Scan related variables
+ Uint32 theBatchSize;
+ Uint32 theParallelism;
+ Uint32 m_keyInfo;
+ NdbApiSignal* theSCAN_TABREQ;
-class SetValueRec {
- friend class SetValueRecList;
-public:
- SetValueRec();
- ~SetValueRec();
-
- enum SetValueType {
- SET_STRING_ATTR1 = 0,
- SET_INT32_ATTR1 = 1,
- SET_UINT32_ATTR1 = 2,
- SET_INT64_ATTR1 = 3,
- SET_UINT64_ATTR1 = 4,
- SET_FLOAT_ATTR1 = 5,
- SET_DOUBLE_ATTR1 = 6,
- SET_STRING_ATTR2 = 7,
- SET_INT32_ATTR2 = 8,
- SET_UINT32_ATTR2 = 9,
- SET_INT64_ATTR2 = 10,
- SET_UINT64_ATTR2 = 11,
- SET_FLOAT_ATTR2 = 12,
- SET_DOUBLE_ATTR2 = 13
- };
-
- SetValueType stype;
- union {
- char* anAttrName;
- Uint32 anAttrId;
- };
- struct String {
- char* aStringValue;
- Uint32 len;
- };
- union {
- String stringStruct;
- Int32 anInt32Value;
- Uint32 anUint32Value;
- Int64 anInt64Value;
- Uint64 anUint64Value;
- float aFloatValue;
- double aDoubleValue;
- };
-private:
- SetValueRec* next;
-};
-
-inline
-SetValueRec::SetValueRec() :
- next(0)
-{
-}
-
-class SetValueRecList {
-public:
- SetValueRecList();
- ~SetValueRecList();
-
- void add(const char* anAttrName, const char* aValue, Uint32 len = 0);
- void add(const char* anAttrName, Int32 aValue);
- void add(const char* anAttrName, Uint32 aValue);
- void add(const char* anAttrName, Int64 aValue);
- void add(const char* anAttrName, Uint64 aValue);
- void add(const char* anAttrName, float aValue);
- void add(const char* anAttrName, double aValue);
- void add(Uint32 anAttrId, const char* aValue, Uint32 len = 0);
- void add(Uint32 anAttrId, Int32 aValue);
- void add(Uint32 anAttrId, Uint32 aValue);
- void add(Uint32 anAttrId, Int64 aValue);
- void add(Uint32 anAttrId, Uint64 aValue);
- void add(Uint32 anAttrId, float aValue);
- void add(Uint32 anAttrId, double aValue);
-
- typedef void(* IterateFn)(SetValueRec&, NdbOperation&);
- static void callSetValueFn(SetValueRec&, NdbOperation&);
- void iterate(IterateFn nextfn, NdbOperation&);
-private:
- SetValueRec* first;
- SetValueRec* last;
-};
-
-inline
-SetValueRecList::SetValueRecList() :
- first(0),
- last(0)
-{
-}
+ int getFirstATTRINFOScan();
+ int saveBoundATTRINFO();
+ int doSendScan(int ProcessorId);
+ int prepareSendScan(Uint32 TC_ConnectPtr, Uint64 TransactionId);
-inline
-SetValueRecList::~SetValueRecList() {
- if (first) delete first;
- first = last = 0;
-}
+ int fix_receivers(Uint32 parallel, bool keyInfo);
+ Uint32 m_allocated_receivers;
+ NdbReceiver** m_receivers; // All receivers
+ Uint32* m_prepared_receivers; // These are to be sent
+
+ Uint32 m_current_api_receiver;
+ Uint32 m_api_receivers_count;
+ NdbReceiver** m_api_receivers; // These are currently used by api
+
+ Uint32 m_conf_receivers_count; // NOTE needs mutex to access
+ NdbReceiver** m_conf_receivers; // receive thread puts them here
+
+ Uint32 m_sent_receivers_count; // NOTE needs mutex to access
+ NdbReceiver** m_sent_receivers; // receive thread puts them here
+
+ int send_next_scan(Uint32 cnt, bool close);
+ void receiver_delivered(NdbReceiver*);
+ void receiver_completed(NdbReceiver*);
+ void execCLOSE_SCAN_REP(Uint32 errCode);
+
+ NdbOperation* takeOverScanOp(OperationType opType, NdbConnection*);
+
+ Uint32 m_ordered;
+};
inline
-void SetValueRecList::iterate(SetValueRecList::IterateFn nextfn, NdbOperation& oper)
-{
- SetValueRec* recPtr = first;
- while(recPtr) {
- (*nextfn)(*recPtr, oper);
- recPtr = recPtr->next; // Move to next in list - MASV
- }
+NdbScanOperation::CursorType
+NdbScanOperation::get_cursor_type() const {
+ return m_cursor_type;
}
#endif
-
-#endif
diff --git a/ndb/src/common/debugger/signaldata/DictTabInfo.cpp b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
index a0e0195adad..7e7bf87e2db 100644
--- a/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
+++ b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
@@ -48,6 +48,7 @@ DictTabInfo::TableMapping[] = {
DTIMAP(Table, CustomTriggerId, CustomTriggerId),
DTIMAP2(Table, FrmLen, FrmLen, 0, MAX_FRM_DATA_SIZE),
DTIMAPB(Table, FrmData, FrmData, 0, MAX_FRM_DATA_SIZE, FrmLen),
+ DTIMAP(Table, FragmentCount, FragmentCount),
DTIBREAK(AttributeName)
};
@@ -128,6 +129,7 @@ DictTabInfo::Table::init(){
CustomTriggerId = RNIL;
FrmLen = 0;
memset(FrmData, 0, sizeof(FrmData));
+ FragmentCount = 0;
}
void
diff --git a/ndb/src/common/debugger/signaldata/ScanTab.cpp b/ndb/src/common/debugger/signaldata/ScanTab.cpp
index b4246059f6a..776e9cf3bfc 100644
--- a/ndb/src/common/debugger/signaldata/ScanTab.cpp
+++ b/ndb/src/common/debugger/signaldata/ScanTab.cpp
@@ -30,20 +30,34 @@ printSCANTABREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiv
fprintf(output, " apiConnectPtr: H\'%.8x\n",
sig->apiConnectPtr);
fprintf(output, " requestInfo: H\'%.8x:\n", requestInfo);
- fprintf(output, " Parallellism: %u, LockMode: %u, Holdlock: %u, RangeScan: %u\n",
- sig->getParallelism(requestInfo), sig->getLockMode(requestInfo), sig->getHoldLockFlag(requestInfo), sig->getRangeScanFlag(requestInfo));
-
+ fprintf(output, " Parallellism: %u, Batch: %u LockMode: %u, Holdlock: %u, RangeScan: %u\n",
+ sig->getParallelism(requestInfo),
+ sig->getScanBatch(requestInfo),
+ sig->getLockMode(requestInfo),
+ sig->getHoldLockFlag(requestInfo),
+ sig->getRangeScanFlag(requestInfo));
+
fprintf(output, " attrLen: %d, tableId: %d, tableSchemaVer: %d\n",
sig->attrLen, sig->tableId, sig->tableSchemaVersion);
fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x) storedProcId: H\'%.8x\n",
sig->transId1, sig->transId2, sig->storedProcId);
- fprintf(output, " OperationPtr(s):\n");
- for(int i = 0; i<16; i=i+4){
- fprintf(output, " H\'%.8x, H\'%.8x, H\'%.8x, H\'%.8x\n",
- sig->apiOperationPtr[i], sig->apiOperationPtr[i+1],
- sig->apiOperationPtr[i+2], sig->apiOperationPtr[i+3]);
+ fprintf(output, " OperationPtr(s):\n ");
+ Uint32 restLen = (len - 9);
+ const Uint32 * rest = &sig->apiOperationPtr[0];
+ while(restLen >= 7){
+ fprintf(output,
+ " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n",
+ rest[0], rest[1], rest[2], rest[3],
+ rest[4], rest[5], rest[6]);
+ restLen -= 7;
+ rest += 7;
+ }
+ if(restLen > 0){
+ for(Uint32 i = 0; itransId1, sig->transId2);
- fprintf(output, " requestInfo: H\'%.8x(Operations: %u, ScanStatus: %u(\"",
- requestInfo, sig->getOperations(requestInfo), sig->getScanStatus(requestInfo));
- switch(sig->getScanStatus(requestInfo)){
- case 0:
- fprintf(output, "ZFALSE");
- break;
- case 1:
- fprintf(output, "ZTRUE");
- break;
- case 2:
- fprintf(output, "ZCLOSED");
- break;
- default:
- fprintf(output, "UNKNOWN");
- break;
- }
- fprintf(output, "\"))\n");
+ fprintf(output, " requestInfo: H\'%.8x(EndOfData: %d)\n",
+ requestInfo, (requestInfo & ScanTabConf::EndOfData != 0));
#if 0
fprintf(output, " Operation(s):\n");
for(int i = 0; i<16; i++){
diff --git a/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
index 7eb7f995eb7..6cac2f00542 100644
--- a/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
+++ b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
@@ -114,6 +114,8 @@ Cmvmi::Cmvmi(const Configuration & conf) :
}
setNodeInfo(nodeId).m_type = nodeType;
}
+
+ setNodeInfo(getOwnNodeId()).m_connected = true;
}
Cmvmi::~Cmvmi()
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
index 084f41e4166..a11205047e5 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
@@ -75,7 +75,6 @@
#include
#include
#include
-#include "../dbtc/Dbtc.hpp"
#include
#define ZNOT_FOUND 626
@@ -254,6 +253,7 @@ Dbdict::packTableIntoPagesImpl(SimpleProperties::Writer & w,
w.add(DictTabInfo::FragmentTypeVal, tablePtr.p->fragmentType);
w.add(DictTabInfo::FragmentKeyTypeVal, tablePtr.p->fragmentKeyType);
w.add(DictTabInfo::TableTypeVal, tablePtr.p->tableType);
+ w.add(DictTabInfo::FragmentCount, tablePtr.p->fragmentCount);
if (tablePtr.p->primaryTableId != RNIL){
TableRecordPtr primTab;
@@ -3599,30 +3599,37 @@ Dbdict::execCREATE_FRAGMENTATION_CONF(Signal* signal){
SegmentedSectionPtr fragDataPtr;
signal->getSection(fragDataPtr, CreateFragmentationConf::FRAGMENTS);
-
signal->header.m_noOfSections = 0;
/**
- * Correct table
+ * Get table
*/
TableRecordPtr tabPtr;
c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI);
- PageRecordPtr pagePtr;
- c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage);
- SchemaFile::TableEntry * tabEntry = getTableEntry(pagePtr.p, tabPtr.i);
+ /**
+ * Save fragment count
+ */
+ tabPtr.p->fragmentCount = conf->noOfFragments;
/**
* Update table version
*/
+ PageRecordPtr pagePtr;
+ c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage);
+ SchemaFile::TableEntry * tabEntry = getTableEntry(pagePtr.p, tabPtr.i);
+
tabPtr.p->tableVersion = tabEntry->m_tableVersion + 1;
-
+
+ /**
+ * Pack
+ */
SimplePropertiesSectionWriter w(getSectionSegmentPool());
packTableIntoPagesImpl(w, tabPtr);
SegmentedSectionPtr spDataPtr;
w.getPtr(spDataPtr);
-
+
signal->setSection(spDataPtr, CreateTabReq::DICT_TAB_INFO);
signal->setSection(fragDataPtr, CreateTabReq::FRAGMENTATION);
@@ -4252,7 +4259,9 @@ Dbdict::execDIADDTABCONF(Signal* signal){
/**
* No local fragment (i.e. no LQHFRAGREQ)
*/
- sendSignal(DBDIH_REF, GSN_TAB_COMMITREQ, signal, 3, JBB);
+ execute(signal, createTabPtr.p->m_callback, 0);
+ return;
+ //sendSignal(DBDIH_REF, GSN_TAB_COMMITREQ, signal, 3, JBB);
}
}
@@ -4637,6 +4646,7 @@ void Dbdict::handleTabInfoInit(SimpleProperties::Reader & it,
tablePtr.p->fragmentKeyType = (DictTabInfo::FragmentKeyType)tableDesc.FragmentKeyType;
tablePtr.p->tableType = (DictTabInfo::TableType)tableDesc.TableType;
tablePtr.p->kValue = tableDesc.TableKValue;
+ tablePtr.p->fragmentCount = tableDesc.FragmentCount;
tablePtr.p->frmLen = tableDesc.FrmLen;
memcpy(tablePtr.p->frmData, tableDesc.FrmData, tableDesc.FrmLen);
@@ -5080,8 +5090,20 @@ Dbdict::execPREP_DROP_TAB_REF(Signal* signal){
Uint32 nodeId = refToNode(prep->senderRef);
dropTabPtr.p->m_coordinatorData.m_signalCounter.clearWaitingFor(nodeId);
-
- dropTabPtr.p->setErrorCode((Uint32)prep->errorCode);
+
+ Uint32 block = refToBlock(prep->senderRef);
+ if((prep->errorCode == PrepDropTabRef::NoSuchTable && block == DBLQH) ||
+ (prep->errorCode == PrepDropTabRef::NF_FakeErrorREF)){
+ jam();
+ /**
+ * Ignore errors:
+ * 1) no such table and LQH, it might not exists in different LQH's
+ * 2) node failure...
+ */
+ } else {
+ dropTabPtr.p->setErrorCode((Uint32)prep->errorCode);
+ }
+
if(!dropTabPtr.p->m_coordinatorData.m_signalCounter.done()){
jam();
return;
@@ -5112,6 +5134,19 @@ void
Dbdict::execDROP_TAB_REF(Signal* signal){
jamEntry();
+ DropTabRef * const req = (DropTabRef*)signal->getDataPtr();
+
+ Uint32 block = refToBlock(req->senderRef);
+ ndbrequire(req->errorCode == DropTabRef::NF_FakeErrorREF ||
+ (req->errorCode == DropTabRef::NoSuchTable &&
+ (block == DBTUP || block == DBACC || block == DBLQH)));
+
+ if(block != DBDICT){
+ jam();
+ ndbrequire(refToNode(req->senderRef) == getOwnNodeId());
+ dropTab_localDROP_TAB_CONF(signal);
+ return;
+ }
ndbrequire(false);
}
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
index 68214785234..de1d9757b2a 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
@@ -230,7 +230,7 @@ public:
Uint32 frmLen;
char frmData[MAX_FRM_DATA_SIZE];
-
+ Uint32 fragmentCount;
};
typedef Ptr TableRecordPtr;
diff --git a/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp b/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp
index df47237ae59..f996a1fe689 100644
--- a/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp
+++ b/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp
@@ -254,6 +254,7 @@ Dbdih::Dbdih(const class Configuration & config):
addRecSignal(GSN_UPDATE_TOCONF, &Dbdih::execUPDATE_TOCONF);
addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbdih::execPREP_DROP_TAB_REQ);
+ addRecSignal(GSN_WAIT_DROP_TAB_REF, &Dbdih::execWAIT_DROP_TAB_REF);
addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbdih::execWAIT_DROP_TAB_CONF);
addRecSignal(GSN_DROP_TAB_REQ, &Dbdih::execDROP_TAB_REQ);
diff --git a/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp b/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
index 0ce1f1e4bbe..059f1301ba2 100644
--- a/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
+++ b/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
@@ -13359,6 +13359,25 @@ Dbdih::checkPrepDropTabComplete(Signal* signal, TabRecordPtr tabPtr){
}
}
+void
+Dbdih::execWAIT_DROP_TAB_REF(Signal* signal){
+ jamEntry();
+ WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtr();
+
+ TabRecordPtr tabPtr;
+ tabPtr.i = ref->tableId;
+ ptrCheckGuard(tabPtr, ctabFileSize, tabRecord);
+
+ ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_DROPPING);
+ Uint32 nodeId = refToNode(ref->senderRef);
+
+ ndbrequire(ref->errorCode == WaitDropTabRef::NoSuchTable ||
+ ref->errorCode == WaitDropTabRef::NF_FakeErrorREF);
+
+ tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor(nodeId);
+ checkPrepDropTabComplete(signal, tabPtr);
+}
+
void
Dbdih::execWAIT_DROP_TAB_CONF(Signal* signal){
jamEntry();
diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index c342f60e13f..0f47ee4f38e 100644
--- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -3198,10 +3198,14 @@ void Dblqh::execLQHKEYREQ(Signal* signal)
const NodeId tcNodeId = refToNode(sig5);
markerPtr.p->tcNodeId = tcNodeId;
+ CommitAckMarkerPtr tmp;
+#ifdef VM_TRACE
+ ndbrequire(!m_commitAckMarkerHash.find(tmp, * markerPtr.p));
+#endif
m_commitAckMarkerHash.add(markerPtr);
regTcPtr->commitAckMarker = markerPtr.i;
- }
-
+ }
+
regTcPtr->reqinfo = Treqinfo;
regTcPtr->lastReplicaNo = LqhKeyReq::getLastReplicaNo(Treqinfo);
regTcPtr->lockType = LqhKeyReq::getLockType(Treqinfo);
@@ -7840,27 +7844,10 @@ void Dblqh::scanTupkeyConfLab(Signal* signal)
}//if
if (scanptr.p->scanKeyinfoFlag) {
jam();
- DatabufPtr TdataBuf;
- TdataBuf.i = tcConnectptr.p->firstTupkeybuf;
- const Uint32 keyLen = tcConnectptr.p->primKeyLen;
- const Uint32 dataBufSz = cdatabufFileSize;
-
- /**
- * Note that this code requires signal->theData to be big enough for
- * a entire key
- */
- ndbrequire(keyLen * 4 <= sizeof(signal->theData));
- KeyInfo20 * keyInfo = (KeyInfo20*)&signal->theData[0];
- for(Uint32 i = 0; i < keyLen; i += 4){
- ptrCheckGuard(TdataBuf, dataBufSz, databuf);
- keyInfo->keyData[i + 0] = TdataBuf.p->data[0];
- keyInfo->keyData[i + 1] = TdataBuf.p->data[1];
- keyInfo->keyData[i + 2] = TdataBuf.p->data[2];
- keyInfo->keyData[i + 3] = TdataBuf.p->data[3];
- TdataBuf.i = TdataBuf.p->nextDatabuf;
- }
sendKeyinfo20(signal, scanptr.p, tcConnectptr.p);
releaseOprec(signal);
+
+ tdata4 += tcConnectptr.p->primKeyLen;// Inform API about keyinfo len aswell
}//if
ndbrequire(scanptr.p->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN);
scanptr.p->scanOpLength[scanptr.p->scanCompletedOperations] = tdata4;
@@ -8297,7 +8284,8 @@ void Dblqh::initScanTc(Signal* signal,
tcConnectptr.p->opExec = 1;
tcConnectptr.p->operation = ZREAD;
tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST;
-
+ tcConnectptr.p->commitAckMarker = RNIL;
+
tabptr.p->usageCount++;
}//Dblqh::initScanTc()
@@ -8401,72 +8389,119 @@ void Dblqh::sendKeyinfo20(Signal* signal,
ndbrequire(scanP->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN);
KeyInfo20 * keyInfo = (KeyInfo20 *)&signal->theData[0];
+ DatabufPtr TdataBuf;
+ TdataBuf.i = tcConP->firstTupkeybuf;
+ Uint32 keyLen = tcConP->primKeyLen;
+ const Uint32 dataBufSz = cdatabufFileSize;
+
+ /**
+ * Note that this code requires signal->theData to be big enough for
+ * a entire key
+ */
+ ndbrequire(keyLen * 4 <= sizeof(signal->theData));
+ const BlockReference ref = scanP->scanApiBlockref;
const Uint32 scanOp = scanP->scanCompletedOperations;
+ const Uint32 nodeId = refToNode(ref);
+ const bool connectedToNode = getNodeInfo(nodeId).m_connected;
+ const Uint32 type = getNodeInfo(nodeId).m_type;
+ const bool is_api = (type >= NodeInfo::API && type <= NodeInfo::REP);
+ const bool old_dest = (getNodeInfo(nodeId).m_version < MAKE_VERSION(3,5,0));
+ const bool longable = is_api && !old_dest;
+
+ Uint32 * dst = keyInfo->keyData;
+ dst += nodeId == getOwnNodeId() ? 0 : KeyInfo20::DataLength;
+
+ /**
+ * Copy keydata from data buffer into signal
+ *
+ */
+ for(Uint32 i = 0; i < keyLen; i += 4){
+ ptrCheckGuard(TdataBuf, dataBufSz, databuf);
+ * dst++ = TdataBuf.p->data[0];
+ * dst++ = TdataBuf.p->data[1];
+ * dst++ = TdataBuf.p->data[2];
+ * dst++ = TdataBuf.p->data[3];
+ TdataBuf.i = TdataBuf.p->nextDatabuf;
+ }
+
keyInfo->clientOpPtr = scanP->scanApiOpPtr[scanOp];
- keyInfo->keyLen = tcConP->primKeyLen;
+ keyInfo->keyLen = keyLen;
keyInfo->scanInfo_Node = KeyInfo20::setScanInfo(scanOp,
scanP->scanNumber)+
(getOwnNodeId() << 16);
-
keyInfo->transId1 = tcConP->transid[0];
keyInfo->transId2 = tcConP->transid[1];
-
- const BlockReference ref = scanP->scanApiBlockref;
- const Uint32 keyLen = tcConP->primKeyLen;
- if(refToNode(ref) == getOwnNodeId()){
+
+ Uint32 * src = signal->theData+25;
+ if(connectedToNode){
jam();
- EXECUTE_DIRECT(refToBlock(ref), GSN_KEYINFO20, signal, 5 + keyLen);
+
+ if(nodeId != getOwnNodeId()){
+ jam();
+
+ if(keyLen <= KeyInfo20::DataLength || !longable) {
+ while(keyLen > KeyInfo20::DataLength){
+ jam();
+ MEMCOPY_NO_WORDS(keyInfo->keyData, src, KeyInfo20::DataLength);
+ sendSignal(ref, GSN_KEYINFO20, signal, 25, JBB);
+ src += KeyInfo20::DataLength;;
+ keyLen -= KeyInfo20::DataLength;
+ } while(keyLen >= KeyInfo20::DataLength);
+
+ MEMCOPY_NO_WORDS(keyInfo->keyData, src, keyLen);
+ sendSignal(ref, GSN_KEYINFO20, signal,
+ KeyInfo20::HeaderLength+keyLen, JBB);
+ return;
+ }
+
+ LinearSectionPtr ptr[3];
+ ptr[0].p = src;
+ ptr[0].sz = keyLen;
+ sendSignal(ref, GSN_KEYINFO20, signal, KeyInfo20::HeaderLength,
+ JBB, ptr, 1);
+ return;
+ }
+
+ EXECUTE_DIRECT(refToBlock(ref), GSN_KEYINFO20, signal, 3 + keyLen);
jamEntry();
return;
- }
-
- bool connectedToNode = getNodeInfo(refToNode(ref)).m_connected;
-
- if (ERROR_INSERTED(5029)){
- // Use error insert to turn routing on
- jam();
- connectedToNode = false;
}
- if (connectedToNode){
+ /**
+ * If this node does not have a direct connection
+ * to the receiving node we want to send the signals
+ * routed via the node that controls this read
+ */
+ Uint32 routeBlockref = tcConP->clientBlockref;
+
+ if(keyLen < KeyInfo20::DataLength || !longable){
jam();
- Uint32 keyLenLeft = keyLen;
- Uint32 keyDataIndex = 20;
- for(; keyLenLeft > 20; keyLenLeft -= 20, keyDataIndex += 20){
- jam();
- sendSignal(ref, GSN_KEYINFO20, signal, 25, JBB);
- for(Uint32 i = 0; i<20; i++)
- keyInfo->keyData[i] = keyInfo->keyData[keyDataIndex + i];
- }//for
- sendSignal(ref, GSN_KEYINFO20, signal, 5 + keyLenLeft, JBB);
- } else {
- /**
- * If this node does not have a direct connection
- * to the receiving node we want to send the signals
- * routed via the control node
- */
- jam();
- Uint32 keyLenLeft = keyLen;
- Uint32 keyDataIndex = 19;
- BlockReference routeBlockref = tcConP->clientBlockref;
- for(; keyLenLeft > 19; keyLenLeft -= 19, keyDataIndex += 19){
- jam();
- // store final destination, but save original value
- Uint32 saveOne = keyInfo->keyData[19];
- keyInfo->keyData[19] = ref;
+ while (keyLen > (KeyInfo20::DataLength - 1)) {
+ jam();
+ MEMCOPY_NO_WORDS(keyInfo->keyData, src, KeyInfo20::DataLength - 1);
+ keyInfo->keyData[KeyInfo20::DataLength-1] = ref;
sendSignal(routeBlockref, GSN_KEYINFO20_R, signal, 25, JBB);
- keyInfo->keyData[19] = saveOne;
- for(Uint32 i = 0; i<19; i++){
- keyInfo->keyData[i] = keyInfo->keyData[keyDataIndex + i];
- }
- }//for
- keyInfo->keyData[keyLenLeft] = ref;
- sendSignal(routeBlockref, GSN_KEYINFO20_R, signal, 5 + keyLenLeft + 1, JBB);
+ src += KeyInfo20::DataLength - 1;
+ keyLen -= KeyInfo20::DataLength - 1;
+ }
+
+ MEMCOPY_NO_WORDS(keyInfo->keyData, src, keyLen);
+ keyInfo->keyData[keyLen] = ref;
+ sendSignal(routeBlockref, GSN_KEYINFO20_R, signal,
+ KeyInfo20::HeaderLength+keyLen+1, JBB);
+ return;
}
-}//Dblqh::sendKeyinfo20()
-
+ keyInfo->keyData[0] = ref;
+ LinearSectionPtr ptr[3];
+ ptr[0].p = src;
+ ptr[0].sz = keyLen;
+ sendSignal(routeBlockref, GSN_KEYINFO20_R, signal,
+ KeyInfo20::HeaderLength+1, JBB, ptr, 1);
+ return;
+}
+
/* ------------------------------------------------------------------------
* ------- SEND SCAN_FRAGCONF TO TC THAT CONTROLS THE SCAN -------
*
@@ -8848,7 +8883,7 @@ void Dblqh::execTRANSID_AI(Signal* signal)
ndbrequire(tcConnectptr.p->transactionState == TcConnectionrec::COPY_TUPKEY);
Uint32 * src = &signal->theData[3];
while(length > 22){
- if (saveTupattrbuf(signal, &signal->theData[3], 22) == ZOK) {
+ if (saveTupattrbuf(signal, src, 22) == ZOK) {
;
} else {
jam();
diff --git a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
index c87712e1887..61e7e42621c 100644
--- a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
+++ b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
@@ -992,12 +992,90 @@ public:
};
typedef Ptr TableRecordPtr;
+ /**
+ * There is max 16 ScanFragRec's for
+ * each scan started in TC. Each ScanFragRec is used by
+ * a scan fragment "process" that scans one fragment at a time.
+ * It will receive max 16 tuples in each request
+ */
+ struct ScanFragRec {
+ ScanFragRec(){}
+ /**
+ * ScanFragState
+ * WAIT_GET_PRIMCONF : Waiting for DIGETPRIMCONF when starting a new
+ * fragment scan
+ * LQH_ACTIVE : The scan process has sent a command to LQH and is
+ * waiting for the response
+ * LQH_ACTIVE_CLOSE : The scan process has sent close to LQH and is
+ * waiting for the response
+ * DELIVERED : The result have been delivered, this scan frag process
+ * are waiting for a SCAN_NEXTREQ to tell us to continue scanning
+ * RETURNING_FROM_DELIVERY : SCAN_NEXTREQ received and continuing scan
+ * soon
+ * QUEUED_FOR_DELIVERY : Result queued in TC and waiting for delivery
+ * to API
+ * COMPLETED : The fragment scan processes has completed and finally
+ * sent a SCAN_PROCCONF
+ */
+ enum ScanFragState {
+ IDLE = 0,
+ WAIT_GET_PRIMCONF = 1,
+ LQH_ACTIVE = 2,
+ DELIVERED = 4,
+ QUEUED_FOR_DELIVERY = 6,
+ COMPLETED = 7
+ };
+ // Timer for checking timeout of this fragment scan
+ Uint32 scanFragTimer;
+
+ // Id of the current scanned fragment
+ Uint32 scanFragId;
+
+ // Blockreference of LQH
+ BlockReference lqhBlockref;
+
+ // getNodeInfo.m_connectCount, set at seize used so that
+ // I don't accidently kill a starting node
+ Uint32 m_connectCount;
+
+ // State of this fragment scan
+ ScanFragState scanFragState;
+
+ // Id of the ScanRecord this fragment scan belongs to
+ Uint32 scanRec;
+
+ // The maximum number of operations that can be scanned before
+ // returning to TC
+ Uint16 scanFragConcurrency;
+
+ inline void startFragTimer(Uint32 timeVal){
+ scanFragTimer = timeVal;
+ }
+ inline void stopFragTimer(void){
+ scanFragTimer = 0;
+ }
+
+ Uint32 m_ops;
+ Uint32 m_chksum;
+ Uint32 m_apiPtr;
+ Uint32 m_totalLen;
+ union {
+ Uint32 nextPool;
+ Uint32 nextList;
+ };
+ Uint32 prevList;
+ };
+
+ typedef Ptr ScanFragRecPtr;
+ typedef LocalDLList ScanFragList;
+
/**
* Each scan allocates one ScanRecord to store information
* about the current scan
*
*/
struct ScanRecord {
+ ScanRecord() {}
/** NOTE! This is the old comment for ScanState. - MASV
* STATE TRANSITIONS OF SCAN_STATE. SCAN_STATE IS THE STATE
* VARIABLE OF THE RECEIVE AND DELIVERY PROCESS.
@@ -1057,161 +1135,68 @@ public:
WAIT_SCAN_TAB_INFO = 1,
WAIT_AI = 2,
WAIT_FRAGMENT_COUNT = 3,
- SCAN_NEXT_ORDERED = 4,
- QUEUED_DELIVERED = 5,
- DELIVERED = 6,
- CLOSING_SCAN = 7
+ RUNNING = 4,
+ CLOSING_SCAN = 5
};
+
// State of this scan
ScanState scanState;
- // References to ScanFragRecs
- Uint32 scanFragrec[16];
- // Refrences to ScanOperationRecords
- Uint32 scanOprec[16];
- // Number of ScanOperationRecords allocated
- Uint32 noScanOprec;
+
+ DLList::Head m_running_scan_frags; // Currently in LQH
+ union { Uint32 m_queued_count; Uint32 scanReceivedOperations; };
+ DLList::Head m_queued_scan_frags; // In TC !sent to API
+ DLList::Head m_delivered_scan_frags;// Delivered to API
+ DLList::Head m_completed_scan_frags;// Completed
+
// Id of the next fragment to be scanned. Used by scan fragment
// processes when they are ready for the next fragment
Uint32 scanNextFragId;
+
// Total number of fragments in the table we are scanning
Uint32 scanNoFrag;
+
// Index of next ScanRecords when in free list
Uint32 nextScan;
+
// Length of expected attribute information
Uint32 scanAiLength;
+
// Reference to ApiConnectRecord
Uint32 scanApiRec;
+
// Reference to TcConnectRecord
Uint32 scanTcrec;
+
// Number of scan frag processes that belong to this scan
Uint32 scanParallel;
- // The number of recieved operations so far
- Uint32 scanReceivedOperations;
+
// Schema version used by this scan
Uint32 scanSchemaVersion;
+
// Index of stored procedure belonging to this scan
Uint32 scanStoredProcId;
+
// The index of table that is scanned
Uint32 scanTableref;
+
// Number of operation records per scanned fragment
Uint16 noOprecPerFrag;
- // The number of SCAN_TABINFO to receive
- Uint16 noScanTabInfo;
- // The number of SCAN_TABINFO received so far
- Uint16 scanTabInfoReceived;
- // apiIsClosed indicates if it's ok to release all resources
- // and send a response to the API
- // If it's false resources should not be released wait for API
- // to close the scan
- bool apiIsClosed;
- // The number of scan frag processes that have completed their task
- Uint8 scanProcessesCompleted;
- // This variable is ZFALSE as long as any scan process is still alive
- // It is ZTRUE as soon as all scan processes have been stopped
- Uint8 scanCompletedStatus;
+
// Shall the locks be held until the application have read the
// records
Uint8 scanLockHold;
+
// Shall the locks be read or write locks
Uint8 scanLockMode;
+
// Skip locks by other transactions and read latest committed
Uint8 readCommitted;
+
// Scan is on ordered index
Uint8 rangeScan;
};
typedef Ptr ScanRecordPtr;
- /**
- * Each scan has max 16 ScanOperationRecords
- * they are used for storing data to be sent to the api
- */
- struct ScanOperationRecord {
- // Reference to the scan operation in api
- Uint32 apiOpptr[16];
- // Index and length of all recieved operations
- // They will be cached here until SCAN_TABCONF is sent to api
- Uint32 scanOpLength[16];
- // Next ScanOperationRecord when in free list
- Uint32 nextScanOp;
- }; /* p2c: size = 132 bytes */
-
- typedef Ptr ScanOperationRecordPtr;
-
- /**
- * There is max 16 ScanFragRec's for
- * each scan started in TC. Each ScanFragRec is used by
- * a scan fragment "process" that scans one fragment at a time.
- * It will receive max 16 tuples in each request
- */
- struct ScanFragRec {
- /**
- * ScanFragState
- * WAIT_GET_PRIMCONF : Waiting for DIGETPRIMCONF when starting a new
- * fragment scan
- * LQH_ACTIVE : The scan process has sent a command to LQH and is
- * waiting for the response
- * LQH_ACTIVE_CLOSE : The scan process has sent close to LQH and is
- * waiting for the response
- * DELIVERED : The result have been delivered, this scan frag process
- * are waiting for a SCAN_NEXTREQ to tell us to continue scanning
- * RETURNING_FROM_DELIVERY : SCAN_NEXTREQ received and continuing scan
- * soon
- * QUEUED_FOR_DELIVERY : Result queued in TC and waiting for delivery
- * to API
- * COMPLETED : The fragment scan processes has completed and finally
- * sent a SCAN_PROCCONF
- */
- enum ScanFragState {
- IDLE = 0,
- WAIT_GET_PRIMCONF = 1,
- LQH_ACTIVE = 2,
- LQH_ACTIVE_CLOSE = 3,
- DELIVERED = 4,
- RETURNING_FROM_DELIVERY = 5,
- QUEUED_FOR_DELIVERY = 6,
- COMPLETED = 7
- };
- // Timer for checking timeout of this fragment scan
- Uint32 scanFragTimer;
- // Id of the current scanned fragment
- Uint32 scanFragId;
- // Blockreference of LQH
- BlockReference lqhBlockref;
- // getNodeInfo.m_connectCount, set at seize used so that
- // I don't accidently kill a starting node
- Uint32 m_connectCount;
- // State of this fragment scan
- ScanFragState scanFragState;
- // Id of the ScanRecord this fragment scan belongs to
- Uint32 scanRec;
- // Index of next ScanFragRec, when in list of
- // free ScanFragRec's
- Uint32 nextScanFrag;
- // Process id of this scan process within the total scan
- Uint32 scanFragProcId;
- // Node where current fragment resides
- NodeId scanFragNodeId;
- // Index of where to store the result in ScanRecord
- Uint16 scanIndividual;
- // The maximum number of operations that can be scanned before
- // returning to TC
- Uint16 scanFragConcurrency;
- // Current status of the fragment scan
- // * 0 = NOT COMPLETED
- // * 1 = COMPLETED
- // * 2 = CLOSED
- Uint8 scanFragCompletedStatus;
-
- inline void startFragTimer(Uint32 timeVal){
- scanFragTimer = timeVal;
- }
- inline void stopFragTimer(void){
- scanFragTimer = 0;
- }
- };
-
- typedef Ptr ScanFragRecPtr;
-
/* **********************************************************************$ */
/* ******$ DATA BUFFER ******$ */
/* */
@@ -1369,6 +1354,7 @@ private:
void execCREATE_TAB_REQ(Signal* signal);
void execPREP_DROP_TAB_REQ(Signal* signal);
void execDROP_TAB_REQ(Signal* signal);
+ void execWAIT_DROP_TAB_REF(Signal* signal);
void execWAIT_DROP_TAB_CONF(Signal* signal);
void checkWaitDropTabFailedLqh(Signal*, Uint32 nodeId, Uint32 tableId);
void execALTER_TAB_REQ(Signal* signal);
@@ -1428,23 +1414,17 @@ private:
Uint32 buddyPtr,
UintR transid1,
UintR transid2);
- void initScanOprec(Signal* signal);
void initScanrec(Signal* signal,
const UintR scanParallel,
const UintR noOprecPerFrag);
void initScanfragrec(Signal* signal);
- void releaseScanrec(Signal* signal);
- void releaseScanResources(Signal* signal);
- void releaseScanFragrec(Signal* signal);
- void releaseScanOprec(Signal* signal);
+ void releaseScanResources(ScanRecordPtr);
void seizeScanrec(Signal* signal);
- void seizeScanFragrec(Signal* signal);
- void seizeScanOprec(Signal* signal);
void sendScanFragReq(Signal* signal);
void sendScanTabConf(Signal* signal);
- void sendScanProcConf(Signal* signal);
- void setScanReceived(Signal* signal, Uint32 noCompletedOps);
-
+ void close_scan_req(Signal*, ScanRecordPtr);
+ void close_scan_req_send_conf(Signal*, ScanRecordPtr);
+
void checkGcp(Signal* signal);
void commitGciHandling(Signal* signal, UintR Tgci);
void copyApi(Signal* signal);
@@ -1473,12 +1453,12 @@ private:
void releaseApiCon(Signal* signal, UintR aApiConnectPtr);
void releaseApiConCopy(Signal* signal);
void releaseApiConnectFail(Signal* signal);
- void releaseAttrinfo(Signal* signal);
+ void releaseAttrinfo();
void releaseGcp(Signal* signal);
- void releaseKeys(Signal* signal);
+ void releaseKeys();
void releaseSimpleRead(Signal* signal);
void releaseDirtyWrite(Signal* signal);
- void releaseTcCon(Signal* signal);
+ void releaseTcCon();
void releaseTcConnectFail(Signal* signal);
void releaseTransResources(Signal* signal);
void saveAttrbuf(Signal* signal);
@@ -1638,6 +1618,8 @@ private:
void checkScanActiveInFailedLqh(Signal* signal,
Uint32 scanPtrI,
Uint32 failedNodeId);
+ void checkScanFragList(Signal*, Uint32 failedNodeId, ScanRecord * scanP,
+ LocalDLList::Head&);
// Initialisation
void initData();
@@ -1720,17 +1702,10 @@ private:
ScanRecordPtr scanptr;
UintR cscanrecFileSize;
- ScanOperationRecord *scanOperationRecord;
- ScanOperationRecordPtr scanOpptr;
- UintR cscanOprecFileSize;
-
- ScanFragRec *scanFragmentRecord;
+ UnsafeArrayPool c_scan_frag_pool;
ScanFragRecPtr scanFragptr;
- UintR cscanFragrecFileSize;
- UintR cfirstfreeScanOprec;
- UintR cnoFreeScanOprec;
- UintR cfirstfreeScanFragrec;
+ UintR cscanFragrecFileSize;
UintR cdatabufFilesize;
BlockReference cdictblockref;
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp b/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp
index 61ecca513f0..9ac1812492f 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp
@@ -35,7 +35,6 @@ void Dbtc::initData()
cgcpFilesize = ZGCP_FILESIZE;
cscanrecFileSize = ZSCANREC_FILE_SIZE;
cscanFragrecFileSize = ZSCAN_FRAGREC_FILE_SIZE;
- cscanOprecFileSize = ZSCAN_OPREC_FILE_SIZE;
ctabrecFilesize = ZTABREC_FILESIZE;
ctcConnectFilesize = ZTC_CONNECT_FILESIZE;
cdihblockref = DBDIH_REF;
@@ -49,8 +48,6 @@ void Dbtc::initData()
hostRecord = 0;
tableRecord = 0;
scanRecord = 0;
- scanOperationRecord = 0;
- scanFragmentRecord = 0;
databufRecord = 0;
attrbufRecord = 0;
gcpRecord = 0;
@@ -143,16 +140,19 @@ void Dbtc::initRecords()
sizeof(ScanRecord),
cscanrecFileSize);
- scanOperationRecord = (ScanOperationRecord*)
- allocRecord("ScanOperationRecord",
- sizeof(ScanOperationRecord),
- cscanOprecFileSize);
- scanFragmentRecord = (ScanFragRec*)
- allocRecord("ScanFragRec",
- sizeof(ScanFragRec),
- cscanFragrecFileSize);
+ c_scan_frag_pool.setSize(cscanFragrecFileSize);
+ {
+ ScanFragRecPtr ptr;
+ SLList tmp(c_scan_frag_pool);
+ while(tmp.seize(ptr)) {
+ new (ptr.p) ScanFragRec();
+ }
+ tmp.release();
+ }
+ indexOps.release();
+
databufRecord = (DatabufRecord*)allocRecord("DatabufRecord",
sizeof(DatabufRecord),
cdatabufFilesize);
@@ -213,10 +213,7 @@ Dbtc::Dbtc(const class Configuration & conf):
addRecSignal(GSN_ATTRINFO, &Dbtc::execATTRINFO);
addRecSignal(GSN_CONTINUEB, &Dbtc::execCONTINUEB);
addRecSignal(GSN_KEYINFO, &Dbtc::execKEYINFO);
- addRecSignal(GSN_SCAN_TABINFO, &Dbtc::execSCAN_TABINFO);
addRecSignal(GSN_SCAN_NEXTREQ, &Dbtc::execSCAN_NEXTREQ);
- addRecSignal(GSN_SCAN_PROCREQ, &Dbtc::execSCAN_PROCREQ);
- addRecSignal(GSN_SCAN_PROCCONF, &Dbtc::execSCAN_PROCCONF);
addRecSignal(GSN_TAKE_OVERTCREQ, &Dbtc::execTAKE_OVERTCREQ);
addRecSignal(GSN_TAKE_OVERTCCONF, &Dbtc::execTAKE_OVERTCCONF);
addRecSignal(GSN_LQHKEYREF, &Dbtc::execLQHKEYREF);
@@ -290,6 +287,7 @@ Dbtc::Dbtc(const class Configuration & conf):
//addRecSignal(GSN_CREATE_TAB_REQ, &Dbtc::execCREATE_TAB_REQ);
addRecSignal(GSN_DROP_TAB_REQ, &Dbtc::execDROP_TAB_REQ);
addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbtc::execPREP_DROP_TAB_REQ);
+ addRecSignal(GSN_WAIT_DROP_TAB_REF, &Dbtc::execWAIT_DROP_TAB_REF);
addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbtc::execWAIT_DROP_TAB_CONF);
addRecSignal(GSN_ALTER_TAB_REQ, &Dbtc::execALTER_TAB_REQ);
@@ -323,17 +321,7 @@ Dbtc::~Dbtc()
deallocRecord((void **)&scanRecord, "ScanRecord",
sizeof(ScanRecord),
cscanrecFileSize);
-
- deallocRecord((void **)&scanOperationRecord,
- "ScanOperationRecord",
- sizeof(ScanOperationRecord),
- cscanOprecFileSize);
-
- deallocRecord((void **)&scanFragmentRecord,
- "ScanFragRec",
- sizeof(ScanFragRec),
- cscanFragrecFileSize);
-
+
deallocRecord((void **)&databufRecord, "DatabufRecord",
sizeof(DatabufRecord),
cdatabufFilesize);
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index 1c916c2754c..edb51ea3c89 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -110,13 +110,7 @@ void Dbtc::execCONTINUEB(Signal* signal)
switch (tcase) {
case TcContinueB::ZRETURN_FROM_QUEUED_DELIVERY:
jam();
- scanptr.i = Tdata0;
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
- scanFragptr.i = Tdata1;
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- ndbrequire(scanFragptr.p->scanFragState ==
- ScanFragRec::RETURNING_FROM_DELIVERY);
- returnFromQueuedDeliveryLab(signal);
+ ndbrequire(false);
return;
case TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER:
jam();
@@ -374,6 +368,39 @@ Dbtc::execWAIT_DROP_TAB_CONF(Signal* signal)
}
}
+void
+Dbtc::execWAIT_DROP_TAB_REF(Signal* signal)
+{
+ jamEntry();
+ WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtr();
+
+ TableRecordPtr tabPtr;
+ tabPtr.i = ref->tableId;
+ ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord);
+
+ ndbrequire(tabPtr.p->dropping == true);
+ Uint32 nodeId = refToNode(ref->senderRef);
+ tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor(nodeId);
+
+ ndbrequire(ref->errorCode == WaitDropTabRef::NoSuchTable ||
+ ref->errorCode == WaitDropTabRef::NF_FakeErrorREF);
+
+ if(!tabPtr.p->dropTable.waitDropTabCount.done()){
+ jam();
+ return;
+ }
+
+ {
+ PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
+ conf->tableId = tabPtr.i;
+ conf->senderRef = reference();
+ conf->senderData = tabPtr.p->dropTable.senderData;
+ sendSignal(tabPtr.p->dropTable.senderRef, GSN_PREP_DROP_TAB_CONF, signal,
+ PrepDropTabConf::SignalLength, JBB);
+ tabPtr.p->dropTable.senderRef = 0;
+ }
+}
+
void
Dbtc::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId)
{
@@ -526,7 +553,6 @@ void Dbtc::execREAD_CONFIG_REQ(Signal* signal)
ctcConnectFilesize = tcConnect;
ctabrecFilesize = tables;
cscanrecFileSize = tcScan;
- cscanOprecFileSize = localScan;
cscanFragrecFileSize = localScan;
initRecords();
@@ -882,7 +908,15 @@ Dbtc::handleFailedApiNode(Signal* signal,
// sending several signals we will increase the loop count by 64.
/*********************************************************************/
jam();
- handleScanStop(signal, TapiFailedNode);
+
+ apiConnectptr.p->apiFailState = ZTRUE;
+ capiConnectClosing[TapiFailedNode]++;
+
+ ScanRecordPtr scanPtr;
+ scanPtr.i = apiConnectptr.p->apiScanRec;
+ ptrCheckGuard(scanPtr, cscanrecFileSize, scanRecord);
+ close_scan_req(signal, scanPtr);
+
TloopCount += 64;
break;
case CS_CONNECTED:
@@ -1072,6 +1106,7 @@ void Dbtc::handleApiFailState(Signal* signal, UintR TapiConnectptr)
*/
void Dbtc::handleScanStop(Signal* signal, UintR TapiFailedNode)
{
+#if JONAS_NOT_DONE
arrGuard(TapiFailedNode, MAX_NODES);
scanptr.i = apiConnectptr.p->apiScanRec;
@@ -1091,7 +1126,7 @@ void Dbtc::handleScanStop(Signal* signal, UintR TapiFailedNode)
* We will release the resources and then release the connection
* to the failed API.
*/
- releaseScanResources(signal);
+ releaseScanResources(scanptr);
if (apiNodeHasFailed) {
jam();
releaseApiCon(signal, apiConnectptr.i);
@@ -1189,6 +1224,7 @@ void Dbtc::handleScanStop(Signal* signal, UintR TapiFailedNode)
break;
}//switch
+#endif
}//Dbtc::handleScanStop()
/****************************************************************************
@@ -1341,6 +1377,7 @@ void Dbtc::sendSignalErrorRefuseLab(Signal* signal)
ptrGuard(apiConnectptr);
if (apiConnectptr.p->apiConnectstate != CS_DISCONNECTED) {
jam();
+ ndbrequire(false);
signal->theData[0] = apiConnectptr.p->ndbapiConnect;
signal->theData[1] = signal->theData[ttransid_ptr];
signal->theData[2] = signal->theData[ttransid_ptr + 1];
@@ -1424,6 +1461,7 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
signal->theData[1] = t1;
signal->theData[2] = t2;
signal->theData[3] = ZABORT_ERROR;
+ ndbrequire(false);
sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKREP,
signal, 4, JBB);
return;
@@ -1881,7 +1919,7 @@ void Dbtc::packKeyData000Lab(Signal* signal,
/* THERE WERE UNSENT INFORMATION, SEND IT. */
/*---------------------------------------------------------------------*/
sendKeyinfo(signal, TBRef, tdataPos);
- releaseKeys(signal);
+ releaseKeys();
return;
}//if
databufptr.i = databufptr.p->nextDatabuf;
@@ -3238,7 +3276,7 @@ void Dbtc::packLqhkeyreq040Lab(Signal* signal,
/*--------------------------------------------------------------------
* WE HAVE SENT ALL THE SIGNALS OF THIS OPERATION. SET STATE AND EXIT.
*---------------------------------------------------------------------*/
- releaseAttrinfo(signal);
+ releaseAttrinfo();
if (Tboth) {
jam();
releaseSimpleRead(signal);
@@ -3264,7 +3302,7 @@ void Dbtc::packLqhkeyreq040Lab(Signal* signal,
/* ========================================================================= */
/* ------- RELEASE ALL ATTRINFO RECORDS IN AN OPERATION RECORD ------- */
/* ========================================================================= */
-void Dbtc::releaseAttrinfo(Signal* signal)
+void Dbtc::releaseAttrinfo()
{
UintR Tmp;
AttrbufRecordPtr Tattrbufptr;
@@ -3296,7 +3334,7 @@ void Dbtc::releaseAttrinfo(Signal* signal)
regApiPtr->cachePtr = RNIL;
return;
}//if
- systemErrorLab(signal);
+ systemErrorLab(0);
return;
}//Dbtc::releaseAttrinfo()
@@ -3306,7 +3344,7 @@ void Dbtc::releaseAttrinfo(Signal* signal)
void Dbtc::releaseSimpleRead(Signal* signal)
{
unlinkReadyTcCon(signal);
- releaseTcCon(signal);
+ releaseTcCon();
/**
* No LQHKEYCONF in Simple/Dirty read
@@ -3370,7 +3408,7 @@ void Dbtc::unlinkReadyTcCon(Signal* signal)
}//if
}//Dbtc::unlinkReadyTcCon()
-void Dbtc::releaseTcCon(Signal* signal)
+void Dbtc::releaseTcCon()
{
TcConnectRecord * const regTcPtr = tcConnectptr.p;
UintR TfirstfreeTcConnect = cfirstfreeTcConnect;
@@ -4787,7 +4825,7 @@ void Dbtc::releaseTransResources(Signal* signal)
tcConnectptr.i = localTcConnectptr.i;
tcConnectptr.p = localTcConnectptr.p;
localTcConnectptr.i = rtrTcConnectptrIndex;
- releaseTcCon(signal);
+ releaseTcCon();
} while (localTcConnectptr.i != RNIL);
handleGcp(signal);
releaseFiredTriggerData(&apiConnectptr.p->theFiredTriggers);
@@ -4841,7 +4879,7 @@ void Dbtc::releaseApiConCopy(Signal* signal)
void Dbtc::releaseDirtyWrite(Signal* signal)
{
unlinkReadyTcCon(signal);
- releaseTcCon(signal);
+ releaseTcCon();
ApiConnectRecord * const regApiPtr = apiConnectptr.p;
if (regApiPtr->apiConnectstate == CS_START_COMMITTING) {
if (regApiPtr->firstTcConnect == RNIL) {
@@ -4942,7 +4980,7 @@ void Dbtc::execLQHKEYREF(Signal* signal)
regApiPtr->lqhkeyconfrec++;
unlinkReadyTcCon(signal);
- releaseTcCon(signal);
+ releaseTcCon();
opPtr.p->triggerExecutionCount--;
if (opPtr.p->triggerExecutionCount == 0) {
@@ -4998,7 +5036,7 @@ void Dbtc::execLQHKEYREF(Signal* signal)
Uint32 indexOp = tcConnectptr.p->indexOp;
Uint32 clientData = regTcPtr->clientData;
unlinkReadyTcCon(signal); /* LINK TC CONNECT RECORD OUT OF */
- releaseTcCon(signal); /* RELEASE THE TC CONNECT RECORD */
+ releaseTcCon(); /* RELEASE THE TC CONNECT RECORD */
setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__);
if (isIndexOp) {
jam();
@@ -6388,7 +6426,7 @@ void Dbtc::timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr)
UintR texpiredTime[8];
UintR TloopCount = 0;
Uint32 TtcTimer = ctcTimer;
-
+
while ((TscanConPtr + 8) < cscanFragrecFileSize) {
jam();
timeOutPtr[0].i = TscanConPtr + 0;
@@ -6400,14 +6438,14 @@ void Dbtc::timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr)
timeOutPtr[6].i = TscanConPtr + 6;
timeOutPtr[7].i = TscanConPtr + 7;
- ptrAss(timeOutPtr[0], scanFragmentRecord);
- ptrAss(timeOutPtr[1], scanFragmentRecord);
- ptrAss(timeOutPtr[2], scanFragmentRecord);
- ptrAss(timeOutPtr[3], scanFragmentRecord);
- ptrAss(timeOutPtr[4], scanFragmentRecord);
- ptrAss(timeOutPtr[5], scanFragmentRecord);
- ptrAss(timeOutPtr[6], scanFragmentRecord);
- ptrAss(timeOutPtr[7], scanFragmentRecord);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[0]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[1]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[2]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[3]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[4]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[5]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[6]);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[7]);
tfragTimer[0] = timeOutPtr[0].p->scanFragTimer;
tfragTimer[1] = timeOutPtr[1].p->scanFragTimer;
@@ -6459,7 +6497,7 @@ void Dbtc::timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr)
for ( ; TscanConPtr < cscanFragrecFileSize; TscanConPtr++){
jam();
timeOutPtr[0].i = TscanConPtr;
- ptrAss(timeOutPtr[0], scanFragmentRecord);
+ c_scan_frag_pool.getPtrForce(timeOutPtr[0]);
if (timeOutPtr[0].p->scanFragTimer != 0) {
texpiredTime[0] = ctcTimer - timeOutPtr[0].p->scanFragTimer;
if (texpiredTime[0] > ctimeOutValue) {
@@ -6475,6 +6513,7 @@ void Dbtc::timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr)
}//if
}//for
ctimeOutCheckFragActive = TOCS_FALSE;
+
return;
}//timeOutLoopStartFragLab()
@@ -6487,11 +6526,9 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
jamEntry();
scanFragptr.i = signal->theData[0];
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
-
+ c_scan_frag_pool.getPtr(scanFragptr);
switch (scanFragptr.p->scanFragState){
case ScanFragRec::LQH_ACTIVE:
- case ScanFragRec::LQH_ACTIVE_CLOSE:
break;
default:
@@ -6541,7 +6578,7 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
{
scanFragptr.i = TscanConPtr;
- ptrAss(scanFragptr, scanFragmentRecord);
+ c_scan_frag_pool.getPtr(scanFragptr);
DEBUG("timeOutFoundFragLab: scanFragState = "<scanFragState);
/*-------------------------------------------------------------------------*/
@@ -6563,39 +6600,11 @@ void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
*/
scanFragError(signal, ZSCAN_FRAG_LQH_ERROR);
DEBUG(" LQH_ACTIVE - closing the fragment scan in node "
- <scanFragNodeId);
+ << refToNode(scanFragptr.p->lqhBlockref));
break;
- case ScanFragRec::LQH_ACTIVE_CLOSE:{
- jam();
- /**
- * The close of LQH expired its time-out. This is not
- * acceptable behaviour from LQH and thus we will shoot
- * it down.
- */
- Uint32 nodeId = scanFragptr.p->scanFragNodeId;
- Uint32 cc = scanFragptr.p->m_connectCount;
- if(getNodeInfo(nodeId).m_connectCount == cc){
- const BlockReference errRef = calcNdbCntrBlockRef(nodeId);
- SystemError * const sysErr = (SystemError*)&signal->theData[0];
- sysErr->errorCode = SystemError::ScanfragTimeout;
- sysErr->errorRef = reference();
- sysErr->data1 = scanFragptr.i;
- sysErr->data2 = scanFragptr.p->scanRec;
- sendSignal(errRef, GSN_SYSTEM_ERROR, signal,
- SystemError::SignalLength, JBA);
- DEBUG(" node " << nodeId << " killed");
- } else {
- DEBUG(" node " << nodeId << " not killed as it has restarted");
- }
- scanFragptr.p->stopFragTimer();
- break;
- }
-
case ScanFragRec::DELIVERED:
jam();
- case ScanFragRec::RETURNING_FROM_DELIVERY:
- jam();
case ScanFragRec::IDLE:
jam();
case ScanFragRec::QUEUED_FOR_DELIVERY:
@@ -6851,47 +6860,17 @@ void Dbtc::execNODE_FAILREP(Signal* signal)
}//Dbtc::execNODE_FAILREP()
void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
- Uint32 scanPtrI,
- Uint32 failedNodeId){
+ Uint32 scanPtrI,
+ Uint32 failedNodeId){
for (scanptr.i = scanPtrI; scanptr.i < cscanrecFileSize; scanptr.i++) {
jam();
ptrAss(scanptr, scanRecord);
if (scanptr.p->scanState != ScanRecord::IDLE){
- for (Uint32 i=0; i<16; i++) {
- jam();
- scanFragptr.i = scanptr.p->scanFragrec[i];
- if (scanFragptr.i != RNIL) {
- jam();
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- if (scanFragptr.p->scanFragNodeId == failedNodeId){
- switch (scanFragptr.p->scanFragState){
- case ScanFragRec::LQH_ACTIVE:
- case ScanFragRec::LQH_ACTIVE_CLOSE:
- jam();
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize,
- apiConnectRecord);
+ checkScanFragList(signal, failedNodeId,
+ scanptr.p, scanptr.p->m_running_scan_frags);
+ }
- // The connection to this LQH is closed
- scanFragptr.p->lqhBlockref = RNIL;
-
- DEBUG("checkScanActiveInFailedLqh: scanFragError");
- scanFragError(signal, ZSCAN_LQH_ERROR);
-
- break;
-
- default:
- /* empty */
- jam();
- break;
- }// switch
-
- } //if
- } //if
- } //for
- } //if
-
// Send CONTINUEB to continue later
signal->theData[0] = TcContinueB::ZCHECK_SCAN_ACTIVE_FAILED_LQH;
signal->theData[1] = scanptr.i + 1; // Check next scanptr
@@ -6901,6 +6880,37 @@ void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
}//for
}
+void
+Dbtc::checkScanFragList(Signal* signal,
+ Uint32 failedNodeId,
+ ScanRecord * scanP,
+ ScanFragList::Head & head){
+
+ ScanFragRecPtr ptr;
+ ScanFragList list(c_scan_frag_pool, head);
+
+ for(list.first(ptr); !ptr.isNull(); list.next(ptr)){
+ if (refToNode(ptr.p->lqhBlockref) == failedNodeId){
+ switch (ptr.p->scanFragState){
+ case ScanFragRec::LQH_ACTIVE:
+ jam();
+ apiConnectptr.i = scanptr.p->scanApiRec;
+ ptrCheckGuard(apiConnectptr, capiConnectFilesize,
+ apiConnectRecord);
+
+ DEBUG("checkScanActiveInFailedLqh: scanFragError");
+ scanFragError(signal, ZSCAN_LQH_ERROR);
+
+ break;
+ default:
+ /* empty */
+ jam();
+ break;
+ }
+ }
+ }
+}
+
void Dbtc::execTAKE_OVERTCCONF(Signal* signal)
{
jamEntry();
@@ -8407,11 +8417,21 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
const Uint32 buddyPtr = (tmpXX == 0xFFFFFFFF ? RNIL : tmpXX);
Uint32 currSavePointId = 0;
- Uint8 scanConcurrency = scanTabReq->getParallelism(reqinfo);
- Uint32 scanParallel;
- Uint32 noOprecPerFrag;
+ Uint32 scanConcurrency = scanTabReq->getParallelism(reqinfo);
+ Uint32 noOprecPerFrag = ScanTabReq::getScanBatch(reqinfo);
+ Uint32 scanParallel = scanConcurrency;
Uint32 errCode;
+ if(noOprecPerFrag == 0){
+ jam();
+ scanParallel = (scanConcurrency + 15) / 16;
+ noOprecPerFrag = (scanConcurrency >= 16 ? 16 : scanConcurrency & 15);
+ }
+#ifdef VM_TRACE
+ ndbout_c("noOprecPerFrag=%d", noOprecPerFrag);
+ ndbout_c("scanParallel=%d", scanParallel);
+#endif
+
jamEntry();
apiConnectptr.i = scanTabReq->apiConnectPtr;
tabptr.i = scanTabReq->tableId;
@@ -8461,43 +8481,19 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
errCode = ZNO_CONCURRENCY_ERROR;
goto SCAN_TAB_error;
}//if
- if (scanConcurrency <= 16) {
- jam();
- noOprecPerFrag = scanConcurrency;
- } else {
- if (scanConcurrency <= 240) {
- jam();
- //If scanConcurrency > 16 it must be a multiple of 16
- if (((scanConcurrency >> 4) << 4) < scanConcurrency) {
- scanConcurrency = ((scanConcurrency >> 4) << 4) + 16;
- }//if
- } else {
- jam();
- errCode = ZTOO_HIGH_CONCURRENCY_ERROR;
- goto SCAN_TAB_error;
- }//if
- noOprecPerFrag = 16;
- }//if
-
- scanParallel = ((scanConcurrency - 1) >> 4) + 1;
+
/**********************************************************
* CALCULATE THE NUMBER OF SCAN_TABINFO SIGNALS THAT WILL
* ARRIVE TO DEFINE THIS SCAN. THIS ALSO DEFINES THE NUMBER
* OF PARALLEL SCANS AND IT ALSO DEFINES THE NUMBER OF SCAN
* OPERATION POINTER RECORDS TO ALLOCATE.
**********************************************************/
- if (cnoFreeScanOprec < scanParallel) {
- jam();
- errCode = ZNO_SCANREC_ERROR;
- goto SCAN_TAB_error;
- // WE DID NOT HAVE ENOUGH OF FREE SCAN OPERATION POINTER RECORDS.
- // THUS WE REFUSE THE SCAN OPERATION.
- }//if
if (cfirstfreeTcConnect == RNIL) {
jam();
errCode = ZNO_FREE_TC_CONNECTION;
goto SCAN_TAB_error;
}//if
+
if (cfirstfreeScanrec == RNIL) {
jam();
errCode = ZNO_SCANREC_ERROR;
@@ -8522,9 +8518,8 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
seizeCacheRecord(signal);
seizeScanrec(signal);
initScanrec(signal, scanParallel, noOprecPerFrag);
- initScanTcrec(signal);
+ tcConnectptr.p->apiConnect = apiConnectptr.i;
initScanApirec(signal, buddyPtr, transid1, transid2);
- cnoFreeScanOprec = cnoFreeScanOprec - scanParallel;
// The scan is started
apiConnectptr.p->apiConnectstate = CS_START_SCAN;
@@ -8536,11 +8531,7 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
***********************************************************/
setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__);
updateBuddyTimer(apiConnectptr);
- if (scanptr.p->noScanTabInfo > 1) {
- jam();
- scanptr.p->scanState = ScanRecord::WAIT_SCAN_TAB_INFO;
- return;
- }//if
+
/***********************************************************
* WE HAVE NOW RECEIVED ALL REFERENCES TO SCAN OBJECTS IN
* THE API. WE ARE NOW READY TO RECEIVE THE ATTRIBUTE INFO
@@ -8566,10 +8557,6 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
return;
}//Dbtc::execSCAN_TABREQ()
-void Dbtc::initScanTcrec(Signal* signal)
-{
- tcConnectptr.p->apiConnect = apiConnectptr.i;
-}//Dbtc::initScanTcrec()
void Dbtc::initScanApirec(Signal* signal,
Uint32 buddyPtr, UintR transid1, UintR transid2)
@@ -8583,16 +8570,6 @@ void Dbtc::initScanApirec(Signal* signal,
}//Dbtc::initScanApirec()
-void Dbtc::initScanOprec(Signal* signal)
-{
- UintR tisoIndex;
-
- for (tisoIndex = 0; tisoIndex < 16; tisoIndex++) {
- scanOpptr.p->apiOpptr[tisoIndex] = cdata[tisoIndex];
- scanOpptr.p->scanOpLength[tisoIndex] = RNIL;
- }//for
-}//Dbtc::initScanOprec()
-
void Dbtc::initScanrec(Signal* signal,
UintR scanParallel,
UintR noOprecPerFrag)
@@ -8607,34 +8584,26 @@ void Dbtc::initScanrec(Signal* signal,
scanptr.p->scanTableref = tabptr.i;
scanptr.p->scanSchemaVersion = scanTabReq->tableSchemaVersion;
scanptr.p->scanParallel = scanParallel;
- scanptr.p->noScanOprec = scanParallel;
- scanptr.p->noScanTabInfo = scanParallel;
- scanptr.p->scanTabInfoReceived = 1;
- scanptr.p->scanProcessesCompleted = 0;
+ scanptr.p->noOprecPerFrag = noOprecPerFrag;
scanptr.p->scanLockMode = ScanTabReq::getLockMode(reqinfo);
scanptr.p->scanLockHold = ScanTabReq::getHoldLockFlag(reqinfo);
scanptr.p->readCommitted = ScanTabReq::getReadCommittedFlag(reqinfo);
scanptr.p->rangeScan = ScanTabReq::getRangeScanFlag(reqinfo);
scanptr.p->scanStoredProcId = scanTabReq->storedProcId;
- scanptr.p->scanReceivedOperations = 0;
- scanptr.p->noOprecPerFrag = noOprecPerFrag;
- scanptr.p->apiIsClosed = false;
- scanptr.p->scanCompletedStatus = ZFALSE;
- scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED;
- for (Uint32 i = 0; i < 16; i++) {
- if (i < scanParallel){
- jam();
- seizeScanOprec(signal);
- scanptr.p->scanOprec[i] = scanOpptr.i;
- } else {
- jam();
- scanptr.p->scanOprec[i] = RNIL;
- }
- scanptr.p->scanFragrec[i] = RNIL;
+ scanptr.p->scanState = ScanRecord::RUNNING;
+ scanptr.p->m_queued_count = 0;
+
+ ScanFragList list(c_scan_frag_pool,
+ scanptr.p->m_running_scan_frags);
+ for (Uint32 i = 0; i < scanParallel; i++) {
+ jam();
+ ScanFragRecPtr ptr;
+ ndbrequire(list.seize(ptr));
+ ptr.p->scanRec = scanptr.i;
+ ptr.p->scanFragId = 0;
+ ptr.p->scanFragConcurrency = noOprecPerFrag;
+ ptr.p->m_apiPtr = cdata[i];
}//for
- scanOpptr.i = scanptr.p->scanOprec[0];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- initScanOprec(signal);
}//Dbtc::initScanrec()
void Dbtc::scanTabRefLab(Signal* signal, Uint32 errCode)
@@ -8648,58 +8617,6 @@ void Dbtc::scanTabRefLab(Signal* signal, Uint32 errCode)
signal, ScanTabRef::SignalLength, JBB);
}//Dbtc::scanTabRefLab()
-/******************************************************
- * execSCAN_TABINFO
- ******************************************************/
-void Dbtc::execSCAN_TABINFO(Signal* signal)
-{
- jamEntry();
- apiConnectptr.i = signal->theData[0];
- for(int i=0; i<16; i++)
- cdata[i] = signal->theData[i+1];
-
- if (apiConnectptr.i >= capiConnectFilesize) {
- jam();
- warningHandlerLab(signal);
- return;
- }//if
- ptrAss(apiConnectptr, apiConnectRecord);
-
- if (apiConnectptr.p->apiConnectstate != CS_START_SCAN){
- jam();
- DEBUG("apiPtr(" << apiConnectptr.i << ") Dropping SCAN_TABINFO, wrong state: " << apiConnectptr.p->apiConnectstate);
- return;
- }
-
- scanptr.i = apiConnectptr.p->apiScanRec;
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
-
- const Uint32 tscanOprec = scanptr.p->scanTabInfoReceived;
- scanptr.p->scanTabInfoReceived++;
- arrGuard(tscanOprec, 16);
- scanOpptr.i = scanptr.p->scanOprec[tscanOprec];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- // Start timer and wait for response from API node.
- setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__);
- updateBuddyTimer(apiConnectptr);
-
- initScanOprec(signal);
- // Start timer and wait for response from API node.
- setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__);
- updateBuddyTimer(apiConnectptr);
-
- if (scanptr.p->scanTabInfoReceived == scanptr.p->noScanTabInfo) {
- jam();
- /******************************************************************
- * WE HAVE NOW RECEIVED ALL REFERENCES TO SCAN OBJECTS IN THE API.
- * WE ARE NOW READY TO RECEIVE THE ATTRIBUTE INFO IF ANY TO RECEIVE.
- ******************************************************************/
- scanptr.p->scanState = ScanRecord::WAIT_AI;
- return;
- }
- ndbrequire(scanptr.p->scanTabInfoReceived <= scanptr.p->noScanTabInfo);
-}//Dbtc::execSCAN_TABINFO()
-
/*---------------------------------------------------------------------------*/
/* */
/* RECEPTION OF ATTRINFO FOR SCAN TABLE REQUEST. */
@@ -8805,7 +8722,7 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT);
if (apiConnectptr.p->apiFailState == ZTRUE) {
jam();
- releaseScanResources(signal);
+ releaseScanResources(scanptr);
handleApiFailState(signal, apiConnectptr.i);
return;
}//if
@@ -8828,31 +8745,40 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
return;
}
- if (tfragCount < scanptr.p->scanParallel) {
+ if(scanptr.p->scanParallel > tfragCount){
jam();
- for (Uint32 i = tfragCount; i < scanptr.p->scanParallel; i++) {
- jam();
- arrGuard(i, 16);
- scanOpptr.i = scanptr.p->scanOprec[i];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- releaseScanOprec(signal);
- scanptr.p->scanOprec[i] = RNIL;
- }//for
- scanptr.p->scanParallel = tfragCount;
- }//if
+ abortScanLab(signal, ZTOO_HIGH_CONCURRENCY_ERROR);
+ return;
+ }
+
+ scanptr.p->scanParallel = tfragCount;
scanptr.p->scanNoFrag = tfragCount;
- for (UintR i = 0; i < scanptr.p->scanParallel; i++) {
- jam();
- // START EACH OF THE PARALLEL SCAN PROCESSES
- signal->theData[0] = scanptr.i;
- signal->theData[1] = i;
- signal->theData[2] = scanptr.p->noOprecPerFrag;
- sendSignal(cownref, GSN_SCAN_PROCREQ, signal, 3, JBB);
- }//for
- // We don't need the timer for checking API anymore, control goes to LQH.
+ scanptr.p->scanNextFragId = 0;
setApiConTimer(apiConnectptr.i, 0, __LINE__);
- scanptr.p->scanNextFragId = scanptr.p->scanParallel;
- scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED;
+ updateBuddyTimer(apiConnectptr);
+
+ ScanFragRecPtr ptr;
+ ScanFragList list(c_scan_frag_pool,
+ scanptr.p->m_running_scan_frags);
+ for (list.first(ptr); !ptr.isNull(); list.next(ptr)){
+ jam();
+
+#ifdef VM_TRACE
+ ndbout_c("DIGETPRIMREQ(%d, %d)",
+ scanptr.p->scanTableref, scanptr.p->scanNextFragId);
+#endif
+
+ ptr.p->startFragTimer(ctcTimer);
+ ptr.p->scanFragId = scanptr.p->scanNextFragId++;
+ ptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF;
+ ptr.p->startFragTimer(ctcTimer);
+
+ signal->theData[0] = tcConnectptr.p->dihConnectptr;
+ signal->theData[1] = ptr.i;
+ signal->theData[2] = scanptr.p->scanTableref;
+ signal->theData[3] = ptr.p->scanFragId;
+ sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB);
+ }//for
}//Dbtc::execDI_FCOUNTCONF()
/******************************************************
@@ -8871,7 +8797,7 @@ void Dbtc::execDI_FCOUNTREF(Signal* signal)
ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT);
if (apiConnectptr.p->apiFailState == ZTRUE) {
jam();
- releaseScanResources(signal);
+ releaseScanResources(scanptr);
handleApiFailState(signal, apiConnectptr.i);
return;
}//if
@@ -8880,126 +8806,43 @@ void Dbtc::execDI_FCOUNTREF(Signal* signal)
void Dbtc::abortScanLab(Signal* signal, Uint32 errCode)
{
- releaseScanResources(signal);
scanTabRefLab(signal, errCode);
+ releaseScanResources(scanptr);
}//Dbtc::abortScanLab()
-void Dbtc::scanReleaseResourcesLab(Signal* signal)
-{
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
- if (apiConnectptr.p->returncode != 0) {
- jam();
- ScanTabRef * ref = (ScanTabRef*)&signal->theData[0];
- ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
- ref->transId1 = apiConnectptr.p->transid[0];
- ref->transId2 = apiConnectptr.p->transid[1];
- ref->errorCode = apiConnectptr.p->returncode;
- sendSignal(apiConnectptr.p->ndbapiBlockref,
- GSN_SCAN_TABREF, signal, ScanTabRef::SignalLength, JBB);
- } else {
- jam();
- sendScanTabConf(signal);
- }//if
- releaseScanResources(signal);
- if (apiConnectptr.p->apiFailState == ZTRUE) {
- jam();
- handleApiFailState(signal, apiConnectptr.i);
- return;
- }//if
-}//Dbtc::scanReleaseResourcesLab()
-
-void Dbtc::releaseScanResources(Signal* signal)
+void Dbtc::releaseScanResources(ScanRecordPtr scanPtr)
{
+#ifdef VM_TRACE
+ ndbout_c("releaseScanResources: %d", scanPtr.i);
+#endif
if (apiConnectptr.p->cachePtr != RNIL) {
cachePtr.i = apiConnectptr.p->cachePtr;
ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord);
- releaseAttrinfo(signal);
+ releaseAttrinfo();
}//if
- cnoFreeScanOprec = cnoFreeScanOprec + scanptr.p->noScanOprec;
- scanptr.p->scanCompletedStatus = ZCLOSED;
- tcConnectptr.i = scanptr.p->scanTcrec;
+ tcConnectptr.i = scanPtr.p->scanTcrec;
ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
- releaseTcCon(signal);
- for (Uint32 i = 0; i < 16; i++) {
- jam();
- scanFragptr.i = scanptr.p->scanFragrec[i];
- scanptr.p->scanFragrec[i] = RNIL;
- if (scanFragptr.i != RNIL) {
- jam();
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- releaseScanFragrec(signal);
- }//if
- scanOpptr.i = scanptr.p->scanOprec[i];
- scanptr.p->scanOprec[i] = RNIL;
- if (scanOpptr.i != RNIL) {
- jam();
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- releaseScanOprec(signal);
- }//if
- }//for
- releaseScanrec(signal);
+ releaseTcCon();
+
+ ScanFragList x(c_scan_frag_pool,
+ scanPtr.p->m_completed_scan_frags);
+ x.release();
+ ndbrequire(scanPtr.p->m_running_scan_frags.isEmpty());
+ ndbrequire(scanPtr.p->m_queued_scan_frags.isEmpty());
+ ndbrequire(scanPtr.p->m_delivered_scan_frags.isEmpty());
+
+ // link into free list
+ scanPtr.p->nextScan = cfirstfreeScanrec;
+ scanPtr.p->scanState = ScanRecord::IDLE;
+ scanPtr.p->scanTcrec = RNIL;
+ cfirstfreeScanrec = scanPtr.i;
+
apiConnectptr.p->apiScanRec = RNIL;
apiConnectptr.p->apiConnectstate = CS_CONNECTED;
setApiConTimer(apiConnectptr.i, 0, __LINE__);
}//Dbtc::releaseScanResources()
-/******************************************************
- * execSCAN_PROCREQ
- ******************************************************/
-void Dbtc::execSCAN_PROCREQ(Signal* signal)
-{
- jamEntry();
- scanptr.i = signal->theData[0];
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
-
- const UintR tscanFragId = signal->theData[1];
- ndbrequire(tscanFragId < 16);
- const UintR tscanNoOprec = signal->theData[2];
-
- ndbrequire(cfirstfreeScanFragrec != RNIL);
- seizeScanFragrec(signal);
-
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
- setApiConTimer(apiConnectptr.i, 0, __LINE__);
-
- scanptr.p->scanFragrec[tscanFragId] = scanFragptr.i;
- scanFragptr.p->scanRec = scanptr.i;
- scanFragptr.p->scanIndividual = tscanFragId * tscanNoOprec;
- scanFragptr.p->scanFragProcId = tscanFragId;
- scanFragptr.p->scanFragId = tscanFragId;
- scanFragptr.p->scanFragConcurrency = tscanNoOprec;
- scanFragptr.p->scanFragCompletedStatus = ZFALSE;
- tcConnectptr.i = scanptr.p->scanTcrec;
- ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
-
- {
- /**
- * Check table
- */
- TableRecordPtr tabPtr;
- tabPtr.i = scanptr.p->scanTableref;
- ptrAss(tabPtr, tableRecord);
- Uint32 schemaVersion = scanptr.p->scanSchemaVersion;
- if(tabPtr.p->checkTable(schemaVersion) == false){
- jam();
- scanFragError(signal, tabPtr.p->getErrorCode(schemaVersion));
- return;
- }
- }
-
- signal->theData[0] = tcConnectptr.p->dihConnectptr;
- signal->theData[1] = scanFragptr.i;
- signal->theData[2] = scanptr.p->scanTableref;
- signal->theData[3] = tscanFragId;
- sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB);
- scanFragptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF;
- updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
-}//Dbtc::execSCAN_PROCREQ()
-
/****************************************************************
* execDIGETPRIMCONF
*
@@ -9012,14 +8855,13 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
jamEntry();
// tcConnectptr.i in theData[0] is not used
scanFragptr.i = signal->theData[1];
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
+ c_scan_frag_pool.getPtr(scanFragptr);
tnodeid = signal->theData[2];
arrGuard(tnodeid, MAX_NDB_NODES);
ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF);
scanFragptr.p->stopFragTimer();
- scanFragptr.p->lqhBlockref = RNIL;
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -9049,16 +8891,22 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
case ScanRecord::CLOSING_SCAN:
jam();
updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
- sendScanProcConf(signal);
+ {
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(scanFragptr);
+ comp.add(scanFragptr);
+ }
+ close_scan_req_send_conf(signal, scanptr);
return;
default:
jam();
/*empty*/;
break;
}//switch
- scanFragptr.p->scanFragNodeId = tnodeid;
- scanFragptr.p->lqhBlockref = calcLqhBlockRef(tnodeid);
+ Uint32 ref = calcLqhBlockRef(tnodeid);
+ scanFragptr.p->lqhBlockref = ref;
scanFragptr.p->m_connectCount = getNodeInfo(tnodeid).m_connectCount;
sendScanFragReq(signal);
attrbufptr.i = cachePtr.p->firstAttrbuf;
@@ -9068,12 +8916,12 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
sendAttrinfo(signal,
scanFragptr.i,
attrbufptr.p,
- scanFragptr.p->lqhBlockref);
+ ref);
attrbufptr.i = attrbufptr.p->attrbuf[ZINBUF_NEXT];
}//while
scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
- updateBuddyTimer(apiConnectptr);
scanFragptr.p->startFragTimer(ctcTimer);
+ updateBuddyTimer(apiConnectptr);
/*********************************************
* WE HAVE NOW STARTED A FRAGMENT SCAN. NOW
* WAIT FOR THE FIRST SCANNED RECORDS
@@ -9093,7 +8941,7 @@ void Dbtc::execDIGETPRIMREF(Signal* signal)
// tcConnectptr.i in theData[0] is not used.
scanFragptr.i = signal->theData[1];
const Uint32 errCode = signal->theData[2];
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
+ c_scan_frag_pool.getPtr(scanFragptr);
ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF);
scanFragError(signal, errCode);
}//Dbtc::execDIGETPRIMREF()
@@ -9112,7 +8960,7 @@ void Dbtc::execSCAN_FRAGREF(Signal* signal)
const Uint32 errCode = ref->errorCode;
scanFragptr.i = ref->senderData;
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
+ c_scan_frag_pool.getPtr(scanFragptr);
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -9133,7 +8981,6 @@ void Dbtc::execSCAN_FRAGREF(Signal* signal)
* stop fragment timer and call scanFragError to start
* close of the other fragment scans
*/
- scanFragptr.p->lqhBlockref = RNIL;
scanFragError(signal, errCode);
}//Dbtc::execSCAN_FRAGREF()
@@ -9154,33 +9001,20 @@ void Dbtc::scanFragError(Signal* signal, Uint32 errorCode)
<< ", scanState = " << scanptr.p->scanState);
scanFragptr.p->stopFragTimer();
+#if JONAS_NOT_DONE
apiConnectptr.i = scanptr.p->scanApiRec;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
- if (scanFragptr.p->lqhBlockref == RNIL){
- // Since the lqh is closed, this scan process should be reported
- // as completed immediately
- jam();
- updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
- sendScanProcConf(signal);
- }//if
// If close of the scan is not already started
if (scanptr.p->scanState != ScanRecord::CLOSING_SCAN) {
jam();
apiConnectptr.p->returncode = errorCode;
- /**
- * Only set apiIsClosed if API is waiting for an answer
- */
- if (scanptr.p->scanState == ScanRecord::SCAN_NEXT_ORDERED){
- jam();
- scanptr.p->apiIsClosed = true;
- }
scanCompletedLab(signal);
return;
}//if
+#endif
}//Dbtc::scanFragError()
@@ -9197,14 +9031,12 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
const ScanFragConf * const conf = (ScanFragConf*)&signal->theData[0];
const Uint32 noCompletedOps = conf->completedOps;
- for(Uint32 i = 0; iopReturnDataLen[i];
scanFragptr.i = conf->senderData;
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
-
+ c_scan_frag_pool.getPtr(scanFragptr);
+
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
-
+
apiConnectptr.i = scanptr.p->scanApiRec;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
@@ -9215,143 +9047,21 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
jam();
systemErrorLab(signal);
}//if
-
- scanFragptr.p->scanFragCompletedStatus = conf->fragmentCompleted;
+
+ ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::LQH_ACTIVE);
+
+ const Uint32 status = conf->fragmentCompleted;
scanFragptr.p->stopFragTimer();
- switch (scanFragptr.p->scanFragCompletedStatus) {
- case ZFALSE:
- case ZTRUE:
- jam();
- /* empty */
- break;
+ if(scanptr.p->scanState == ScanRecord::CLOSING_SCAN){
+ if(status == ZFALSE){
+ /**
+ * Dont deliver to api, but instead close in LQH
+ * Dont need to mess with queues
+ */
+ ndbout_c("running -> running(close)");
- case ZCLOSED:
- /* The scan has finished this fragment. */
- jam();
- returnFromQueuedDeliveryLab(signal);
- return;
- break;
-
- default:
- jam();
- systemErrorLab(signal);
- break;
- }//switch
-
- // CHECK THE STATE OF THE DELIVERY PROCESS TO THE APPLICATION.
- switch (scanptr.p->scanState) {
- case ScanRecord::SCAN_NEXT_ORDERED:
- jam();
- /**
- * THE APPLICATION HAVE ISSUED A SCAN_NEXTREQ AND IS WAITING
- * FOR MORE OPERATIONS. SEND OPERATIONS DIRECTLY
- */
- if (noCompletedOps > 0) {
jam();
- setScanReceived(signal, noCompletedOps);
- sendScanTabConf(signal);
- scanptr.p->scanState = ScanRecord::DELIVERED;
- scanFragptr.p->scanFragState = ScanFragRec::DELIVERED;
- return;
- }//if
- break;
-
- case ScanRecord::DELIVERED:
- case ScanRecord::QUEUED_DELIVERED:
- jam();
- /**
- * THE APPLICATION HAVE ALREADY RECEIVED A DELIVERY.
- * QUEUE THE RECEIVED SCAN OPERATIONS AND ISSUE THEM
- * WHEN THE APPLICATION ASKS FOR MORE.
- */
- if (noCompletedOps > 0) {
- jam();
- setScanReceived(signal, noCompletedOps);
- scanptr.p->scanState = ScanRecord::QUEUED_DELIVERED;
- scanFragptr.p->scanFragState = ScanFragRec::QUEUED_FOR_DELIVERY;
- return;
- }//if
- break;
-
- case ScanRecord::CLOSING_SCAN:
- jam();
- /*************************************************
- * WE ARE CURRENTLY CLOSING THE SCAN.
- *
- * WE HAVE ALREADY ORDERED THE FRAGMENT TO CLOSE ITS
- * SCAN. THIS SIGNAL MUST HAVE BEEN SENT BEFORE THIS
- * CLOSE SIGNAL ARRIVED. SIMPLY IGNORE THIS SIGNAL.
- **************************************************/
- return;
- break;
-
- default:
- jam();
- systemErrorLab(signal);
- break;
-
- }//switch
-
- /**
- * THERE WAS NO TUPLES LEFT TO REPORT IN THIS FRAGMENT. CLOSE SCAN
- * HAVE NOT BEEN ORDERED. WE CAN CONTINUE THE SCAN PROCESS IMMEDIATELY.
- * THE COMPLETED STATUS MUST BE TRUE SINCE IT IS NOT CLOSED. IF IT WAS
- * FALSE IT MUST HAVE BEEN MORE TUPLES TO SCAN AND AT LEAST ONE OF
- * THOSE SHOULD HAVE BEEN REPORTED.
- */
- if (scanFragptr.p->scanFragCompletedStatus == ZFALSE) {
- jam();
- /**
- * THE SENDING NODE IS OUT OF ORDER WE WILL KILL IT BY SENDING SYSTEM
- * ERROR TO IT
- */
- const BlockReference errRef =
- calcNdbCntrBlockRef(scanFragptr.p->scanFragNodeId);
- SystemError * const sysErr = (SystemError*)&signal->theData[0];
- sysErr->errorCode = SystemError::ScanfragStateError;
- sysErr->errorRef = reference();
- sendSignal(errRef, GSN_SYSTEM_ERROR, signal,
- SystemError::SignalLength, JBA);
- return;
- }//if
- returnFromQueuedDeliveryLab(signal);
-}//Dbtc::execSCAN_FRAGCONF()
-
-void Dbtc::returnFromQueuedDeliveryLab(Signal* signal)
-{
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
-
- switch(scanFragptr.p->scanFragCompletedStatus) {
- case ZFALSE:
- {
- /*********************************************************************
- * WE HAVE SENT THE SCANNED OPERATION TO THE APPLICATION AND WE HAVE
- * RECEIVED THE ORDER TO CONTINUE SCANNING. THE CURRENT FRAGMENT STILL
- * CONTAINS MORE TUPLES TO SCAN.
- *********************************************************************/
- jam();
- scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
- ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
- nextReq->senderData = scanFragptr.i;
- nextReq->closeFlag = ZFALSE;
- nextReq->transId1 = apiConnectptr.p->transid[0];
- nextReq->transId2 = apiConnectptr.p->transid[1];
- sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
- ScanFragNextReq::SignalLength, JBB);
- }
- break;
-
- case ZTRUE:
- {
- /*********************************************************************
- * WE HAVE SENT THE SCANNED OPERATION TO THE APPLICATION AND WE HAVE
- * RECEIVED THE ORDER TO CONTINUE SCANNING. THE CURRENT FRAGMENT HAVE
- * BEEN COMPLETELY SCANNED AND WE ARE READY TO CLOSE IT.
- *********************************************************************/
- jam();
- scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE_CLOSE;
ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
nextReq->senderData = scanFragptr.i;
nextReq->closeFlag = ZTRUE;
@@ -9359,126 +9069,66 @@ void Dbtc::returnFromQueuedDeliveryLab(Signal* signal)
nextReq->transId2 = apiConnectptr.p->transid[1];
sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- }
- break;
-
- case ZCLOSED:
- {
- /********************************************************************
- * THE SCANNED FRAGMENT HAVE BEEN CLOSED. IF CLOSE SCAN HAVE BEEN
- * ORDERED THEN WE CAN REPORT THAT THIS SCAN PROCESS IS COMPLETED.
- * ALSO IF THERE ARE NO MORE FRAGMENTS TO SCAN WE CAN REPORT THAT
- * THE SCAN PROCESS IS COMPLETED.
- ********************************************************************/
- jam();
- scanFragptr.p->lqhBlockref = RNIL;
- if ((scanptr.p->scanState != ScanRecord::CLOSING_SCAN) &&
- (scanptr.p->scanNextFragId < scanptr.p->scanNoFrag)){
- jam();
- scanFragptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF;
- tcConnectptr.i = scanptr.p->scanTcrec;
- ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
- scanFragptr.p->scanFragId = scanptr.p->scanNextFragId;
- scanptr.p->scanNextFragId++;
- signal->theData[0] = tcConnectptr.p->dihConnectptr;
- signal->theData[1] = scanFragptr.i;
- signal->theData[2] = scanptr.p->scanTableref;
- signal->theData[3] = scanFragptr.p->scanFragId;
- sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB);
- } else {
- jam();
- sendScanProcConf(signal);
- }//if
- }
- break;
-
- default:
- jam();
- systemErrorLab(signal);
- break;
- }//switch
-
- updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
-}//Dbtc::returnFromQueuedDeliveryLab()
-
-/**********************************************************
- * execSCAN_PROCCONF
- **********************************************************/
-void Dbtc::execSCAN_PROCCONF(Signal* signal)
-{
- jamEntry();
-
- scanptr.i = signal->theData[0];
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
- scanptr.p->scanProcessesCompleted++;
- ndbassert(scanptr.p->scanProcessesCompleted <= scanptr.p->scanParallel);
-
- scanFragptr.i = signal->theData[1];
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- scanFragptr.p->stopFragTimer();
- scanFragptr.p->scanFragState = ScanFragRec::COMPLETED;
-
- if (scanptr.p->scanProcessesCompleted == scanptr.p->scanParallel) {
- jam();
-
- // Check that all scan processes are in state COMPLETED
- for (Uint32 i = 0; i < 16; i++) {
- scanFragptr.i = scanptr.p->scanFragrec[i];
- if (scanFragptr.i != RNIL) {
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::COMPLETED);
- }
- }
-
- // ALL SCAN PROCESSES HAS COMPLETED
- scanptr.p->scanCompletedStatus = ZTRUE;
- switch (scanptr.p->scanState) {
-
- case ScanRecord::CLOSING_SCAN:
- jam();
- if (scanptr.p->apiIsClosed == true) {
- jam();
- /*
- * The API has either failed or ordered a close of this scan
- * it's resources should be released and a response sent
- */
- scanReleaseResourcesLab(signal);
- return;
- }//if
-
- /**
- * The close have been performed but the API is still alive and not
- * expecting a response, keep resources until API fails or it orders
- * a close
- */
return;
- case ScanRecord::SCAN_NEXT_ORDERED:
+ } else {
jam();
- /**
- * The scan is completed and api is waiting for a response.
- * Reslease resources and send a response.
- */
- scanReleaseResourcesLab(signal);
- return;
- case ScanRecord::DELIVERED:
- case ScanRecord::QUEUED_DELIVERED:
- jam();
- /**
- * All processes have reported completion, wait for a new request from
- * API and start close of the scan then.
- */
- scanptr.p->scanReceivedOperations = 0;
- scanptr.p->scanState = ScanRecord::CLOSING_SCAN;
- return;
- default:
- jam();
- systemErrorLab(signal);
- break;
- }//switch
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(scanFragptr);
+ comp.add(scanFragptr);
+ }
+ close_scan_req_send_conf(signal, scanptr);
+ return;
}
-}//Dbtc::execSCAN_PROCCONF()
+
+ if(status == ZCLOSED && scanptr.p->scanNextFragId < scanptr.p->scanNoFrag){
+ /**
+ * Start on next fragment
+ */
+ ndbrequire(noCompletedOps == 0);
+ scanFragptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF;
+ scanFragptr.p->startFragTimer(ctcTimer);
+ tcConnectptr.i = scanptr.p->scanTcrec;
+ ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
+ scanFragptr.p->scanFragId = scanptr.p->scanNextFragId++;
+ signal->theData[0] = tcConnectptr.p->dihConnectptr;
+ signal->theData[1] = scanFragptr.i;
+ signal->theData[2] = scanptr.p->scanTableref;
+ signal->theData[3] = scanFragptr.p->scanFragId;
+ sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB);
+ return;
+ }
+
+ Uint32 chksum = 0;
+ Uint32 totalLen = 0;
+ for(Uint32 i = 0; iopReturnDataLen[i];
+ chksum += (tmp << i);
+ totalLen += tmp;
+ }
+
+ {
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList queued(c_scan_frag_pool, scanptr.p->m_queued_scan_frags);
+
+ run.remove(scanFragptr);
+ queued.add(scanFragptr);
+ scanptr.p->m_queued_count++;
+ }
+
+ scanFragptr.p->m_ops = noCompletedOps;
+ scanFragptr.p->m_chksum = chksum;
+ scanFragptr.p->m_totalLen = totalLen;
+ scanFragptr.p->scanFragState = ScanFragRec::QUEUED_FOR_DELIVERY;
+ scanFragptr.p->stopFragTimer();
+
+ if(scanptr.p->m_queued_count > /** Min */ 0){
+ jam();
+ sendScanTabConf(signal);
+ }
+}//Dbtc::execSCAN_FRAGCONF()
/****************************************************************************
* execSCAN_NEXTREQ
@@ -9541,7 +9191,7 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
scanTabRefLab(signal, ZSTATE_ERROR);
return;
}//if
-
+
/*******************************************************
* START THE ACTUAL LOGIC OF SCAN_NEXTREQ.
********************************************************/
@@ -9549,202 +9199,176 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
setApiConTimer(apiConnectptr.i, 0, __LINE__);
scanptr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
+ ScanRecord* scanP = scanptr.p;
- if (scanptr.p->apiIsClosed == true) {
- jam();
- /**
- * The close is already started. Api has failed or
- * has not responded in time so this signal is not allowed
- */
- DEBUG("execSCAN_NEXTREQ: apiIsClosed == true");
- DEBUG(" apiConnectstate="<apiConnectstate);
- DEBUG(" scanState="<scanState);
- return;
- }//if
-
-
- if (scanptr.p->scanState == ScanRecord::CLOSING_SCAN) {
- jam();
- /*********************************************************************
- * WE HAVE STARTED A CLOSE OF THIS SCAN OPERATION. NOW WE CAN REPORT
- * THIS TO THE APPLICATION. BEFORE WE REPORT IT TO THE APPLICATION WE
- * MUST COMPLETE THE CLOSE FIRST.
- *********************************************************************/
- if (scanptr.p->scanCompletedStatus == ZTRUE) {
- jam();
- /*********************************************************************
- * THE SCAN IS ALREADY COMPLETED. WE ARE NOW READY TO COMPLETE THE SCAN
- * BY RELEASING ALL RESOURCES AND SENDING THE CONFIRMATION TO THE
- * APPLICATION.
- *********************************************************************/
- scanReleaseResourcesLab(signal);
- return;
- } else {
- jam();
- /*********************************************************************
- * THE CLOSE IS ONGOING BUT NOT YET COMPLETED. WE WILL SET THE STATE
- * TO INDICATE THAT THE APPLICATION IS WAITING FOR THE RESPONSE.
- *********************************************************************/
- scanptr.p->apiIsClosed = true;
- return;
- }//if
- }//if
+ const Uint32 len = signal->getLength() - 4;
if (stopScan == ZTRUE) {
jam();
/*********************************************************************
* APPLICATION IS CLOSING THE SCAN.
**********************************************************************/
- scanptr.p->apiIsClosed = true;
- scanCompletedLab(signal);
+ ndbrequire(len == 0);
+ close_scan_req(signal, scanptr);
return;
}//if
- /*********************************************************************
- * THOSE SCAN PROCESSES THAT WAS SENT IN PREVIOUS MESSAGE ARE
- * ACKNOWLEDGED BY THIS REQUEST FOR MORE SCANNED OPERATIONS. WE CAN
- * THUS RESTART THOSE SCAN PROCESSES.
- *********************************************************************/
- for (Uint32 i = 0; i < 16; i++) {
- jam();
- scanFragptr.i = scanptr.p->scanFragrec[i];
- if (scanFragptr.i != RNIL) {
- jam();
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- if (scanFragptr.p->scanFragState == ScanFragRec::DELIVERED) {
- jam();
- scanFragptr.p->scanFragState = ScanFragRec::RETURNING_FROM_DELIVERY;
- signal->theData[0] = TcContinueB::ZRETURN_FROM_QUEUED_DELIVERY;
- signal->theData[1] = scanptr.i;
- signal->theData[2] = scanFragptr.i;
- sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB);
- }
- }//if
- }//for
+ // Copy op ptrs so I dont overwrite them when sending...
+ memcpy(signal->getDataPtrSend()+25, signal->getDataPtr()+4, 4 * len);
- switch (scanptr.p->scanState) {
- case ScanRecord::QUEUED_DELIVERED:
- /*********************************************************************
- * A NUMBER OF SCAN PROCESSES ARE READY TO DELIVER. DELIVER AND SET
- * STATE TO DELIVERED. ALSO CONTINUE PROCESS QUEUED SCAN PROCESSES.
- *********************************************************************/
+ ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
+ nextReq->closeFlag = ZFALSE;
+ nextReq->transId1 = apiConnectptr.p->transid[0];
+ nextReq->transId2 = apiConnectptr.p->transid[1];
+
+ ScanFragList running(c_scan_frag_pool, scanP->m_running_scan_frags);
+ ScanFragList delivered(c_scan_frag_pool, scanP->m_delivered_scan_frags);
+ for(Uint32 i = 0 ; iscanState = ScanRecord::DELIVERED;
- /*********************************************************************
- * UPDATE STATUS OF THE SCAN PROCESSES THAT WAS NOW SENT TO THE
- * APPLICATION TO DELIVERED. PREVIOUSLY THEY WERE QUEUED FOR DELIVERY.
- *********************************************************************/
- for (Uint32 i = 0; i < 16; i++) {
- jam();
- scanFragptr.i = scanptr.p->scanFragrec[i];
- if (scanFragptr.i != RNIL) {
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- if (scanFragptr.p->scanFragState == ScanFragRec::QUEUED_FOR_DELIVERY) {
- jam();
- scanFragptr.p->scanFragState = ScanFragRec::DELIVERED;
- }//if
- }//if
- }//for
- return;
- case ScanRecord::DELIVERED:
- jam();
- /*********************************************************************
- * WE HAVE NOT ANY QUEUED DELIVERIES. SET STATE TO INDICATE IT IS OK
- * TO SEND SCAN_TABCONF AS SOON AS ANY FRAGMENT IS READY TO DELIVER.
- *********************************************************************/
- scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED;
- return;
- case ScanRecord::SCAN_NEXT_ORDERED:
- jam();
- /* empty */
- return;
- default:
- jam();
- systemErrorLab(signal);
- return;
- }//switch
-}//Dbtc::execSCAN_NEXTREQ()
+ scanFragptr.i = signal->theData[i+25];
+ c_scan_frag_pool.getPtr(scanFragptr);
+ ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::DELIVERED);
+
+ scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
+ scanFragptr.p->startFragTimer(ctcTimer);
-void Dbtc::scanCompletedLab(Signal* signal) {
- scanptr.p->scanReceivedOperations = 0;
- scanptr.p->scanState = ScanRecord::CLOSING_SCAN;
-
- // Iterate over all fragment scans and check if
- // they need to be closed in LQH
- for (Uint32 i = 0; i < 16; i++) {
- if (scanptr.p->scanFragrec[i] == RNIL) {
- jam();
- continue;
- }
- scanFragptr.i = scanptr.p->scanFragrec[i];
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
-
- if (scanFragptr.p->lqhBlockref == RNIL){
- // The connection to this LQH has been closed
- jam();
- continue;
- }
-
- if (scanFragptr.p->scanFragCompletedStatus == ZCLOSED){
- // The fragment scan is already completed
- jam();
- continue;
- }
-
- if (scanFragptr.p->scanFragState == ScanFragRec::RETURNING_FROM_DELIVERY){
- // The scan process is soon to continue executing
- // Set scanFragCompletedStatus to ZTRUE so that LQH is properly closed
- // when this scan process "returns from delivery"
- jam();
- DEBUG("scanCompletedLab: setting scanFragCompletedStatus to ZTRUE");
- scanFragptr.p->scanFragCompletedStatus = ZTRUE;
- continue;
- }
-
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
-
- ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
+ scanFragptr.p->m_ops = 0;
nextReq->senderData = scanFragptr.i;
- nextReq->closeFlag = ZTRUE;
- nextReq->transId1 = apiConnectptr.p->transid[0];
- nextReq->transId2 = apiConnectptr.p->transid[1];
sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- updateBuddyTimer(apiConnectptr);
-
- updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
- scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE_CLOSE;
-
+ delivered.remove(scanFragptr);
+ running.add(scanFragptr);
}//for
-}//Dbtc::scanCompletedLab()
+
+}//Dbtc::execSCAN_NEXTREQ()
-void Dbtc::sendScanProcConf(Signal* signal){
- signal->theData[0] = scanptr.i;
- signal->theData[1] = scanFragptr.i;
- sendSignal(cownref, GSN_SCAN_PROCCONF, signal, 2, JBB);
+void
+Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr){
+#ifdef VM_TRACE
+ ndbout_c("%d close_scan_req", apiConnectptr.i);
+#endif
+ ScanRecord* scanP = scanPtr.p;
+ scanPtr.p->scanState = ScanRecord::CLOSING_SCAN;
+
+ /**
+ * Queue : Action
+ * ========== : =================
+ * completed : -
+ * running : -
+ * delivered : close -> LQH
+ * queued w/ : close -> LQH
+ * queued wo/ : move to completed
+ */
+
+ /**
+ * All delivered should to be closed
+ */
+ ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
+ nextReq->closeFlag = ZTRUE;
+ nextReq->transId1 = apiConnectptr.p->transid[0];
+ nextReq->transId2 = apiConnectptr.p->transid[1];
+
+ {
+ ScanFragRecPtr ptr;
+ ScanFragList running(c_scan_frag_pool, scanP->m_running_scan_frags);
+ ScanFragList completed(c_scan_frag_pool, scanP->m_completed_scan_frags);
+ ScanFragList delivered(c_scan_frag_pool, scanP->m_delivered_scan_frags);
+ for(delivered.first(ptr); !ptr.isNull(); ){
+ jam();
+ ScanFragRecPtr curr = ptr; // Remove while iterating...
+ delivered.next(ptr);
+
+ ndbrequire(curr.p->scanFragState == ScanFragRec::DELIVERED);
+ delivered.remove(curr);
+
+ if(curr.p->m_ops > 0){
+ jam();
+ running.add(curr);
+ curr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
+ curr.p->startFragTimer(ctcTimer);
+ nextReq->senderData = curr.i;
+ sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
+ ScanFragNextReq::SignalLength, JBB);
+
+ ndbout_c("delivered -> running");
+ } else {
+ jam();
+ completed.add(curr);
+ curr.p->scanFragState = ScanFragRec::COMPLETED;
+ curr.p->stopFragTimer();
+ ndbout_c("delivered -> completed");
+ }
+ }//for
+
+ /**
+ * All queued with data should be closed
+ */
+ ScanFragList queued(c_scan_frag_pool, scanP->m_queued_scan_frags);
+ for(queued.first(ptr); !ptr.isNull(); ){
+ jam();
+ ndbrequire(ptr.p->scanFragState == ScanFragRec::QUEUED_FOR_DELIVERY);
+ ScanFragRecPtr curr = ptr; // Remove while iterating...
+ queued.next(ptr);
+
+ queued.remove(curr);
+ scanP->m_queued_count--;
+
+ if(curr.p->m_ops > 0){
+ jam();
+ running.add(curr);
+ curr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
+ curr.p->startFragTimer(ctcTimer);
+ nextReq->senderData = curr.i;
+ sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
+ ScanFragNextReq::SignalLength, JBB);
+
+ ndbout_c("queued -> running");
+ } else {
+ jam();
+ completed.add(curr);
+ curr.p->scanFragState = ScanFragRec::COMPLETED;
+ curr.p->stopFragTimer();
+ ndbout_c("queued -> completed");
+ }
+ }
+ }
+ close_scan_req_send_conf(signal, scanptr);
}
-void Dbtc::releaseScanrec(Signal* signal) {
- scanptr.p->nextScan = cfirstfreeScanrec;
- scanptr.p->scanState = ScanRecord::IDLE;
- scanptr.p->scanTcrec = RNIL;
- cfirstfreeScanrec = scanptr.i;
-}//Dbtc::releaseScanrec()
+void
+Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
-void Dbtc::releaseScanFragrec(Signal* signal) {
- scanFragptr.p->nextScanFrag = cfirstfreeScanFragrec;
- scanFragptr.p->scanFragState = ScanFragRec::IDLE;
- cfirstfreeScanFragrec = scanFragptr.i;
- scanFragptr.p->stopFragTimer();
-}//Dbtc::releaseScanFragrec()
+ jam();
+ ndbrequire(scanPtr.p->m_queued_scan_frags.isEmpty());
+ ndbrequire(scanPtr.p->m_delivered_scan_frags.isEmpty());
+ if(!scanPtr.p->m_running_scan_frags.isEmpty()){
+ jam();
+ return;
+ }
+
+ const bool apiFail = (apiConnectptr.p->apiFailState == ZTRUE);
+
+ if(!apiFail){
+ jam();
+ Uint32 ref = apiConnectptr.p->ndbapiBlockref;
+ ScanTabConf * conf = (ScanTabConf*)&signal->theData[0];
+ conf->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
+ conf->requestInfo = ScanTabConf::EndOfData;
+ conf->transId1 = apiConnectptr.p->transid[0];
+ conf->transId2 = apiConnectptr.p->transid[1];
+ sendSignal(ref, GSN_SCAN_TABCONF, signal, ScanTabConf::SignalLength, JBB);
+ }
-void Dbtc::releaseScanOprec(Signal* signal) {
- scanOpptr.p->nextScanOp = cfirstfreeScanOprec;
- cfirstfreeScanOprec = scanOpptr.i;
-}//Dbtc::releaseScanOprec()
+ releaseScanResources(scanPtr);
+
+ if(apiFail){
+ jam();
+ /**
+ * API has failed
+ */
+ handleApiFailState(signal, apiConnectptr.i);
+ }
+}
void Dbtc::seizeScanrec(Signal* signal) {
scanptr.i = cfirstfreeScanrec;
@@ -9754,27 +9378,7 @@ void Dbtc::seizeScanrec(Signal* signal) {
ndbrequire(scanptr.p->scanState == ScanRecord::IDLE);
}//Dbtc::seizeScanrec()
-void Dbtc::seizeScanFragrec(Signal* signal) {
- scanFragptr.i = cfirstfreeScanFragrec;
- ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord);
- cfirstfreeScanFragrec = scanFragptr.p->nextScanFrag;
- scanFragptr.p->nextScanFrag = RNIL;
- ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::IDLE);
-}//Dbtc::seizeScanFragrec()
-
-void Dbtc::seizeScanOprec(Signal* signal) {
- scanOpptr.i = cfirstfreeScanOprec;
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- cfirstfreeScanOprec = scanOpptr.p->nextScanOp;
- scanOpptr.p->nextScanOp = RNIL;
-}//Dbtc::seizeScanOprec()
-
-
void Dbtc::sendScanFragReq(Signal* signal) {
- arrGuard(scanFragptr.p->scanFragProcId, 16);
- scanOpptr.i = scanptr.p->scanOprec[scanFragptr.p->scanFragProcId];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
-
Uint32 requestInfo = 0;
ScanFragReq::setConcurrency(requestInfo, scanFragptr.p->scanFragConcurrency);
ScanFragReq::setLockMode(requestInfo, scanptr.p->scanLockMode);
@@ -9800,96 +9404,72 @@ void Dbtc::sendScanFragReq(Signal* signal) {
req->transId1 = apiConnectptr.p->transid[0];
req->transId2 = apiConnectptr.p->transid[1];
for(int i = 0; i<16; i++){
- req->clientOpPtr[i] = scanOpptr.p->apiOpptr[i];
+ req->clientOpPtr[i] = scanFragptr.p->m_apiPtr;
}
sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_FRAGREQ, signal, 25, JBB);
updateBuddyTimer(apiConnectptr);
scanFragptr.p->startFragTimer(ctcTimer);
- scanFragptr.p->scanFragCompletedStatus = ZFALSE;
}//Dbtc::sendScanFragReq()
void Dbtc::sendScanTabConf(Signal* signal) {
jam();
- /*******************************************************
- * Send SCAN_TABINFO with information about all
- * received operations
- *******************************************************/
- Int32 operationsToSend = scanptr.p->scanReceivedOperations;
- Uint32 sstOpIndex = 0;
-
- while (operationsToSend > 0){
+ Uint32* ops = signal->getDataPtrSend()+4;
+ Uint32 op_count = scanptr.p->m_queued_count;
+ if(4 + 3 * op_count > 25){
jam();
-
- ScanTabInfo * info = (ScanTabInfo*)&signal->theData[0];
- info->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
-
- for (int i = 0; i < 16; i++){
- jam();
- arrGuard(sstOpIndex, 16);
- scanOpptr.i = scanptr.p->scanOprec[sstOpIndex];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- info->operLenAndIdx[i] = scanOpptr.p->scanOpLength[i];
- operationsToSend--;
- scanOpptr.p->scanOpLength[i] = RNIL;
- }
- sstOpIndex++;
- sendSignal(apiConnectptr.p->ndbapiBlockref,
- GSN_SCAN_TABINFO, signal, ScanTabInfo::SignalLength, JBB);
+ ops += 21;
}
-
- /********************************************************
- * Send SCAN_TABCONF signaling that a result set have
- * been sent to the API
- *********************************************************/
- Uint32 requestInfo = 0;
- ScanTabConf::setOperations(requestInfo, scanptr.p->scanReceivedOperations);
- ScanTabConf::setScanStatus(requestInfo, scanptr.p->scanCompletedStatus);
-
+
ScanTabConf * conf = (ScanTabConf*)&signal->theData[0];
conf->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
- conf->requestInfo = requestInfo;
+ conf->requestInfo = op_count;
conf->transId1 = apiConnectptr.p->transid[0];
conf->transId2 = apiConnectptr.p->transid[1];
- sendSignal(apiConnectptr.p->ndbapiBlockref,
- GSN_SCAN_TABCONF, signal, ScanTabConf::SignalLength, JBB);
+ ScanFragRecPtr ptr;
+ ScanRecord* scanP = scanptr.p;
+ ScanFragList queued(c_scan_frag_pool, scanP->m_queued_scan_frags);
+ ScanFragList completed(c_scan_frag_pool, scanP->m_completed_scan_frags);
+ ScanFragList delivered(c_scan_frag_pool, scanP->m_delivered_scan_frags);
+ for(queued.first(ptr); !ptr.isNull(); ){
+ ndbrequire(ptr.p->scanFragState == ScanFragRec::QUEUED_FOR_DELIVERY);
+ ScanFragRecPtr curr = ptr; // Remove while iterating...
+ queued.next(ptr);
- scanptr.p->scanReceivedOperations = 0;
- // Start the scanRec-timer again and wait for response from the API.
- setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__);
- updateBuddyTimer(apiConnectptr);
+ * ops++ = curr.p->m_apiPtr;
+ * ops++ = curr.i;
+ * ops++ = (curr.p->m_totalLen << 5) + curr.p->m_ops;
+
+ queued.remove(curr);
+ if(curr.p->m_ops > 0){
+ delivered.add(curr);
+ curr.p->scanFragState = ScanFragRec::DELIVERED;
+ curr.p->stopFragTimer();
+ } else {
+ (* --ops) = ScanTabConf::EndOfData; ops++;
+ completed.add(curr);
+ curr.p->scanFragState = ScanFragRec::COMPLETED;
+ curr.p->stopFragTimer();
+ }
+ }
+
+ if(4 + 3 * op_count > 25){
+ jam();
+ LinearSectionPtr ptr[3];
+ ptr[0].p = signal->getDataPtrSend()+25;
+ ptr[0].sz = 3 * op_count;
+ sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABCONF, signal,
+ ScanTabConf::SignalLength, JBB, ptr, 1);
+ } else {
+ jam();
+ sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABCONF, signal,
+ ScanTabConf::SignalLength + 3 * op_count, JBB);
+ }
+ scanptr.p->m_queued_count = 0;
}//Dbtc::sendScanTabConf()
-/*
- * Write index and length of all operations received into
- * scanOprec->scanOpLength buffer
- */
-void Dbtc::setScanReceived(Signal* signal, Uint32 noCompletedOps)
-{
- UintR tssrIndividual;
- UintR tssrOprecIndex;
- UintR tssrLengthPlusIndex;
- UintR tssrOpIndex;
-
- ndbrequire(noCompletedOps <= 16);
- tssrIndividual = scanFragptr.p->scanIndividual;
- for (Uint32 i = 0; i < noCompletedOps; i++) {
- jam();
- tssrOprecIndex = scanptr.p->scanReceivedOperations >> 4;
- arrGuard(tssrOprecIndex, 16);
- scanOpptr.i = scanptr.p->scanOprec[tssrOprecIndex];
- ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord);
- tssrLengthPlusIndex = tssrIndividual << 24;
- tssrLengthPlusIndex += cdata[i];
- tssrOpIndex = scanptr.p->scanReceivedOperations & 15;
- scanOpptr.p->scanOpLength[tssrOpIndex] = tssrLengthPlusIndex;
- scanptr.p->scanReceivedOperations++;
- tssrIndividual++;
- }//for
-}//Dbtc::setScanReceived()
-
void Dbtc::gcpTcfinished(Signal* signal)
{
signal->theData[1] = tcheckGcpId;
@@ -10139,6 +9719,7 @@ void Dbtc::initialiseScanrec(Signal* signal)
for (scanptr.i = 0; scanptr.i < cscanrecFileSize; scanptr.i++) {
jam();
ptrAss(scanptr, scanRecord);
+ new (scanptr.p) ScanRecord();
scanptr.p->scanState = ScanRecord::IDLE;
scanptr.p->nextScan = scanptr.i + 1;
}//for
@@ -10150,34 +9731,10 @@ void Dbtc::initialiseScanrec(Signal* signal)
void Dbtc::initialiseScanFragrec(Signal* signal)
{
- ndbrequire(cscanFragrecFileSize > 0);
- for (scanFragptr.i = 0; scanFragptr.i < cscanFragrecFileSize;
- scanFragptr.i++) {
- jam();
- ptrAss(scanFragptr, scanFragmentRecord);
- scanFragptr.p->scanFragState = ScanFragRec::IDLE;
- scanFragptr.p->stopFragTimer();
- scanFragptr.p->nextScanFrag = scanFragptr.i + 1;
- }//for
- scanFragptr.i = cscanFragrecFileSize - 1;
- ptrAss(scanFragptr, scanFragmentRecord);
- scanFragptr.p->nextScanFrag = RNIL;
- cfirstfreeScanFragrec = 0;
}//Dbtc::initialiseScanFragrec()
void Dbtc::initialiseScanOprec(Signal* signal)
{
- ndbrequire(cscanOprecFileSize > 0);
- for (scanOpptr.i = 0; scanOpptr.i < cscanOprecFileSize; scanOpptr.i++) {
- jam();
- ptrAss(scanOpptr, scanOperationRecord);
- scanOpptr.p->nextScanOp = scanOpptr.i + 1;
- }//for
- scanOpptr.i = cscanOprecFileSize - 1;
- ptrAss(scanOpptr, scanOperationRecord);
- scanOpptr.p->nextScanOp = RNIL;
- cfirstfreeScanOprec = 0;
- cnoFreeScanOprec = cscanOprecFileSize;
}//Dbtc::initialiseScanOprec()
void Dbtc::initTable(Signal* signal)
@@ -10302,8 +9859,8 @@ void Dbtc::releaseAbortResources(Signal* signal)
if (apiConnectptr.p->cachePtr != RNIL) {
cachePtr.i = apiConnectptr.p->cachePtr;
ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord);
- releaseAttrinfo(signal);
- releaseKeys(signal);
+ releaseAttrinfo();
+ releaseKeys();
}//if
tcConnectptr.i = apiConnectptr.p->firstTcConnect;
while (tcConnectptr.i != RNIL) {
@@ -10312,7 +9869,7 @@ void Dbtc::releaseAbortResources(Signal* signal)
// Clear any markers that were set in CS_RECEIVING state
clearCommitAckMarker(apiConnectptr.p, tcConnectptr.p);
rarTcConnectptr.i = tcConnectptr.p->nextTcConnect;
- releaseTcCon(signal);
+ releaseTcCon();
tcConnectptr.i = rarTcConnectptr.i;
}//while
apiConnectptr.p->firstTcConnect = RNIL;
@@ -10403,7 +9960,7 @@ void Dbtc::releaseGcp(Signal* signal)
cfirstfreeGcp = gcpPtr.i;
}//Dbtc::releaseGcp()
-void Dbtc::releaseKeys(Signal* signal)
+void Dbtc::releaseKeys()
{
UintR Tmp;
databufptr.i = cachePtr.p->firstKeybuf;
@@ -10682,20 +10239,15 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
ScanFragRecPtr sfp;
sfp.i = recordNo;
- ptrAss(sfp, scanFragmentRecord);
- infoEvent("Dbtc::ScanFragRec[%d]: state=%d, status=%d, "
- "fragid=%d, procid=%d, ",
+ c_scan_frag_pool.getPtr(sfp);
+ infoEvent("Dbtc::ScanFragRec[%d]: state=%d fragid=%d",
sfp.i,
sfp.p->scanFragState,
- sfp.p->scanFragCompletedStatus,
- sfp.p->scanFragId,
- sfp.p->scanFragProcId);
- infoEvent(" nodeid=%d, ind=%d, concurr=%d, timer=%d, next=%d",
- sfp.p->scanFragNodeId,
- sfp.p->scanIndividual,
+ sfp.p->scanFragId);
+ infoEvent(" nodeid=%d, concurr=%d, timer=%d",
+ refToNode(sfp.p->lqhBlockref),
sfp.p->scanFragConcurrency,
- sfp.p->scanFragTimer,
- sfp.p->nextScanFrag);
+ sfp.p->scanFragTimer);
}
// Dump all ScanRecords
@@ -10762,11 +10314,10 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
ScanRecordPtr sp;
sp.i = recordNo;
ptrAss(sp, scanRecord);
- infoEvent("Dbtc::ScanRecord[%d]: state=%d, scanOprec=%d, "
+ infoEvent("Dbtc::ScanRecord[%d]: state=%d"
"nextfrag=%d, nofrag=%d",
sp.i,
sp.p->scanState,
- sp.p->noScanOprec,
sp.p->scanNextFragId,
sp.p->scanNoFrag);
infoEvent(" ailen=%d, para=%d, receivedop=%d, noOprePperFrag=%d",
@@ -10774,17 +10325,11 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
sp.p->scanParallel,
sp.p->scanReceivedOperations,
sp.p->noOprecPerFrag);
- infoEvent(" schv=%d, tab=%d, sproc=%d, noTI=%d, norecTI=%d",
+ infoEvent(" schv=%d, tab=%d, sproc=%d",
sp.p->scanSchemaVersion,
sp.p->scanTableref,
- sp.p->scanStoredProcId,
- sp.p->noScanTabInfo,
- sp.p->scanTabInfoReceived);
- infoEvent(" apiclosed=%d, noProcCompl=%d, "
- "complStat=%d, lhold=%d, lmode=%d",
- sp.p->apiIsClosed,
- sp.p->scanProcessesCompleted,
- sp.p->scanCompletedStatus,
+ sp.p->scanStoredProcId);
+ infoEvent(" lhold=%d, lmode=%d",
sp.p->scanLockHold,
sp.p->scanLockMode);
infoEvent(" apiRec=%d, next=%d",
@@ -10792,13 +10337,20 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
if (sp.p->scanState != ScanRecord::IDLE){
// Request dump of ScanFragRec
- for (Uint32 i = 0; i < 16; i++){
- if (sp.p->scanFragrec[i] != RNIL){
- dumpState->args[0] = DumpStateOrd::TcDumpOneScanFragRec;
- dumpState->args[1] = sp.p->scanFragrec[i];
- execDUMP_STATE_ORD(signal);
- }
- }
+ ScanFragRecPtr sfptr;
+#define DUMP_SFR(x){\
+ ScanFragList list(c_scan_frag_pool, x);\
+ for(list.first(sfptr); !sfptr.isNull(); list.next(sfptr)){\
+ dumpState->args[0] = DumpStateOrd::TcDumpOneScanFragRec; \
+ dumpState->args[1] = sfptr.i;\
+ execDUMP_STATE_ORD(signal);\
+ }}
+
+ DUMP_SFR(sp.p->m_running_scan_frags);
+ DUMP_SFR(sp.p->m_queued_scan_frags);
+ DUMP_SFR(sp.p->m_delivered_scan_frags);
+ DUMP_SFR(sp.p->m_completed_scan_frags);
+
// Request dump of ApiConnectRecord
dumpState->args[0] = DumpStateOrd::TcDumpOneApiConnectRec;
dumpState->args[1] = sp.p->scanApiRec;
diff --git a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
index c09c8984ce2..70b8a739fef 100644
--- a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
+++ b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
@@ -950,9 +950,6 @@ typedef Ptr TableDescriptorPtr;
struct HostBuffer {
bool inPackedList;
- Uint32 packetLenRC;
- Uint32 noOfPacketsRC;
- Uint32 packetBufferRC[29];
Uint32 packetLenTA;
Uint32 noOfPacketsTA;
Uint32 packetBufferTA[30];
@@ -1637,11 +1634,7 @@ private:
//------------------------------------------------------------------
//------------------------------------------------------------------
- void bufferREADCONF(Signal* signal, BlockReference aRef, Uint32* buffer, Uint32 Tlen);
-
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- void bufferTRANSID_AI(Signal* signal, BlockReference aRef, Uint32* buffer, Uint32 Tlen);
+ void bufferTRANSID_AI(Signal* signal, BlockReference aRef, Uint32 Tlen);
//------------------------------------------------------------------
// Trigger handling routines
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
index 90c6dbc6802..cd5057d8a62 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
@@ -35,7 +35,6 @@ void Dbtup::execSEND_PACKED(Signal* signal)
hostId = cpackedList[i];
ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero
Uint32 TpacketTA = hostBuffer[hostId].noOfPacketsTA;
- Uint32 TpacketRC = hostBuffer[hostId].noOfPacketsRC;
if (TpacketTA != 0) {
ljam();
BlockReference TBref = numberToRef(API_PACKED, hostId);
@@ -47,91 +46,17 @@ void Dbtup::execSEND_PACKED(Signal* signal)
hostBuffer[hostId].noOfPacketsTA = 0;
hostBuffer[hostId].packetLenTA = 0;
}//if
- if (TpacketRC != 0) {
- ljam();
- BlockReference TBref = numberToRef(API_PACKED, hostId);
- Uint32 TpacketLen = hostBuffer[hostId].packetLenRC;
- MEMCOPY_NO_WORDS(&signal->theData[0],
- &hostBuffer[hostId].packetBufferRC[0],
- TpacketLen);
- sendSignal(TBref, GSN_READCONF, signal, TpacketLen, JBB);
- hostBuffer[hostId].noOfPacketsRC = 0;
- hostBuffer[hostId].packetLenRC = 0;
- }//if
hostBuffer[hostId].inPackedList = false;
}//for
cpackedListIndex = 0;
}//Dbtup::execSEND_PACKED()
-void Dbtup::bufferREADCONF(Signal* signal, BlockReference aRef,
- Uint32* buffer, Uint32 Tlen)
-{
- Uint32 hostId = refToNode(aRef);
- Uint32 Theader = ((refToBlock(aRef) << 16) + (Tlen-3));
-
- ndbrequire(hostId < MAX_NODES);
- Uint32 TpacketLen = hostBuffer[hostId].packetLenRC;
- Uint32 TnoOfPackets = hostBuffer[hostId].noOfPacketsRC;
- Uint32 sig0 = signal->theData[0];
- Uint32 sig1 = signal->theData[1];
- Uint32 sig2 = signal->theData[2];
- Uint32 sig3 = signal->theData[3];
-
- BlockReference TBref = numberToRef(API_PACKED, hostId);
-
- if ((Tlen + TpacketLen + 1) <= 25) {
-// ----------------------------------------------------------------
-// There is still space in the buffer. We will copy it into the
-// buffer.
-// ----------------------------------------------------------------
- ljam();
- updatePackedList(signal, hostId);
- } else if (TnoOfPackets == 1) {
-// ----------------------------------------------------------------
-// The buffer is full and there was only one packet buffered. We
-// will send this as a normal signal.
-// ----------------------------------------------------------------
- Uint32 TnewRef = numberToRef((hostBuffer[hostId].packetBufferRC[0] >> 16),
- hostId);
- MEMCOPY_NO_WORDS(&signal->theData[0],
- &hostBuffer[hostId].packetBufferRC[1],
- TpacketLen - 1);
- sendSignal(TnewRef, GSN_READCONF, signal, (TpacketLen - 1), JBB);
- TpacketLen = 0;
- TnoOfPackets = 0;
- } else {
-// ----------------------------------------------------------------
-// The buffer is full but at least two packets. Send those in
-// packed form.
-// ----------------------------------------------------------------
- MEMCOPY_NO_WORDS(&signal->theData[0],
- &hostBuffer[hostId].packetBufferRC[0],
- TpacketLen);
- sendSignal(TBref, GSN_READCONF, signal, TpacketLen, JBB);
- TpacketLen = 0;
- TnoOfPackets = 0;
- }//if
-// ----------------------------------------------------------------
-// Copy the signal into the buffer
-// ----------------------------------------------------------------
- hostBuffer[hostId].packetBufferRC[TpacketLen + 0] = Theader;
- hostBuffer[hostId].packetBufferRC[TpacketLen + 1] = sig0;
- hostBuffer[hostId].packetBufferRC[TpacketLen + 2] = sig1;
- hostBuffer[hostId].packetBufferRC[TpacketLen + 3] = sig2;
- hostBuffer[hostId].packetBufferRC[TpacketLen + 4] = sig3;
- hostBuffer[hostId].noOfPacketsRC = TnoOfPackets + 1;
- hostBuffer[hostId].packetLenRC = Tlen + TpacketLen + 1;
- MEMCOPY_NO_WORDS(&hostBuffer[hostId].packetBufferRC[TpacketLen + 5],
- buffer,
- Tlen - 4);
-}//Dbtup::bufferREADCONF()
-
void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
- Uint32* buffer, Uint32 Tlen)
+ Uint32 Tlen)
{
Uint32 hostId = refToNode(aRef);
Uint32 Theader = ((refToBlock(aRef) << 16)+(Tlen-3));
-
+
ndbrequire(hostId < MAX_NODES);
Uint32 TpacketLen = hostBuffer[hostId].packetLenTA;
Uint32 TnoOfPackets = hostBuffer[hostId].noOfPacketsTA;
@@ -148,7 +73,7 @@ void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
// ----------------------------------------------------------------
ljam();
updatePackedList(signal, hostId);
- } else if (TnoOfPackets == 1) {
+ } else if (false && TnoOfPackets == 1) {
// ----------------------------------------------------------------
// The buffer is full and there was only one packet buffered. We
// will send this as a normal signal.
@@ -183,7 +108,7 @@ void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
hostBuffer[hostId].noOfPacketsTA = TnoOfPackets + 1;
hostBuffer[hostId].packetLenTA = Tlen + TpacketLen + 1;
MEMCOPY_NO_WORDS(&hostBuffer[hostId].packetBufferTA[TpacketLen + 4],
- buffer,
+ &signal->theData[25],
Tlen - 3);
}//Dbtup::bufferTRANSID_AI()
@@ -206,124 +131,122 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
const Operationrec * const regOperPtr)
{
const BlockReference recBlockref = regOperPtr->recBlockref;
- bool toOwnNode = refToNode(recBlockref) == getOwnNodeId();
- bool connectedToNode = getNodeInfo(refToNode(recBlockref)).m_connected;
- const Uint32 type = getNodeInfo(refToNode(recBlockref)).m_type;
+ const Uint32 block = refToBlock(recBlockref);
+ const Uint32 nodeId = refToNode(recBlockref);
+
+ bool connectedToNode = getNodeInfo(nodeId).m_connected;
+ const Uint32 type = getNodeInfo(nodeId).m_type;
bool is_api = (type >= NodeInfo::API && type <= NodeInfo::REP);
+ bool old_dest = (getNodeInfo(nodeId).m_version < MAKE_VERSION(3,5,0));
- if (ERROR_INSERTED(4006)){
+ if (ERROR_INSERTED(4006) && (nodeId != getOwnNodeId())){
// Use error insert to turn routing on
ljam();
connectedToNode = false;
}
- if (!toOwnNode && !connectedToNode){
- /**
- * If this node does not have a direct connection
- * to the receiving node we want to send the signals
- * routed via the node that controls this read
- */
- Uint32 routeBlockref = regOperPtr->coordinatorTC;
-
- /**
- * Fill in a TRANSID_AI signal, use last word to store
- * final destination and send it to route node
- * as signal TRANSID_AI_R (R as in Routed)
- */
- TransIdAI * const transIdAI = (TransIdAI *)signal->getDataPtr();
- transIdAI->connectPtr = regOperPtr->tcOperationPtr;
- transIdAI->transId[0] = regOperPtr->transid1;
- transIdAI->transId[1] = regOperPtr->transid2;
-
- Uint32 tot = ToutBufIndex;
- Uint32 sent = 0;
- Uint32 maxLen = TransIdAI::DataLength - 1;
- while (sent < tot) {
- ljam();
- Uint32 dataLen = (tot - sent > maxLen) ? maxLen : tot - sent;
- Uint32 sigLen = dataLen + TransIdAI::HeaderLength + 1;
- MEMCOPY_NO_WORDS(&transIdAI->attrData,
- &coutBuffer[sent],
- dataLen);
- // Set final destination in last word
- transIdAI->attrData[dataLen] = recBlockref;
-
- sendSignal(routeBlockref, GSN_TRANSID_AI_R,
- signal, sigLen, JBB);
- sent += dataLen;
-
- }
- return;
- }
-
- Uint32 TbufIndex = 0;
Uint32 sig0 = regOperPtr->tcOperationPtr;
Uint32 sig1 = regOperPtr->transid1;
Uint32 sig2 = regOperPtr->transid2;
- signal->theData[0] = sig0;
- signal->theData[1] = sig1;
- signal->theData[2] = sig2;
+
+ TransIdAI * transIdAI = (TransIdAI *)signal->getDataPtrSend();
+ transIdAI->connectPtr = sig0;
+ transIdAI->transId[0] = sig1;
+ transIdAI->transId[1] = sig2;
+
+ if (connectedToNode){
+ /**
+ * Own node -> execute direct
+ */
+ if(nodeId != getOwnNodeId()){
+ ljam();
+
+ /**
+ * Send long sig
+ */
+ if(ToutBufIndex >= 22 && is_api && !old_dest) {
+ ljam();
+ LinearSectionPtr ptr[3];
+ ptr[0].p = &signal->theData[25];
+ ptr[0].sz = ToutBufIndex;
+ sendSignal(recBlockref, GSN_TRANSID_AI, signal, 3, JBB, ptr, 1);
+ return;
+ }
+
+ /**
+ * short sig + api -> buffer
+ */
+#ifndef NDB_NO_DROPPED_SIGNAL
+ if (ToutBufIndex < 22 && is_api){
+ ljam();
+ bufferTRANSID_AI(signal, recBlockref, 3+ToutBufIndex);
+ return;
+ }//if
+#endif
- while (ToutBufIndex > 21) {
- ljam();
- MEMCOPY_NO_WORDS(&signal->theData[3],
- &coutBuffer[TbufIndex],
- 22);
- TbufIndex += 22;
- ToutBufIndex -= 22;
- const BlockReference sendBref = regOperPtr->recBlockref;
- if (refToNode(sendBref) != getOwnNodeId()) {
- ljam();
- sendSignal(sendBref, GSN_TRANSID_AI, signal, 25, JBB);
- ljam();
- } else {
- ljam();
- EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal, 25);
- ljamEntry();
- }//if
- }//while
-
- Uint32 TsigNumber;
- Uint32 TsigLen;
- Uint32 TdataIndex;
- if ((regOperPtr->opSimple == ZTRUE) &&
- (regOperPtr->optype == ZREAD)) {
- /* DIRTY OPERATIONS ARE ALSO SIMPLE */
- ljam();
- Uint32 sig3 = regOperPtr->attroutbufLen;
- TdataIndex = 4;
- TsigLen = 4 + ToutBufIndex;
- TsigNumber = GSN_READCONF;
- signal->theData[3] = sig3;
- if ((TsigLen < 18) && is_api){
- bufferREADCONF(signal, regOperPtr->recBlockref,
- &coutBuffer[TbufIndex], TsigLen);
+ /**
+ * rest -> old send sig
+ */
+ Uint32 * src = signal->theData+25;
+ if(ToutBufIndex >= 22){
+ do {
+ ljam();
+ MEMCOPY_NO_WORDS(&signal->theData[3], src, 22);
+ sendSignal(recBlockref, GSN_TRANSID_AI, signal, 25, JBB);
+ ToutBufIndex -= 22;
+ src += 22;
+ } while(ToutBufIndex >= 22);
+ }
+
+ if(ToutBufIndex > 0){
+ ljam();
+ MEMCOPY_NO_WORDS(&signal->theData[3], src, ToutBufIndex);
+ sendSignal(recBlockref, GSN_TRANSID_AI, signal, 3+ToutBufIndex, JBB);
+ }
return;
- }//if
- } else if (ToutBufIndex > 0) {
- ljam();
- TdataIndex = 3;
- TsigLen = 3 + ToutBufIndex;
- TsigNumber = GSN_TRANSID_AI;
- if ((TsigLen < 18) && is_api){
- ljam();
- bufferTRANSID_AI(signal, regOperPtr->recBlockref,
- &coutBuffer[TbufIndex], TsigLen);
- return;
- }//if
- } else {
- ljam();
- return;
- }//if
- MEMCOPY_NO_WORDS(&signal->theData[TdataIndex],
- &coutBuffer[TbufIndex],
- ToutBufIndex);
- const BlockReference sendBref = regOperPtr->recBlockref;
- if (refToNode(sendBref) != getOwnNodeId()) {
- ljam();
- sendSignal(sendBref, TsigNumber, signal, TsigLen, JBB);
- } else {
- EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal, TsigLen);
+ }
+ EXECUTE_DIRECT(block, GSN_TRANSID_AI, signal, 3 + ToutBufIndex);
ljamEntry();
- }//if
+ return;
+ }
+
+ /**
+ * If this node does not have a direct connection
+ * to the receiving node we want to send the signals
+ * routed via the node that controls this read
+ */
+ Uint32 routeBlockref = regOperPtr->coordinatorTC;
+
+ if(is_api && !old_dest){
+ ljam();
+ transIdAI->attrData[0] = recBlockref;
+ LinearSectionPtr ptr[3];
+ ptr[0].p = &signal->theData[25];
+ ptr[0].sz = ToutBufIndex;
+ sendSignal(routeBlockref, GSN_TRANSID_AI_R, signal, 4, JBB, ptr, 1);
+ return;
+ }
+
+ /**
+ * Fill in a TRANSID_AI signal, use last word to store
+ * final destination and send it to route node
+ * as signal TRANSID_AI_R (R as in Routed)
+ */
+ Uint32 tot = ToutBufIndex;
+ Uint32 sent = 0;
+ Uint32 maxLen = TransIdAI::DataLength - 1;
+ while (sent < tot) {
+ ljam();
+ Uint32 dataLen = (tot - sent > maxLen) ? maxLen : tot - sent;
+ Uint32 sigLen = dataLen + TransIdAI::HeaderLength + 1;
+ MEMCOPY_NO_WORDS(&transIdAI->attrData,
+ &signal->theData[25+sent],
+ dataLen);
+ // Set final destination in last word
+ transIdAI->attrData[dataLen] = recBlockref;
+
+ sendSignal(routeBlockref, GSN_TRANSID_AI_R,
+ signal, sigLen, JBB);
+ sent += dataLen;
+ }
}//Dbtup::sendReadAttrinfo()
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
index 07bad00acf1..eb9ff08c2b1 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
@@ -873,6 +873,7 @@ int Dbtup::handleReadReq(Signal* signal,
Page* pagePtr)
{
Uint32 Ttupheadoffset = regOperPtr->pageOffset;
+ const BlockReference sendBref = regOperPtr->recBlockref;
if (regTabPtr->checksumIndicator &&
(calculateChecksum(pagePtr, Ttupheadoffset,
regTabPtr->tupheadsize) != 0)) {
@@ -882,14 +883,29 @@ int Dbtup::handleReadReq(Signal* signal,
return -1;
}//if
+ Uint32 * dst = &signal->theData[25];
+ Uint32 dstLen = (sizeof(signal->theData) / 4) - 25;
+ const Uint32 node = refToNode(sendBref);
+ if(node != 0 && node != getOwnNodeId()) {
+ ;
+ } else {
+ jam();
+ /**
+ * execute direct
+ */
+ dst = &signal->theData[3];
+ dstLen = (sizeof(signal->theData) / 4) - 3;
+ }
+
if (regOperPtr->interpretedExec != 1) {
jam();
+
Uint32 TnoOfDataRead = readAttributes(pagePtr,
Ttupheadoffset,
&cinBuffer[0],
regOperPtr->attrinbufLen,
- &coutBuffer[0],
- (Uint32)ZATTR_BUFFER_SIZE);
+ dst,
+ dstLen);
if (TnoOfDataRead != (Uint32)-1) {
/* ------------------------------------------------------------------------- */
// We have read all data into coutBuffer. Now send it to the API.
@@ -1214,11 +1230,8 @@ int Dbtup::interpreterStartLab(Signal* signal,
Uint32 RattrinbufLen = regOperPtr->attrinbufLen;
const BlockReference sendBref = regOperPtr->recBlockref;
- Uint32 * dst = &coutBuffer[0];
- Uint32 dstLen = sizeof(coutBuffer) / 4;
- Uint32 * tmp = &signal->theData[3];
- Uint32 tmpLen = (sizeof(signal->theData) / 4) - 3;
- bool executeDirect = false;
+ Uint32 * dst = &signal->theData[25];
+ Uint32 dstLen = (sizeof(signal->theData) / 4) - 25;
const Uint32 node = refToNode(sendBref);
if(node != 0 && node != getOwnNodeId()) {
;
@@ -1227,12 +1240,8 @@ int Dbtup::interpreterStartLab(Signal* signal,
/**
* execute direct
*/
- executeDirect = true;
dst = &signal->theData[3];
dstLen = (sizeof(signal->theData) / 4) - 3;
-
- tmp = &coutBuffer[0];
- tmpLen = sizeof(coutBuffer) / 4;
}
RtotalLen = RinitReadLen;
@@ -1292,8 +1301,8 @@ int Dbtup::interpreterStartLab(Signal* signal,
RexecRegionLen,
&cinBuffer[RsubPC],
RsubLen,
- tmp,
- tmpLen);
+ &coutBuffer[0],
+ sizeof(coutBuffer) / 4);
if (TnoDataRW != (Uint32)-1) {
RinstructionCounter += RexecRegionLen;
RlogSize = TnoDataRW;
@@ -1350,20 +1359,7 @@ int Dbtup::interpreterStartLab(Signal* signal,
}//if
regOperPtr->logSize = RlogSize;
regOperPtr->attroutbufLen = RattroutCounter;
- if(!executeDirect) {
- jam();
- sendReadAttrinfo(signal, RattroutCounter, regOperPtr);
- } else {
- jam();
- Uint32 sig0 = regOperPtr->tcOperationPtr;
- Uint32 sig1 = regOperPtr->transid1;
- Uint32 sig2 = regOperPtr->transid2;
- signal->theData[0] = sig0;
- signal->theData[1] = sig1;
- signal->theData[2] = sig2;
- EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal,
- 3 + RattroutCounter);
- }//if
+ sendReadAttrinfo(signal, RattroutCounter, regOperPtr);
if (RlogSize > 0) {
sendLogAttrinfo(signal, RlogSize, regOperPtr);
}//if
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
index 095ea412701..3b54817edb0 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
@@ -966,9 +966,7 @@ void Dbtup::initializeHostBuffer()
for (hostId = 0; hostId < MAX_NODES; hostId++) {
hostBuffer[hostId].inPackedList = false;
hostBuffer[hostId].noOfPacketsTA = 0;
- hostBuffer[hostId].noOfPacketsRC = 0;
hostBuffer[hostId].packetLenTA = 0;
- hostBuffer[hostId].packetLenRC = 0;
}//for
}//Dbtup::initializeHostBuffer()
diff --git a/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
index b5a5d0948bb..5965673f25f 100644
--- a/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
+++ b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
@@ -1667,7 +1667,7 @@ void Ndbcntr::crSystab7Lab(Signal* signal)
tcKeyReq->requestInfo = reqInfo;
tcKeyReq->tableSchemaVersion = ZSYSTAB_VERSION;
tcKeyReq->transId1 = 0;
- tcKeyReq->transId2 = 0;
+ tcKeyReq->transId2 = ckey;
//-------------------------------------------------------------
// There is no optional part in this TCKEYREQ. There is one
diff --git a/ndb/src/ndbapi/Makefile b/ndb/src/ndbapi/Makefile
index f2dd21fdaa3..648c8cbb016 100644
--- a/ndb/src/ndbapi/Makefile
+++ b/ndb/src/ndbapi/Makefile
@@ -34,31 +34,25 @@ SOURCES = \
Ndblist.cpp \
Ndbif.cpp \
Ndbinit.cpp \
- Ndberr.cpp \
- ndberror.c \
- NdbErrorOut.cpp \
- NdbConnection.cpp \
+ ndberror.c Ndberr.cpp NdbErrorOut.cpp \
+ NdbConnection.cpp \
NdbConnectionScan.cpp \
NdbOperation.cpp \
NdbOperationSearch.cpp \
- NdbOperationScan.cpp \
NdbOperationInt.cpp \
NdbOperationDefine.cpp \
NdbOperationExec.cpp \
- NdbScanReceiver.cpp \
NdbResultSet.cpp \
- NdbCursorOperation.cpp \
NdbScanOperation.cpp NdbScanFilter.cpp \
NdbIndexOperation.cpp \
NdbEventOperation.cpp \
NdbEventOperationImpl.cpp \
NdbApiSignal.cpp \
NdbRecAttr.cpp \
- NdbSchemaCon.cpp \
- NdbSchemaOp.cpp \
NdbUtil.cpp \
NdbReceiver.cpp \
- NdbDictionary.cpp NdbDictionaryImpl.cpp DictCache.cpp
+ NdbDictionary.cpp NdbDictionaryImpl.cpp DictCache.cpp \
+ NdbSchemaCon.cpp NdbSchemaOp.cpp
include $(NDB_TOP)/Epilogue.mk
diff --git a/ndb/src/ndbapi/Ndb.cpp b/ndb/src/ndbapi/Ndb.cpp
index 2a8abf1870c..63cc871b707 100644
--- a/ndb/src/ndbapi/Ndb.cpp
+++ b/ndb/src/ndbapi/Ndb.cpp
@@ -158,26 +158,22 @@ Ndb::NDB_connect(Uint32 tNode)
tNdbCon->Status(Connecting); // Set status to connecting
Uint32 nodeSequence;
{ // send and receive signal
- tp->lock_mutex();
+ Guard guard(tp->theMutexPtr);
nodeSequence = tp->getNodeSequence(tNode);
bool node_is_alive = tp->get_node_alive(tNode);
if (node_is_alive) {
tReturnCode = tp->sendSignal(tSignal, tNode);
releaseSignal(tSignal);
- if (tReturnCode == -1) {
- tp->unlock_mutex();
- } else {
+ if (tReturnCode != -1) {
theWaiter.m_node = tNode;
theWaiter.m_state = WAIT_TC_SEIZE;
tReturnCode = receiveResponse();
}//if
} else {
releaseSignal(tSignal);
- tp->unlock_mutex();
tReturnCode = -1;
}//if
}
-
if ((tReturnCode == 0) && (tNdbCon->Status() == Connected)) {
//************************************************
// Send and receive was successful
@@ -467,9 +463,9 @@ Ndb::closeTransaction(NdbConnection* aConnection)
CHECK_STATUS_MACRO_VOID;
tCon = theTransactionList;
-
+
if (aConnection == tCon) { // Remove the active connection object
- theTransactionList = tCon->next(); // from the transaction list.
+ theTransactionList = tCon->next(); // from the transaction list.
} else {
while (aConnection != tCon) {
if (tCon == NULL) {
@@ -477,44 +473,33 @@ Ndb::closeTransaction(NdbConnection* aConnection)
// closeTransaction called on non-existing transaction
//-----------------------------------------------------
- if(aConnection->theError.code == 4008){
- /**
- * When a SCAN timed-out, returning the NdbConnection leads
- * to reuse. And TC crashes when the API tries to reuse it to
- * something else...
- */
+ if(aConnection->theError.code == 4008){
+ /**
+ * When a SCAN timed-out, returning the NdbConnection leads
+ * to reuse. And TC crashes when the API tries to reuse it to
+ * something else...
+ */
#ifdef VM_TRACE
- printf("Scan timeout:ed NdbConnection-> not returning it-> memory leak\n");
+ printf("Scan timeout:ed NdbConnection-> "
+ "not returning it-> memory leak\n");
#endif
- return;
- }
+ return;
+ }
#ifdef VM_TRACE
- printf("Non-existing transaction into closeTransaction\n");
+ printf("Non-existing transaction into closeTransaction\n");
abort();
#endif
- return;
+ return;
}//if
tPreviousCon = tCon;
tCon = tCon->next();
}//while
tPreviousCon->next(tCon->next());
}//if
-
+
aConnection->release();
-
- if(aConnection->theError.code == 4008){
- /**
- * When a SCAN timed-out, returning the NdbConnection leads
- * to reuse. And TC crashes when the API tries to reuse it to
- * something else...
- */
-#ifdef VM_TRACE
- printf("Scan timeout:ed NdbConnection-> not returning it-> memory leak\n");
-#endif
- return;
- }
-
+
if(aConnection->theError.code == 4008){
/**
* Something timed-out, returning the NdbConnection leads
@@ -526,7 +511,7 @@ Ndb::closeTransaction(NdbConnection* aConnection)
#endif
return;
}
-
+
if (aConnection->theReleaseOnClose == false) {
/**
* Put it back in idle list for that node
diff --git a/ndb/src/ndbapi/NdbApiSignal.cpp b/ndb/src/ndbapi/NdbApiSignal.cpp
index a9cd5b1d53a..91e4aa5976d 100644
--- a/ndb/src/ndbapi/NdbApiSignal.cpp
+++ b/ndb/src/ndbapi/NdbApiSignal.cpp
@@ -47,6 +47,7 @@ Adjust: 971114 UABMNST First version.
#include
#include
#include
+#include
#include
@@ -189,7 +190,7 @@ NdbApiSignal::setSignal(int aNdbSignalType)
theTrace = TestOrd::TraceAPI;
theReceiversBlockNumber = DBTC;
theVerId_signalNumber = GSN_SCAN_TABREQ;
- theLength = 25;
+ theLength = 9; // ScanTabReq::SignalLength;
}
break;
diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index 4ec098c3c60..84254b94612 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -27,11 +27,12 @@ Description: Interface between TIS and NDB
Documentation:
Adjust: 971022 UABMNST First version.
*****************************************************************************/
-#include "NdbOut.hpp"
-#include "NdbConnection.hpp"
-#include "NdbOperation.hpp"
-#include "NdbScanOperation.hpp"
-#include "NdbIndexOperation.hpp"
+#include
+#include
+#include
+#include
+#include
+#include
#include "NdbApiSignal.hpp"
#include "TransporterFacade.hpp"
#include "API.hpp"
@@ -79,15 +80,12 @@ NdbConnection::NdbConnection( Ndb* aNdb ) :
theTransactionIsStarted(false),
theDBnode(0),
theReleaseOnClose(false),
- // Cursor operations
- m_waitForReply(true),
- m_theFirstCursorOperation(NULL),
- m_theLastCursorOperation(NULL),
- m_firstExecutedCursorOp(NULL),
// Scan operations
- theScanFinished(0),
- theCurrentScanRec(NULL),
- thePreviousScanRec(NULL),
+ m_waitForReply(true),
+ m_theFirstScanOperation(NULL),
+ m_theLastScanOperation(NULL),
+ m_firstExecutedScanOp(NULL),
+ // Scan operations
theScanningOp(NULL),
theBuddyConPtr(0xFFFFFFFF)
{
@@ -117,7 +115,6 @@ NdbConnection::init()
theListState = NotInList;
theInUseState = true;
theTransactionIsStarted = false;
- theScanFinished = 0;
theNext = NULL;
theFirstOpInList = NULL;
@@ -128,9 +125,6 @@ NdbConnection::init()
theFirstExecOpInList = NULL;
theLastExecOpInList = NULL;
- theCurrentScanRec = NULL;
- thePreviousScanRec = NULL;
-
theCompletedFirstOp = NULL;
theGlobalCheckpointId = 0;
@@ -146,11 +140,11 @@ NdbConnection::init()
theSimpleState = true;
theSendStatus = InitState;
theMagicNumber = 0x37412619;
- // Cursor operations
+ // Scan operations
m_waitForReply = true;
- m_theFirstCursorOperation = NULL;
- m_theLastCursorOperation = NULL;
- m_firstExecutedCursorOp = 0;
+ m_theFirstScanOperation = NULL;
+ m_theLastScanOperation = NULL;
+ m_firstExecutedScanOp = 0;
theBuddyConPtr = 0xFFFFFFFF;
}//NdbConnection::init()
@@ -331,7 +325,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
*/
theError.code = 0;
- NdbCursorOperation* tcOp = m_theFirstCursorOperation;
+ NdbScanOperation* tcOp = m_theFirstScanOperation;
if (tcOp != 0){
// Execute any cursor operations
while (tcOp != NULL) {
@@ -340,14 +334,14 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
if (tReturnCode == -1) {
return;
}//if
- tcOp = (NdbCursorOperation*)tcOp->next();
+ tcOp = (NdbScanOperation*)tcOp->next();
} // while
- m_theLastCursorOperation->next(m_firstExecutedCursorOp);
- m_firstExecutedCursorOp = m_theFirstCursorOperation;
+ m_theLastScanOperation->next(m_firstExecutedScanOp);
+ m_firstExecutedScanOp = m_theFirstScanOperation;
// Discard cursor operations, since these are also
// in the complete operations list we do not need
// to release them.
- m_theFirstCursorOperation = m_theLastCursorOperation = NULL;
+ m_theFirstScanOperation = m_theLastScanOperation = NULL;
}
bool tTransactionIsStarted = theTransactionIsStarted;
@@ -714,17 +708,14 @@ Remark: Release all operations.
******************************************************************************/
void
NdbConnection::release(){
- if (theTransactionIsStarted == true && theScanningOp != NULL )
- stopScan();
-
releaseOperations();
if ( (theTransactionIsStarted == true) &&
- ((theCommitStatus != Committed) &&
- (theCommitStatus != Aborted))) {
-/****************************************************************************
- * The user did not perform any rollback but simply closed the
- * transaction. We must rollback Ndb since Ndb have been contacted.
-******************************************************************************/
+ ((theCommitStatus != Committed) &&
+ (theCommitStatus != Aborted))) {
+ /************************************************************************
+ * The user did not perform any rollback but simply closed the
+ * transaction. We must rollback Ndb since Ndb have been contacted.
+ ************************************************************************/
execute(Rollback);
}//if
theMagicNumber = 0xFE11DC;
@@ -756,8 +747,8 @@ void
NdbConnection::releaseOperations()
{
// Release any open scans
- releaseCursorOperations(m_theFirstCursorOperation);
- releaseCursorOperations(m_firstExecutedCursorOp);
+ releaseScanOperations(m_theFirstScanOperation);
+ releaseScanOperations(m_firstExecutedScanOp);
releaseOps(theCompletedFirstOp);
releaseOps(theFirstOpInList);
@@ -769,9 +760,9 @@ NdbConnection::releaseOperations()
theLastOpInList = NULL;
theLastExecOpInList = NULL;
theScanningOp = NULL;
- m_theFirstCursorOperation = NULL;
- m_theLastCursorOperation = NULL;
- m_firstExecutedCursorOp = NULL;
+ m_theFirstScanOperation = NULL;
+ m_theLastScanOperation = NULL;
+ m_firstExecutedScanOp = NULL;
}//NdbConnection::releaseOperations()
void
@@ -782,24 +773,21 @@ NdbConnection::releaseCompletedOperations()
}//NdbConnection::releaseOperations()
/******************************************************************************
-void releaseCursorOperations();
+void releaseScanOperations();
Remark: Release all cursor operations.
(NdbScanOperation and NdbIndexOperation)
******************************************************************************/
void
-NdbConnection::releaseCursorOperations(NdbCursorOperation* cursorOp)
+NdbConnection::releaseScanOperations(NdbIndexScanOperation* cursorOp)
{
while(cursorOp != 0){
- NdbCursorOperation* next = (NdbCursorOperation*)cursorOp->next();
+ NdbIndexScanOperation* next = (NdbIndexScanOperation*)cursorOp->next();
cursorOp->release();
- if (cursorOp->cursorType() == NdbCursorOperation::ScanCursor)
- theNdb->releaseScanOperation((NdbScanOperation*)cursorOp);
- else
- theNdb->releaseOperation(cursorOp);
+ theNdb->releaseScanOperation(cursorOp);
cursorOp = next;
}
-}//NdbConnection::releaseCursorOperations()
+}//NdbConnection::releaseScanOperations()
/*****************************************************************************
NdbOperation* getNdbOperation(const char* aTableName);
@@ -832,45 +820,6 @@ NdbConnection::getNdbOperation(const char* aTableName)
return NULL;
}//NdbConnection::getNdbOperation()
-/*****************************************************************************
-NdbOperation* getNdbOperation(const char* anIndexName, const char* aTableName);
-
-Return Value Return a pointer to a NdbOperation object if getNdbOperation
- was succesful.
- Return NULL : In all other case.
-Parameters: anIndexName : Name of the index to use.
- aTableName : Name of the database table.
-Remark: Get an operation from NdbOperation idlelist and get the
- NdbConnection object
- who was fetch by startTransaction pointing to this operation
- getOperation will set the theTableId in the NdbOperation object.
- synchronous
-******************************************************************************/
-NdbOperation*
-NdbConnection::getNdbOperation(const char* anIndexName, const char* aTableName)
-{
- if ((theError.code == 0) &&
- (theCommitStatus == Started)){
- NdbIndexImpl* index =
- theNdb->theDictionary->getIndex(anIndexName, aTableName);
- NdbTableImpl* table = theNdb->theDictionary->getTable(aTableName);
- NdbTableImpl* indexTable =
- theNdb->theDictionary->getIndexTable(index, table);
- if (indexTable != 0){
- return getNdbOperation(indexTable);
- } else {
- setErrorCode(theNdb->theDictionary->getNdbError().code);
- return NULL;
- }//if
- } else {
- if (theError.code == 0) {
- setOperationErrorCodeAbort(4114);
- }//if
-
- return NULL;
- }//if
-}//NdbConnection::getNdbOperation()
-
/*****************************************************************************
NdbOperation* getNdbOperation(int aTableId);
@@ -956,8 +905,9 @@ Remark: Get an operation from NdbScanOperation idlelist and get the NdbC
who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbOperation object.synchronous
******************************************************************************/
-NdbScanOperation*
-NdbConnection::getNdbScanOperation(const char* anIndexName, const char* aTableName)
+NdbIndexScanOperation*
+NdbConnection::getNdbIndexScanOperation(const char* anIndexName,
+ const char* aTableName)
{
if (theCommitStatus == Started){
NdbIndexImpl* index =
@@ -966,7 +916,9 @@ NdbConnection::getNdbScanOperation(const char* anIndexName, const char* aTableNa
NdbTableImpl* indexTable =
theNdb->theDictionary->getIndexTable(index, table);
if (indexTable != 0){
- return getNdbScanOperation(indexTable);
+ NdbIndexScanOperation* tOp = getNdbScanOperation(indexTable);
+ if(tOp) tOp->m_cursor_type = NdbScanOperation::IndexCursor;
+ return tOp;
} else {
setOperationErrorCodeAbort(theNdb->theError.code);
return NULL;
@@ -987,21 +939,21 @@ Remark: Get an operation from NdbScanOperation object idlelist and get t
object who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbOperation object, synchronous.
*****************************************************************************/
-NdbScanOperation*
+NdbIndexScanOperation*
NdbConnection::getNdbScanOperation(NdbTableImpl * tab)
{
- NdbScanOperation* tOp;
+ NdbIndexScanOperation* tOp;
tOp = theNdb->getScanOperation();
if (tOp == NULL)
goto getNdbOp_error1;
// Link scan operation into list of cursor operations
- if (m_theLastCursorOperation == NULL)
- m_theFirstCursorOperation = m_theLastCursorOperation = tOp;
+ if (m_theLastScanOperation == NULL)
+ m_theFirstScanOperation = m_theLastScanOperation = tOp;
else {
- m_theLastCursorOperation->next(tOp);
- m_theLastCursorOperation = tOp;
+ m_theLastScanOperation->next(tOp);
+ m_theLastScanOperation = tOp;
}
tOp->next(NULL);
if (tOp->init(tab, this) != -1) {
@@ -1211,12 +1163,12 @@ Remark:
int
NdbConnection::receiveTC_COMMITCONF(const TcCommitConf * commitConf)
{
- if(theStatus != Connected){
- return -1;
+ if(checkState_TransId(&commitConf->transId1)){
+ theCommitStatus = Committed;
+ theCompletionStatus = CompletedSuccess;
+ return 0;
}
- theCommitStatus = Committed;
- theCompletionStatus = CompletedSuccess;
- return 0;
+ return -1;
}//NdbConnection::receiveTC_COMMITCONF()
/******************************************************************************
@@ -1230,33 +1182,33 @@ Remark:
int
NdbConnection::receiveTC_COMMITREF(NdbApiSignal* aSignal)
{
- if(theStatus != Connected){
- return -1;
+ const TcCommitRef * ref = CAST_CONSTPTR(TcCommitRef, aSignal->getDataPtr());
+ if(checkState_TransId(&ref->transId1)){
+ setOperationErrorCodeAbort(ref->errorCode);
+ theCommitStatus = Aborted;
+ theCompletionStatus = CompletedFailure;
+ return 0;
}
- const TcCommitRef * const ref = CAST_CONSTPTR(TcCommitRef, aSignal->getDataPtr());
- setOperationErrorCodeAbort(ref->errorCode);
- theCommitStatus = Aborted;
- theCompletionStatus = CompletedFailure;
- return 0;
+ return -1;
}//NdbConnection::receiveTC_COMMITREF()
-/*******************************************************************************
+/******************************************************************************
int receiveTCROLLBACKCONF(NdbApiSignal* aSignal);
Return Value: Return 0 : receiveTCROLLBACKCONF was successful.
Return -1: In all other case.
Parameters: aSignal: The signal object pointer.
Remark:
-*******************************************************************************/
+******************************************************************************/
int
NdbConnection::receiveTCROLLBACKCONF(NdbApiSignal* aSignal)
{
- if(theStatus != Connected){
- return -1;
+ if(checkState_TransId(aSignal->getDataPtr() + 1)){
+ theCommitStatus = Aborted;
+ theCompletionStatus = CompletedSuccess;
+ return 0;
}
- theCommitStatus = Aborted;
- theCompletionStatus = CompletedSuccess;
- return 0;
+ return -1;
}//NdbConnection::receiveTCROLLBACKCONF()
/*******************************************************************************
@@ -1270,13 +1222,13 @@ Remark:
int
NdbConnection::receiveTCROLLBACKREF(NdbApiSignal* aSignal)
{
- if(theStatus != Connected){
- return -1;
+ if(checkState_TransId(aSignal->getDataPtr() + 1)){
+ setOperationErrorCodeAbort(aSignal->readData(4));
+ theCommitStatus = Aborted;
+ theCompletionStatus = CompletedFailure;
+ return 0;
}
- setOperationErrorCodeAbort(aSignal->readData(2));
- theCommitStatus = Aborted;
- theCompletionStatus = CompletedFailure;
- return 0;
+ return -1;
}//NdbConnection::receiveTCROLLBACKREF()
/*****************************************************************************
@@ -1291,36 +1243,26 @@ Remark: Handles the reception of the ROLLBACKREP signal.
int
NdbConnection::receiveTCROLLBACKREP( NdbApiSignal* aSignal)
{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tTmp1, tTmp2;
-
- if (theStatus != Connected) {
- return -1;
- }//if
-/*****************************************************************************
+ /****************************************************************************
Check that we are expecting signals from this transaction and that it doesn't
belong to a transaction already completed. Simply ignore messages from other
transactions.
-******************************************************************************/
- tTmp1 = aSignal->readData(2);
- tTmp2 = aSignal->readData(3);
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
- tCurrTransId = this->getTransactionId();
- if (tCurrTransId != tRecTransId) {
- return -1;
- }//if
- theError.code = aSignal->readData(4); // Override any previous errors
+ ****************************************************************************/
+ if(checkState_TransId(aSignal->getDataPtr() + 1)){
+ theError.code = aSignal->readData(4);// Override any previous errors
-/**********************************************************************/
-/* A serious error has occured. This could be due to deadlock or */
-/* lack of resources or simply a programming error in NDB. This */
-/* transaction will be aborted. Actually it has already been */
-/* and we only need to report completion and return with the */
-/* error code to the application. */
-/**********************************************************************/
- theCompletionStatus = CompletedFailure;
- theCommitStatus = Aborted;
- return 0;
+ /**********************************************************************/
+ /* A serious error has occured. This could be due to deadlock or */
+ /* lack of resources or simply a programming error in NDB. This */
+ /* transaction will be aborted. Actually it has already been */
+ /* and we only need to report completion and return with the */
+ /* error code to the application. */
+ /**********************************************************************/
+ theCompletionStatus = CompletedFailure;
+ theCommitStatus = Aborted;
+ return 0;
+ }
+ return -1;
}//NdbConnection::receiveTCROLLBACKREP()
/*******************************************************************************
@@ -1334,47 +1276,38 @@ Remark:
int
NdbConnection::receiveTCKEYCONF(const TcKeyConf * keyConf, Uint32 aDataLength)
{
- Uint64 tRecTransId;
- NdbOperation* tOp;
- Uint32 tConditionFlag;
-
+ NdbReceiver* tOp;
const Uint32 tTemp = keyConf->confInfo;
- const Uint32 tTmp1 = keyConf->transId1;
- const Uint32 tTmp2 = keyConf->transId2;
-/******************************************************************************
+ /***************************************************************************
Check that we are expecting signals from this transaction and that it
doesn't belong to a transaction already completed. Simply ignore messages
from other transactions.
-******************************************************************************/
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
+ ***************************************************************************/
+ if(checkState_TransId(&keyConf->transId1)){
- const Uint32 tNoOfOperations = TcKeyConf::getNoOfOperations(tTemp);
- const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
- tConditionFlag = (Uint32)(((aDataLength - 5) >> 1) - tNoOfOperations);
- tConditionFlag |= (Uint32)(tNoOfOperations > 10);
- tConditionFlag |= (Uint32)(tNoOfOperations <= 0);
- tConditionFlag |= (Uint32)(theTransactionId - tRecTransId);
- tConditionFlag |= (Uint32)(theStatus - Connected);
+ const Uint32 tNoOfOperations = TcKeyConf::getNoOfOperations(tTemp);
+ const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
- if (tConditionFlag == 0) {
const Uint32* tPtr = (Uint32 *)&keyConf->operations[0];
+ Uint32 tNoComp = theNoOfOpCompleted;
for (Uint32 i = 0; i < tNoOfOperations ; i++) {
- tOp = theNdb->void2rec_op(theNdb->int2void(*tPtr));
+ tOp = theNdb->void2rec(theNdb->int2void(*tPtr));
tPtr++;
const Uint32 tAttrInfoLen = *tPtr;
tPtr++;
- if (tOp && tOp->checkMagicNumber() != -1) {
- tOp->TCOPCONF(tAttrInfoLen);
+ if (tOp && tOp->checkMagicNumber()) {
+ tNoComp += tOp->execTCOPCONF(tAttrInfoLen);
} else {
return -1;
}//if
}//for
- Uint32 tNoComp = theNoOfOpCompleted;
Uint32 tNoSent = theNoOfOpSent;
+ theNoOfOpCompleted = tNoComp;
Uint32 tGCI = keyConf->gci;
if (tCommitFlag == 1) {
theCommitStatus = Committed;
theGlobalCheckpointId = tGCI;
+ theTransactionId++;
} else if ((tNoComp >= tNoSent) &&
(theLastExecOpInList->theCommitIndicator == 1)){
/**********************************************************************/
@@ -1406,50 +1339,46 @@ Remark: Handles the reception of the TCKEY_FAILCONF signal.
int
NdbConnection::receiveTCKEY_FAILCONF(const TcKeyFailConf * failConf)
{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tTmp1, tTmp2;
NdbOperation* tOp;
- if (theStatus != Connected) {
- return -1;
- }//if
/*
- Check that we are expecting signals from this transaction and that it
- doesn't belong to a transaction already completed. Simply ignore
- messages from other transactions.
+ Check that we are expecting signals from this transaction and that it
+ doesn't belong to a transaction already completed. Simply ignore
+ messages from other transactions.
*/
- tTmp1 = failConf->transId1;
- tTmp2 = failConf->transId2;
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
- tCurrTransId = this->getTransactionId();
- if (tCurrTransId != tRecTransId) {
- return -1;
- }//if
- /*
- A node failure of the TC node occured. The transaction has
- been committed.
- */
- theCommitStatus = Committed;
- tOp = theFirstExecOpInList;
- while (tOp != NULL) {
+ if(checkState_TransId(&failConf->transId1)){
/*
- Check if the transaction expected read values...
- If it did some of them might have gotten lost even if we succeeded
- in committing the transaction.
+ A node failure of the TC node occured. The transaction has
+ been committed.
*/
- if (tOp->theAI_ElementLen != 0) {
- theCompletionStatus = CompletedFailure;
- setOperationErrorCodeAbort(4115);
- break;
- }//if
- if (tOp->theCurrentRecAttr != NULL) {
- theCompletionStatus = CompletedFailure;
- setOperationErrorCodeAbort(4115);
- break;
- }//if
- tOp = tOp->next();
- }//while
- theReleaseOnClose = true;
- return 0;
+ theCommitStatus = Committed;
+ tOp = theFirstExecOpInList;
+ while (tOp != NULL) {
+ /*
+ * Check if the transaction expected read values...
+ * If it did some of them might have gotten lost even if we succeeded
+ * in committing the transaction.
+ */
+ switch(tOp->theOperationType){
+ case UpdateRequest:
+ case InsertRequest:
+ case DeleteRequest:
+ case WriteRequest:
+ tOp = tOp->next();
+ break;
+ case ReadRequest:
+ case ReadExclusive:
+ case OpenScanRequest:
+ case OpenRangeScanRequest:
+ theCompletionStatus = CompletedFailure;
+ setOperationErrorCodeAbort(4115);
+ tOp = NULL;
+ break;
+ }//if
+ }//while
+ theReleaseOnClose = true;
+ return 0;
+ }
+ return -1;
}//NdbConnection::receiveTCKEY_FAILCONF()
/*************************************************************************
@@ -1464,101 +1393,75 @@ Remark: Handles the reception of the TCKEY_FAILREF signal.
int
NdbConnection::receiveTCKEY_FAILREF(NdbApiSignal* aSignal)
{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tTmp1, tTmp2;
-
- if (theStatus != Connected) {
- return -1;
- }//if
/*
- Check that we are expecting signals from this transaction and
- that it doesn't belong to a transaction already
- completed. Simply ignore messages from other transactions.
+ Check that we are expecting signals from this transaction and
+ that it doesn't belong to a transaction already
+ completed. Simply ignore messages from other transactions.
*/
- tTmp1 = aSignal->readData(2);
- tTmp2 = aSignal->readData(3);
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
- tCurrTransId = this->getTransactionId();
- if (tCurrTransId != tRecTransId) {
- return -1;
- }//if
- /*
- We received an indication of that this transaction was aborted due to a
- node failure.
- */
- if (theSendStatus == sendTC_ROLLBACK) {
+ if(checkState_TransId(aSignal->getDataPtr()+1)){
/*
- We were in the process of sending a rollback anyways. We will
- report it as a success.
+ We received an indication of that this transaction was aborted due to a
+ node failure.
*/
- theCompletionStatus = CompletedSuccess;
- } else {
- theCompletionStatus = CompletedFailure;
- theError.code = 4031;
- }//if
- theReleaseOnClose = true;
- theCommitStatus = Aborted;
- return 0;
+ if (theSendStatus == sendTC_ROLLBACK) {
+ /*
+ We were in the process of sending a rollback anyways. We will
+ report it as a success.
+ */
+ theCompletionStatus = CompletedSuccess;
+ } else {
+ theCompletionStatus = CompletedFailure;
+ theError.code = 4031;
+ }//if
+ theReleaseOnClose = true;
+ theCommitStatus = Aborted;
+ return 0;
+ }
+ return -1;
}//NdbConnection::receiveTCKEY_FAILREF()
-/*******************************************************************************
+/******************************************************************************
int receiveTCINDXCONF(NdbApiSignal* aSignal, Uint32 long_short_ind);
Return Value: Return 0 : receiveTCINDXCONF was successful.
Return -1: In all other case.
Parameters: aSignal: The signal object pointer.
Remark:
-*******************************************************************************/
-int
-NdbConnection::receiveTCINDXCONF(const TcIndxConf * indxConf, Uint32 aDataLength)
-{
- Uint64 tRecTransId;
- Uint32 tConditionFlag;
-
- const Uint32 tTemp = indxConf->confInfo;
- const Uint32 tTmp1 = indxConf->transId1;
- const Uint32 tTmp2 = indxConf->transId2;
-/******************************************************************************
-Check that we are expecting signals from this transaction and that it
-doesn't belong to a transaction already completed. Simply ignore messages
-from other transactions.
******************************************************************************/
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
-
- const Uint32 tNoOfOperations = TcIndxConf::getNoOfOperations(tTemp);
- const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
-
- tConditionFlag = (Uint32)(((aDataLength - 5) >> 1) - tNoOfOperations);
- tConditionFlag |= (Uint32)(tNoOfOperations > 10);
- tConditionFlag |= (Uint32)(tNoOfOperations <= 0);
- tConditionFlag |= (Uint32)(theTransactionId - tRecTransId);
- tConditionFlag |= (Uint32)(theStatus - Connected);
-
- if (tConditionFlag == 0) {
+int
+NdbConnection::receiveTCINDXCONF(const TcIndxConf * indxConf,
+ Uint32 aDataLength)
+{
+ if(checkState_TransId(&indxConf->transId1)){
+ const Uint32 tTemp = indxConf->confInfo;
+ const Uint32 tNoOfOperations = TcIndxConf::getNoOfOperations(tTemp);
+ const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
+
const Uint32* tPtr = (Uint32 *)&indxConf->operations[0];
+ Uint32 tNoComp = theNoOfOpCompleted;
for (Uint32 i = 0; i < tNoOfOperations ; i++) {
- NdbIndexOperation* tOp = theNdb->void2rec_iop(theNdb->int2void(*tPtr));
+ NdbReceiver* tOp = theNdb->void2rec(theNdb->int2void(*tPtr));
tPtr++;
const Uint32 tAttrInfoLen = *tPtr;
tPtr++;
- if (tOp && tOp->checkMagicNumber() != -1) {
- tOp->TCOPCONF(tAttrInfoLen);
+ if (tOp && tOp->checkMagicNumber()) {
+ tNoComp += tOp->execTCOPCONF(tAttrInfoLen);
} else {
return -1;
}//if
}//for
- Uint32 tNoComp = theNoOfOpCompleted;
Uint32 tNoSent = theNoOfOpSent;
Uint32 tGCI = indxConf->gci;
+ theNoOfOpCompleted = tNoComp;
if (tCommitFlag == 1) {
theCommitStatus = Committed;
theGlobalCheckpointId = tGCI;
} else if ((tNoComp >= tNoSent) &&
(theLastExecOpInList->theCommitIndicator == 1)){
-/**********************************************************************/
-// We sent the transaction with Commit flag set and received a CONF with
-// no Commit flag set. This is clearly an anomaly.
-/**********************************************************************/
+ /**********************************************************************/
+ // We sent the transaction with Commit flag set and received a CONF with
+ // no Commit flag set. This is clearly an anomaly.
+ /**********************************************************************/
theError.code = 4011;
theCompletionStatus = CompletedFailure;
theCommitStatus = Aborted;
@@ -1584,36 +1487,21 @@ Remark: Handles the reception of the TCINDXREF signal.
int
NdbConnection::receiveTCINDXREF( NdbApiSignal* aSignal)
{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tTmp1, tTmp2;
+ if(checkState_TransId(aSignal->getDataPtr()+1)){
+ theError.code = aSignal->readData(4); // Override any previous errors
- if (theStatus != Connected) {
- return -1;
- }//if
-/*****************************************************************************
-Check that we are expecting signals from this transaction and that it doesn't
-belong to a transaction already completed. Simply ignore messages from other
-transactions.
-******************************************************************************/
- tTmp1 = aSignal->readData(2);
- tTmp2 = aSignal->readData(3);
- tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
- tCurrTransId = this->getTransactionId();
- if (tCurrTransId != tRecTransId) {
- return -1;
- }//if
- theError.code = aSignal->readData(4); // Override any previous errors
-
-/**********************************************************************/
-/* A serious error has occured. This could be due to deadlock or */
-/* lack of resources or simply a programming error in NDB. This */
-/* transaction will be aborted. Actually it has already been */
-/* and we only need to report completion and return with the */
-/* error code to the application. */
-/**********************************************************************/
- theCompletionStatus = CompletedFailure;
- theCommitStatus = Aborted;
- return 0;
+ /**********************************************************************/
+ /* A serious error has occured. This could be due to deadlock or */
+ /* lack of resources or simply a programming error in NDB. This */
+ /* transaction will be aborted. Actually it has already been */
+ /* and we only need to report completion and return with the */
+ /* error code to the application. */
+ /**********************************************************************/
+ theCompletionStatus = CompletedFailure;
+ theCommitStatus = Aborted;
+ return 0;
+ }
+ return -1;
}//NdbConnection::receiveTCINDXREF()
/*******************************************************************************
diff --git a/ndb/src/ndbapi/NdbConnectionScan.cpp b/ndb/src/ndbapi/NdbConnectionScan.cpp
index 962acc0bdac..ea45f2b5a00 100644
--- a/ndb/src/ndbapi/NdbConnectionScan.cpp
+++ b/ndb/src/ndbapi/NdbConnectionScan.cpp
@@ -33,7 +33,6 @@
#include
#include
#include
-#include "NdbScanReceiver.hpp"
#include "NdbApiSignal.hpp"
#include "TransporterFacade.hpp"
#include "NdbUtil.hpp"
@@ -49,299 +48,6 @@
#define WAITFOR_SCAN_TIMEOUT 120000
-/*****************************************************************************
- * int executeScan();
- *
- * 1. Check that the transaction is started and other important preconditions
- * 2. Tell the kernel to start scanning by sending one SCAN_TABREQ, if
- * parallelism is greater than 16 also send one SCAN_TABINFO for each
- * additional 16
- * Define which attributes to scan in ATTRINFO, this signal also holds the
- * interpreted program
- * 3. Wait for the answer of the SCAN_TABREQ. This is either a SCAN_TABCONF if
- * the scan was correctly defined and a SCAN_TABREF if the scan couldn't
- * be started.
- * 4. Check the result, if scan was not started return -1
- *
- ****************************************************************************/
-int
-NdbConnection::executeScan(){
- if (theTransactionIsStarted == true){ // Transaction already started.
- setErrorCode(4600);
- return -1;
- }
- if (theStatus != Connected) { // Lost connection
- setErrorCode(4601);
- return -1;
- }
- if (theScanningOp == NULL){
- setErrorCode(4602); // getNdbOperation must be called before executeScan
- return -1;
- }
- TransporterFacade* tp = TransporterFacade::instance();
- theNoOfOpCompleted = 0;
- theNoOfSCANTABCONFRecv = 0;
- tp->lock_mutex();
- if (tp->get_node_alive(theDBnode) &&
- (tp->getNodeSequence(theDBnode) == theNodeSequence)) {
- if (tp->check_send_size(theDBnode, get_send_size())) {
- theTransactionIsStarted = true;
- if (sendScanStart() == -1){
- tp->unlock_mutex();
- return -1;
- }//if
- theNdb->theWaiter.m_node = theDBnode;
- theNdb->theWaiter.m_state = WAIT_SCAN;
- int res = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
- if (res == 0) {
- return 0;
- } else {
- if (res == -1) {
- setErrorCode(4008);
- } else if (res == -2) {
- theTransactionIsStarted = false;
- theReleaseOnClose = true;
- setErrorCode(4028);
- } else {
- ndbout << "Impossible return from receiveResponse in executeScan";
- ndbout << endl;
- abort();
- }//if
- theCommitStatus = Aborted;
- return -1;
- }//if
- } else {
- TRACE_DEBUG("Start a scan with send buffer full attempted");
- setErrorCode(4022);
- theCommitStatus = Aborted;
- }//if
- } else {
- if (!(tp->get_node_stopping(theDBnode) &&
- (tp->getNodeSequence(theDBnode) == theNodeSequence))) {
- TRACE_DEBUG("The node is hard dead when attempting to start a scan");
- setErrorCode(4029);
- theReleaseOnClose = true;
- } else {
- TRACE_DEBUG("The node is stopping when attempting to start a scan");
- setErrorCode(4030);
- }//if
- theCommitStatus = Aborted;
- }//if
- tp->unlock_mutex();
- return -1;
-}
-
-/******************************************************************************
- * int nextScanResult();
- * Remark:
- * This method is used to distribute data received to the application.
- * Iterate through the list and search for operations that haven't
- * been distributed yet (status != Finished).
- * If there are no more operations/records still waiting to be exececuted
- * we have to send SCAN_NEXTREQ to fetch next set of records.
- *
- * TODO - This function should be able to return a value indicating if
- * there are any more records already fetched from memory or if it has to
- * ask the db for more. This would mean we could get better performance when
- * takeOver is used wince we can take over all ops already fetched, put them
- * in another trans and send them of to the db when there are no more records
- * already fetched. Maybe use a new argument to the function for this
-******************************************************************************/
-int
-NdbConnection::nextScanResult(bool fetchAllowed){
-
- if (theTransactionIsStarted != true){ // Transaction not started.
- setErrorCode(4601);
- return -1;
- }
- // Scan has finished ok but no operations recived = empty recordset.
- if(theScanFinished == true){
- return 1; // No more records
- }
- if (theStatus != Connected){// Lost connection
- setErrorCode(4601);
- return -1;
- }
- // Something went wrong, probably we got a SCAN_TABREF earlier.
- if (theCompletionStatus == CompletedFailure) {
- return -1;
- }
- if (theNoOfOpCompleted == theNoOfOpFetched) {
- // There are no more records cached in NdbApi
- if (fetchAllowed == true){
- // Get some more records from db
-
- if (fetchNextScanResult() == -1){
- return -1;
- }
- if (theScanFinished == true) { // The scan has finished.
- return 1; // 1 = No more records
- }
- if (theCompletionStatus == CompletedFailure) {
- return -1; // Something went wrong, probably we got a SCAN_TABREF.
- }
- } else {
- // There where no more cached records in NdbApi
- // and we where not allowed to go to db and ask for
- // more
- return 2;
- }
- }
-
- // It's not allowed to come here without any cached records
- if (theCurrentScanRec == NULL){
-#ifdef VM_TRACE
- ndbout << "nextScanResult("<theWaiter.m_node = " <theWaiter.m_node<theWaiter.m_state = " << theNdb->theWaiter.m_state << endl;
- abort();
-#endif
- return -1;
- }
-
- // Execute the saved signals for this operation.
- NdbScanReceiver* tScanRec = theCurrentScanRec;
- theScanningOp->theCurrRecAI_Len = 0;
- theScanningOp->theCurrentRecAttr = theScanningOp->theFirstRecAttr;
- if(tScanRec->executeSavedSignals() != 0)
- return -1;
- theNoOfOpCompleted++;
- // Remember for next iteration and takeOverScanOp
- thePreviousScanRec = tScanRec;
- theCurrentScanRec = tScanRec->next();
- return 0; // 0 = There are more rows to be fetched.
-}
-
-/******************************************************************************
- * int stopScan()
- * Remark: By sending SCAN_NEXTREQ with data word 2 set to TRUE we
- * abort the scan process.
- *****************************************************************************/
-int
-NdbConnection::stopScan()
-{
- if(theScanFinished == true){
- return 0;
- }
- if (theCompletionStatus == CompletedFailure){
- return 0;
- }
-
- if (theScanningOp == 0){
- return 0;
- }
-
- theNoOfOpCompleted = 0;
- theNoOfSCANTABCONFRecv = 0;
- theScanningOp->prepareNextScanResult();
- return sendScanNext(1);
-}
-
-
-/********************************************************************
- * int sendScanStart()
- *
- * Send the signals reuired to define and start the scan
- * 1. Send SCAN_TABREQ
- * 2. Send SCAN_TABINFO(if any, parallelism must be > 16)
- * 3. Send ATTRINFO signals
- *
- * Returns -1 if an error occurs otherwise 0.
- *
- ********************************************************************/
-int
-NdbConnection::sendScanStart(){
-
- /***** 0. Prepare signals ******************/
- // This might modify variables and signals
- if(theScanningOp->prepareSendScan(theTCConPtr,
- theTransactionId) == -1)
- return -1;
-
- /***** 1. Send SCAN_TABREQ **************/
- /***** 2. Send SCAN_TABINFO *************/
- /***** 3. Send ATTRINFO signals *********/
- if (theScanningOp->doSendScan(theDBnode) == -1)
- return -1;
- return 0;
-}
-
-
-int
-NdbConnection::fetchNextScanResult(){
- theNoOfOpCompleted = 0;
- theNoOfSCANTABCONFRecv = 0;
- theScanningOp->prepareNextScanResult();
- return sendScanNext(0);
-}
-
-
-
-/***********************************************************
- * int sendScanNext(int stopScanFlag)
- *
- * ************************************************************/
-int NdbConnection::sendScanNext(bool stopScanFlag){
- NdbApiSignal tSignal(theNdb->theMyRef);
- Uint32 tTransId1, tTransId2;
- tSignal.setSignal(GSN_SCAN_NEXTREQ);
- tSignal.setData(theTCConPtr, 1);
- // Set the stop flag in word 2(1 = stop)
- Uint32 tStopValue;
- tStopValue = stopScanFlag == true ? 1 : 0;
- tSignal.setData(tStopValue, 2);
- tTransId1 = (Uint32) theTransactionId;
- tTransId2 = (Uint32) (theTransactionId >> 32);
- tSignal.setData(tTransId1, 3);
- tSignal.setData(tTransId2, 4);
- tSignal.setLength(4);
- Uint32 conn_seq = theNodeSequence;
- int return_code = theNdb->sendRecSignal(theDBnode,
- WAIT_SCAN,
- &tSignal,
- conn_seq);
- if (return_code == 0) {
- return 0;
- } else if (return_code == -1) { // Time-out
- TRACE_DEBUG("Time-out when sending sendScanNext");
- setErrorCode(4024);
- theTransactionIsStarted = false;
- theReleaseOnClose = true;
- theCommitStatus = Aborted;
- } else if (return_code == -2) { // Node failed
- TRACE_DEBUG("Node failed when sendScanNext");
- setErrorCode(4027);
- theTransactionIsStarted = false;
- theReleaseOnClose = true;
- theCommitStatus = Aborted;
- } else if (return_code == -3) {
- TRACE_DEBUG("Send failed when sendScanNext");
- setErrorCode(4033);
- theTransactionIsStarted = false;
- theReleaseOnClose = true;
- theCommitStatus = Aborted;
- } else if (return_code == -4) {
- TRACE_DEBUG("Send buffer full when sendScanNext");
- setErrorCode(4032);
- } else if (return_code == -5) {
- TRACE_DEBUG("Node stopping when sendScanNext");
- setErrorCode(4034);
- } else {
- ndbout << "Impossible return from sendRecSignal" << endl;
- abort();
- }//if
- return -1;
-}
-
/***************************************************************************
* int receiveSCAN_TABREF(NdbApiSignal* aSignal)
@@ -352,39 +58,13 @@ int NdbConnection::sendScanNext(bool stopScanFlag){
****************************************************************************/
int
NdbConnection::receiveSCAN_TABREF(NdbApiSignal* aSignal){
- const ScanTabRef * const scanTabRef = CAST_CONSTPTR(ScanTabRef, aSignal->getDataPtr());
- if (theStatus != Connected){
-#ifdef VM_TRACE
- ndbout << "SCAN_TABREF dropped, theStatus = " << theStatus << endl;
-#endif
- return -1;
+ const ScanTabRef * ref = CAST_CONSTPTR(ScanTabRef, aSignal->getDataPtr());
+
+ if(checkState_TransId(&ref->transId1)){
+ theScanningOp->execCLOSE_SCAN_REP(ref->errorCode);
+ return 0;
}
- if (aSignal->getLength() != ScanTabRef::SignalLength){
-#ifdef VM_TRACE
- ndbout << "SCAN_TABREF dropped, signal length " << aSignal->getLength() << endl;
-#endif
- return -1;
- }
- const Uint64 tCurrTransId = this->getTransactionId();
- const Uint64 tRecTransId = (Uint64)scanTabRef->transId1 +
- ((Uint64)scanTabRef->transId2 << 32);
- if ((tRecTransId - tCurrTransId) != (Uint64)0){
-#ifdef VM_TRACE
- ndbout << "SCAN_TABREF dropped, wrong transid" << endl;
-#endif
- return -1;
- }
-#if 0
- ndbout << "SCAN_TABREF, "
- <<"transid=("<transId1<<", "<transId2<<")"
- <<", err="<errorCode << endl;
-#endif
- setErrorCode(scanTabRef->errorCode);
- theCompletionStatus = CompletedFailure;
- theCommitStatus = Aborted; // Indicate that this "transaction" was aborted
- theTransactionIsStarted = false;
- theScanningOp->releaseSignals();
- return 0;
+ return -1;
}
/*****************************************************************************
@@ -401,173 +81,43 @@ NdbConnection::receiveSCAN_TABREF(NdbApiSignal* aSignal){
*
*****************************************************************************/
int
-NdbConnection::receiveSCAN_TABCONF(NdbApiSignal* aSignal)
+NdbConnection::receiveSCAN_TABCONF(NdbApiSignal* aSignal,
+ const Uint32 * ops, Uint32 len)
{
- const ScanTabConf * const conf = CAST_CONSTPTR(ScanTabConf, aSignal->getDataPtr());
- if (theStatus != Connected){
-#ifdef VM_TRACE
- ndbout << "Dropping SCAN_TABCONF, theStatus = "<< theStatus << endl;
-#endif
- return -1;
- }
- if(aSignal->getLength() != ScanTabConf::SignalLength){
-#ifdef VM_TRACE
- ndbout << "Dropping SCAN_TABCONF, getLength = "<< aSignal->getLength() << endl;
-#endif
- return -1;
- }
- const Uint64 tCurrTransId = this->getTransactionId();
- const Uint64 tRecTransId =
- (Uint64)conf->transId1 + ((Uint64)conf->transId2 << 32);
- if ((tRecTransId - tCurrTransId) != (Uint64)0){
-#ifdef VM_TRACE
- ndbout << "Dropping SCAN_TABCONF, wrong transid" << endl;
-#endif
- return -1;
- }
-
- const Uint8 scanStatus =
- ScanTabConf::getScanStatus(conf->requestInfo);
-
- if (scanStatus != 0) {
- theCompletionStatus = CompletedSuccess;
- theCommitStatus = Committed;
- theScanFinished = true;
- return 0;
- }
-
- // There can only be one SCANTABCONF
- assert(theNoOfSCANTABCONFRecv == 0);
- theNoOfSCANTABCONFRecv++;
-
- // Save a copy of the signal
- NdbApiSignal * tCopy = new NdbApiSignal(0);//getSignal();
- if (tCopy == NULL){
- setErrorCode(4000);
- return 2; // theWaiter.m_state = NO_WAIT
- }
- tCopy->copyFrom(aSignal);
- tCopy->next(NULL);
- theScanningOp->theSCAN_TABCONF_Recv = tCopy;
-
- return checkNextScanResultComplete();
-
-}
-
-/*****************************************************************************
- * int receiveSCAN_TABINFO(NdbApiSignal* aSignal)
- *
- * Receive SCAN_TABINFO
- *
- *****************************************************************************/
-int
-NdbConnection::receiveSCAN_TABINFO(NdbApiSignal* aSignal)
-{
- if (theStatus != Connected){
- //ndbout << "SCAN_TABINFO dropped, theStatus = " << theStatus << endl;
- return -1;
- }
- if (aSignal->getLength() != ScanTabInfo::SignalLength){
- //ndbout << "SCAN_TABINFO dropped, length = " << aSignal->getLength() << endl;
- return -1;
- }
-
- NdbApiSignal * tCopy = new NdbApiSignal(0);//getSignal();
- if (tCopy == NULL){
- setErrorCode(4000);
- return 2; // theWaiter.m_state = NO_WAIT
- }
- tCopy->copyFrom(aSignal);
- tCopy->next(NULL);
-
- // Put the signal last in list
- if (theScanningOp->theFirstSCAN_TABINFO_Recv == NULL)
- theScanningOp->theFirstSCAN_TABINFO_Recv = tCopy;
- else
- theScanningOp->theLastSCAN_TABINFO_Recv->next(tCopy);
- theScanningOp->theLastSCAN_TABINFO_Recv = tCopy;
-
- return checkNextScanResultComplete();
-}
-
-/******************************************************************************
- * int checkNextScanResultComplete(NdbApiSignal* aSignal)
- *
- * Remark Traverses all the lists that are associated with
- * this resultset and checks if all signals are there.
- * If all required signal are received return 0
- *
- *
- *****************************************************************************/
-int
-NdbConnection::checkNextScanResultComplete(){
-
- if (theNoOfSCANTABCONFRecv != 1) {
- return -1;
- }
-
- Uint32 tNoOfOpFetched = 0;
- theCurrentScanRec = NULL;
- thePreviousScanRec = NULL;
-
- const ScanTabConf * const conf =
- CAST_CONSTPTR(ScanTabConf, theScanningOp->theSCAN_TABCONF_Recv->getDataPtr());
- const Uint32 numOperations = ScanTabConf::getOperations(conf->requestInfo);
- Uint32 sigIndex = 0;
- NdbApiSignal* tSignal = theScanningOp->theFirstSCAN_TABINFO_Recv;
- while(tSignal != NULL){
- const ScanTabInfo * const info = CAST_CONSTPTR(ScanTabInfo, tSignal->getDataPtr());
- // Loop through the operations for this SCAN_TABINFO
- // tOpAndLength is allowed to be zero, this means no
- // TRANSID_AI signals where sent for this record
- // I.e getValue was called 0 times when defining scan
-
- // The max number of operations in each signal is 16
- Uint32 numOpsInSig = numOperations - sigIndex*16;
- if (numOpsInSig > 16)
- numOpsInSig = 16;
- for(Uint32 i = 0; i < numOpsInSig; i++){
- const Uint32 tOpAndLength = info->operLenAndIdx[i];
- const Uint32 tOpIndex = ScanTabInfo::getIdx(tOpAndLength);
- const Uint32 tOpLen = ScanTabInfo::getLen(tOpAndLength);
-
- assert(tOpIndex < 256);
- NdbScanReceiver* tScanRec =
- theScanningOp->theScanReceiversArray[tOpIndex];
- assert(tScanRec != NULL);
- if(tScanRec->isCompleted(tOpLen))
- tScanRec->setCompleted();
- else{
- return -1; // At least one receiver was not ready
- }
-
- // Build list of scan receivers
- if (theCurrentScanRec == NULL) {
- theCurrentScanRec = tScanRec;
- thePreviousScanRec = tScanRec;
- } else {
- thePreviousScanRec->next(tScanRec);
- thePreviousScanRec = tScanRec;
- }
- tNoOfOpFetched++;
+ const ScanTabConf * conf = CAST_CONSTPTR(ScanTabConf, aSignal->getDataPtr());
+ if(checkState_TransId(&conf->transId1)){
+
+ if (conf->requestInfo == ScanTabConf::EndOfData) {
+ theScanningOp->execCLOSE_SCAN_REP(0);
+ return 0;
}
- tSignal = tSignal->next();
- sigIndex++;
- }
-
- // Check number of operations fetched against value in SCANTAB_CONF
- if (tNoOfOpFetched != numOperations) {
- setErrorCode(4113);
- return 2; // theWaiter.m_state = NO_WAIT
+
+ int noComp = -1;
+ for(Uint32 i = 0; iint2void(ptrI);
+ assert(tPtr); // For now
+ NdbReceiver* tOp = theNdb->void2rec(tPtr);
+ if (tOp && tOp->checkMagicNumber()){
+ if(tOp->execSCANOPCONF(tcPtrI, totalLen, opCount)){
+ /**
+ *
+ */
+ noComp++;
+ theScanningOp->receiver_delivered(tOp);
+ } else if(info == ScanTabConf::EndOfData){
+ noComp++;
+ theScanningOp->receiver_completed(tOp);
+ }
+ }
+ }
+ return noComp;
}
- // All signals for this resultset recieved
- // release SCAN_TAB signals
- theNoOfSCANTABCONFRecv = 0;
- theScanningOp->releaseSignals();
-
- // We have received all operations with correct lengths.
- thePreviousScanRec = NULL;
- theNoOfOpFetched = tNoOfOpFetched;
- return 0;
+ return -1;
}
diff --git a/ndb/src/ndbapi/NdbCursorOperation.cpp b/ndb/src/ndbapi/NdbCursorOperation.cpp
index e4dd600c57f..a9f84c4c110 100644
--- a/ndb/src/ndbapi/NdbCursorOperation.cpp
+++ b/ndb/src/ndbapi/NdbCursorOperation.cpp
@@ -30,8 +30,6 @@
#include
NdbCursorOperation::NdbCursorOperation(Ndb* aNdb) :
- NdbOperation(aNdb),
- m_resultSet(0)
{
}
@@ -48,10 +46,6 @@ void NdbCursorOperation::cursInit()
NdbResultSet* NdbCursorOperation::getResultSet()
{
- if (!m_resultSet)
- m_resultSet = new NdbResultSet(this);
-
- return m_resultSet;
}
diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
index 89c4fb19399..0478bed3237 100644
--- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp
+++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
@@ -258,6 +258,7 @@ NdbTableImpl::init(){
m_indexType = NdbDictionary::Index::Undefined;
m_noOfKeys = 0;
+ m_fragmentCount = 0;
}
bool
@@ -276,11 +277,9 @@ NdbTableImpl::equal(const NdbTableImpl& obj) const
if(strcmp(m_internalName.c_str(), obj.m_internalName.c_str()) != 0){
return false;
}
-
if(m_fragmentType != obj.m_fragmentType){
return false;
}
-
if(m_columns.size() != obj.m_columns.size()){
return false;
}
@@ -319,6 +318,7 @@ NdbTableImpl::assign(const NdbTableImpl& org)
m_newExternalName.assign(org.m_newExternalName);
m_frm.assign(org.m_frm.get_data(), org.m_frm.length());
m_fragmentType = org.m_fragmentType;
+ m_fragmentCount = org.m_fragmentCount;
for(unsigned i = 0; iunlock_mutex();
// End of Protected area
if(m_waiter.m_state == NO_WAIT && m_error.code == 0){
@@ -1116,6 +1117,7 @@ NdbDictInterface::parseTableInfo(NdbTableImpl ** ret,
impl->m_kvalue = tableDesc.TableKValue;
impl->m_minLoadFactor = tableDesc.MinLoadFactor;
impl->m_maxLoadFactor = tableDesc.MaxLoadFactor;
+ impl->m_fragmentCount = tableDesc.FragmentCount;
impl->m_indexType = (NdbDictionary::Index::Type)
getApiConstant(tableDesc.TableType,
@@ -1199,6 +1201,8 @@ NdbDictInterface::parseTableInfo(NdbTableImpl ** ret,
it.next();
}
impl->m_noOfKeys = keyCount;
+ impl->m_keyLenInWords = keyInfoPos;
+
* ret = impl;
return 0;
}
@@ -2708,6 +2712,7 @@ NdbDictInterface::listObjects(NdbApiSignal* signal)
m_waiter.m_node = aNodeId;
m_waiter.m_state = WAIT_LIST_TABLES_CONF;
m_waiter.wait(WAITFOR_RESPONSE_TIMEOUT);
+ m_transporter->unlock_mutex();
// end protected
if (m_waiter.m_state == NO_WAIT && m_error.code == 0)
return 0;
diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.hpp b/ndb/src/ndbapi/NdbDictionaryImpl.hpp
index 3263a636a79..311d101f8f4 100644
--- a/ndb/src/ndbapi/NdbDictionaryImpl.hpp
+++ b/ndb/src/ndbapi/NdbDictionaryImpl.hpp
@@ -123,7 +123,9 @@ public:
int m_kvalue;
int m_minLoadFactor;
int m_maxLoadFactor;
-
+ int m_keyLenInWords;
+ int m_fragmentCount;
+
NdbDictionaryImpl * m_dictionary;
NdbIndexImpl * m_index;
NdbColumnImpl * getColumn(unsigned attrId);
diff --git a/ndb/src/ndbapi/NdbEventOperationImpl.cpp b/ndb/src/ndbapi/NdbEventOperationImpl.cpp
index acc726e28c5..efac193746c 100644
--- a/ndb/src/ndbapi/NdbEventOperationImpl.cpp
+++ b/ndb/src/ndbapi/NdbEventOperationImpl.cpp
@@ -167,7 +167,7 @@ NdbEventOperationImpl::getValue(const NdbColumnImpl *tAttrInfo, char *aValue, in
}
//theErrorLine++;
- tRecAttr->setUNDEFINED();
+ tRecAttr->setNULL();
// We want to keep the list sorted to make data insertion easier later
if (theFirstRecAttr == NULL) {
@@ -388,7 +388,7 @@ NdbEventOperationImpl::next(int *pOverrun)
while (tAttrId > tRecAttrId) {
//printf("[%u] %u %u [%u]\n", tAttrId, tDataSz, *aDataPtr, tRecAttrId);
- tWorkingRecAttr->setUNDEFINED();
+ tWorkingRecAttr->setNULL();
tWorkingRecAttr = tWorkingRecAttr->next();
if (tWorkingRecAttr == NULL)
break;
@@ -400,19 +400,16 @@ NdbEventOperationImpl::next(int *pOverrun)
//printf("[%u] %u %u [%u]\n", tAttrId, tDataSz, *aDataPtr, tRecAttrId);
if (tAttrId == tRecAttrId) {
- tWorkingRecAttr->setNotNULL();
if (!m_eventImpl->m_tableImpl->getColumn(tRecAttrId)->getPrimaryKey())
hasSomeData++;
//printf("set!\n");
- Uint32 *theRef = (Uint32*)tWorkingRecAttr->aRef();
- Uint32 *theEndRef = theRef + tDataSz;
- while (theRef < theEndRef)
- *theRef++ = *aDataPtr++;
+ tWorkingRecAttr->receive_data(aDataPtr, tDataSz);
// move forward, data has already moved forward
aAttrPtr++;
+ aDataPtr += tDataSz;
tWorkingRecAttr = tWorkingRecAttr->next();
} else {
// move only attr forward
@@ -424,7 +421,7 @@ NdbEventOperationImpl::next(int *pOverrun)
while (tWorkingRecAttr != NULL) {
tRecAttrId = tWorkingRecAttr->attrId();
//printf("set undefined [%u] %u %u [%u]\n", tAttrId, tDataSz, *aDataPtr, tRecAttrId);
- tWorkingRecAttr->setUNDEFINED();
+ tWorkingRecAttr->setNULL();
tWorkingRecAttr = tWorkingRecAttr->next();
}
@@ -437,7 +434,7 @@ NdbEventOperationImpl::next(int *pOverrun)
tDataSz = AttributeHeader(*aDataPtr).getDataSize();
aDataPtr++;
while (tAttrId > tRecAttrId) {
- tWorkingRecAttr->setUNDEFINED();
+ tWorkingRecAttr->setNULL();
tWorkingRecAttr = tWorkingRecAttr->next();
if (tWorkingRecAttr == NULL)
break;
@@ -446,16 +443,11 @@ NdbEventOperationImpl::next(int *pOverrun)
if (tWorkingRecAttr == NULL)
break;
if (tAttrId == tRecAttrId) {
- tWorkingRecAttr->setNotNULL();
-
if (!m_eventImpl->m_tableImpl->getColumn(tRecAttrId)->getPrimaryKey())
hasSomeData++;
- Uint32 *theRef = (Uint32*)tWorkingRecAttr->aRef();
- Uint32 *theEndRef = theRef + tDataSz;
- while (theRef < theEndRef)
- *theRef++ = *aDataPtr++;
-
+ tWorkingRecAttr->receive_data(aDataPtr, tDataSz);
+ aDataPtr += tDataSz;
// move forward, data+attr has already moved forward
tWorkingRecAttr = tWorkingRecAttr->next();
} else {
@@ -464,7 +456,7 @@ NdbEventOperationImpl::next(int *pOverrun)
}
}
while (tWorkingRecAttr != NULL) {
- tWorkingRecAttr->setUNDEFINED();
+ tWorkingRecAttr->setNULL();
tWorkingRecAttr = tWorkingRecAttr->next();
}
diff --git a/ndb/src/ndbapi/NdbImpl.hpp b/ndb/src/ndbapi/NdbImpl.hpp
index cd05335b337..1fb1969b589 100644
--- a/ndb/src/ndbapi/NdbImpl.hpp
+++ b/ndb/src/ndbapi/NdbImpl.hpp
@@ -35,6 +35,7 @@ public:
#include
#include
#include
+#include
#include
@@ -83,12 +84,13 @@ Ndb::void2rec_iop(void* val){
return (NdbIndexOperation*)(void2rec(val)->getOwner());
}
-inline
-NdbScanReceiver*
-Ndb::void2rec_srec(void* val){
- return (NdbScanReceiver*)(void2rec(val)->getOwner());
+inline
+NdbConnection *
+NdbReceiver::getTransaction(){
+ return ((NdbOperation*)m_owner)->theNdbCon;
}
+
inline
int
Ndb::checkInitState()
@@ -151,7 +153,6 @@ NdbWaiter::wait(int waitTime)
waitTime = maxTime - NdbTick_CurrentMillisecond();
}
}
- NdbMutex_Unlock((NdbMutex*)m_mutex);
}
inline
diff --git a/ndb/src/ndbapi/NdbIndexOperation.cpp b/ndb/src/ndbapi/NdbIndexOperation.cpp
index ee5491d72a8..5bab52e0e0f 100644
--- a/ndb/src/ndbapi/NdbIndexOperation.cpp
+++ b/ndb/src/ndbapi/NdbIndexOperation.cpp
@@ -52,7 +52,7 @@ NdbIndexOperation::NdbIndexOperation(Ndb* aNdb) :
/**
* Change receiver type
*/
- theReceiver.init(NdbReceiver::NDB_INDEX_OPERATION, this);
+ theReceiver.init(NdbReceiver::NDB_INDEX_OPERATION, this, false);
}
NdbIndexOperation::~NdbIndexOperation()
@@ -664,10 +664,8 @@ NdbIndexOperation::prepareSend(Uint32 aTC_ConnectPtr, Uint64 aTransactionId)
tSignal = tnextSignal;
} while (tSignal != NULL);
}//if
- NdbRecAttr* tRecAttrObject = theFirstRecAttr;
theStatus = WaitResponse;
- theCurrentRecAttr = tRecAttrObject;
-
+ theReceiver.prepareSend();
return 0;
}
diff --git a/ndb/src/ndbapi/NdbOperation.cpp b/ndb/src/ndbapi/NdbOperation.cpp
index ccbfa767542..1e1448bdf9a 100644
--- a/ndb/src/ndbapi/NdbOperation.cpp
+++ b/ndb/src/ndbapi/NdbOperation.cpp
@@ -54,7 +54,6 @@ NdbOperation::NdbOperation(Ndb* aNdb) :
//theTable(aTable),
theNdbCon(NULL),
theNext(NULL),
- theNextScanOp(NULL),
theTCREQ(NULL),
theFirstATTRINFO(NULL),
theCurrentATTRINFO(NULL),
@@ -62,8 +61,6 @@ NdbOperation::NdbOperation(Ndb* aNdb) :
theAI_LenInCurrAI(0),
theFirstKEYINFO(NULL),
theLastKEYINFO(NULL),
- theFirstRecAttr(NULL),
- theCurrentRecAttr(NULL),
theFirstLabel(NULL),
theLastLabel(NULL),
@@ -76,10 +73,6 @@ NdbOperation::NdbOperation(Ndb* aNdb) :
theNoOfLabels(0),
theNoOfSubroutines(0),
- theTotalRecAI_Len(0),
- theCurrRecAI_Len(0),
- theAI_ElementLen(0),
- theCurrElemPtr(NULL),
m_currentTable(NULL), //theTableId(0xFFFF),
m_accessTable(NULL), //theAccessTableId(0xFFFF),
//theSchemaVersion(0),
@@ -95,17 +88,9 @@ NdbOperation::NdbOperation(Ndb* aNdb) :
m_tcReqGSN(GSN_TCKEYREQ),
m_keyInfoGSN(GSN_KEYINFO),
m_attrInfoGSN(GSN_ATTRINFO),
- theParallelism(0),
- theScanReceiversArray(NULL),
- theSCAN_TABREQ(NULL),
- theFirstSCAN_TABINFO_Send(NULL),
- theLastSCAN_TABINFO_Send(NULL),
- theFirstSCAN_TABINFO_Recv(NULL),
- theLastSCAN_TABINFO_Recv(NULL),
- theSCAN_TABCONF_Recv(NULL),
theBoundATTRINFO(NULL)
{
- theReceiver.init(NdbReceiver::NDB_OPERATION, this);
+ theReceiver.init(NdbReceiver::NDB_OPERATION, this, false);
theError.code = 0;
}
/*****************************************************************************
@@ -165,7 +150,7 @@ NdbOperation::init(NdbTableImpl* tab, NdbConnection* myConnection){
theNdbCon = myConnection;
for (Uint32 i=0; iscanInfo = 0;
theKEYINFOptr = &tcKeyReq->keyInfo[0];
theATTRINFOptr = &tcKeyReq->attrInfo[0];
+ theReceiver.init(NdbReceiver::NDB_OPERATION, this, false);
return 0;
}
@@ -226,8 +207,6 @@ NdbOperation::release()
{
NdbApiSignal* tSignal;
NdbApiSignal* tSaveSignal;
- NdbRecAttr* tRecAttr;
- NdbRecAttr* tSaveRecAttr;
NdbBranch* tBranch;
NdbBranch* tSaveBranch;
NdbLabel* tLabel;
@@ -260,15 +239,6 @@ NdbOperation::release()
}
theFirstKEYINFO = NULL;
theLastKEYINFO = NULL;
- tRecAttr = theFirstRecAttr;
- while (tRecAttr != NULL)
- {
- tSaveRecAttr = tRecAttr;
- tRecAttr = tRecAttr->next();
- theNdb->releaseRecAttr(tSaveRecAttr);
- }
- theFirstRecAttr = NULL;
- theCurrentRecAttr = NULL;
if (theInterpretIndicator == 1)
{
tBranch = theFirstBranch;
@@ -308,19 +278,18 @@ NdbOperation::release()
}
theBoundATTRINFO = NULL;
}
- releaseScan();
}
NdbRecAttr*
NdbOperation::getValue(const char* anAttrName, char* aValue)
{
- return getValue(m_currentTable->getColumn(anAttrName), aValue);
+ return getValue_impl(m_currentTable->getColumn(anAttrName), aValue);
}
NdbRecAttr*
NdbOperation::getValue(Uint32 anAttrId, char* aValue)
{
- return getValue(m_currentTable->getColumn(anAttrId), aValue);
+ return getValue_impl(m_currentTable->getColumn(anAttrId), aValue);
}
int
@@ -416,16 +385,4 @@ NdbOperation::write_attr(Uint32 anAttrId, Uint32 RegDest)
return write_attr(m_currentTable->getColumn(anAttrId), RegDest);
}
-int
-NdbOperation::setBound(const char* anAttrName, int type, const void* aValue, Uint32 len)
-{
- return setBound(m_accessTable->getColumn(anAttrName), type, aValue, len);
-}
-
-int
-NdbOperation::setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len)
-{
- return setBound(m_accessTable->getColumn(anAttrId), type, aValue, len);
-}
-
diff --git a/ndb/src/ndbapi/NdbOperationDefine.cpp b/ndb/src/ndbapi/NdbOperationDefine.cpp
index 18f8b79d12e..a54081ae6dc 100644
--- a/ndb/src/ndbapi/NdbOperationDefine.cpp
+++ b/ndb/src/ndbapi/NdbOperationDefine.cpp
@@ -35,6 +35,7 @@
#include "NdbUtil.hpp"
#include "NdbOut.hpp"
#include "NdbImpl.hpp"
+#include
#include
@@ -262,30 +263,10 @@ NdbOperation::interpretedUpdateTuple()
theStatus = OperationDefined;
tNdbCon->theSimpleState = 0;
theOperationType = UpdateRequest;
- theInterpretIndicator = 1;
theAI_LenInCurrAI = 25;
theErrorLine = tErrorLine++;
- theTotalCurrAI_Len = 5;
- theSubroutineSize = 0;
- theInitialReadSize = 0;
- theInterpretedSize = 0;
- theFinalUpdateSize = 0;
- theFinalReadSize = 0;
-
- theFirstLabel = NULL;
- theLastLabel = NULL;
- theFirstBranch = NULL;
- theLastBranch = NULL;
-
- theFirstCall = NULL;
- theLastCall = NULL;
- theFirstSubroutine = NULL;
- theLastSubroutine = NULL;
-
- theNoOfLabels = 0;
- theNoOfSubroutines = 0;
-
+ initInterpreter();
return 0;
} else {
setErrorCode(4200);
@@ -305,30 +286,11 @@ NdbOperation::interpretedDeleteTuple()
theStatus = OperationDefined;
tNdbCon->theSimpleState = 0;
theOperationType = DeleteRequest;
- theInterpretIndicator = 1;
theErrorLine = tErrorLine++;
theAI_LenInCurrAI = 25;
- theTotalCurrAI_Len = 5;
- theSubroutineSize = 0;
- theInitialReadSize = 0;
- theInterpretedSize = 0;
- theFinalUpdateSize = 0;
- theFinalReadSize = 0;
-
- theFirstLabel = NULL;
- theLastLabel = NULL;
- theFirstBranch = NULL;
- theLastBranch = NULL;
-
- theFirstCall = NULL;
- theLastCall = NULL;
- theFirstSubroutine = NULL;
- theLastSubroutine = NULL;
-
- theNoOfLabels = 0;
- theNoOfSubroutines = 0;
+ initInterpreter();
return 0;
} else {
setErrorCode(4200);
@@ -348,14 +310,14 @@ NdbOperation::interpretedDeleteTuple()
* Remark: Define an attribute to retrieve in query.
*****************************************************************************/
NdbRecAttr*
-NdbOperation::getValue(const NdbColumnImpl* tAttrInfo, char* aValue)
+NdbOperation::getValue_impl(const NdbColumnImpl* tAttrInfo, char* aValue)
{
NdbRecAttr* tRecAttr;
if ((tAttrInfo != NULL) &&
(!tAttrInfo->m_indexOnly) &&
(theStatus != Init)){
if (theStatus == SetBound) {
- saveBoundATTRINFO();
+ ((NdbScanOperation*)this)->saveBoundATTRINFO();
theStatus = GetValue;
}
if (theStatus != GetValue) {
@@ -387,33 +349,15 @@ NdbOperation::getValue(const NdbColumnImpl* tAttrInfo, char* aValue)
// Insert Attribute Id into ATTRINFO part.
/************************************************************************
- * Get a Receive Attribute object and link it into the operation object.
- ************************************************************************/
- tRecAttr = theNdb->getRecAttr();
- if (tRecAttr != NULL) {
- if (theFirstRecAttr == NULL)
- theFirstRecAttr = tRecAttr;
- else
- theCurrentRecAttr->next(tRecAttr);
- theCurrentRecAttr = tRecAttr;
- tRecAttr->next(NULL);
-
- /**********************************************************************
- * Now set the attribute identity and the pointer to the data in
- * the RecAttr object
- * Also set attribute size, array size and attribute type
- ********************************************************************/
- if (tRecAttr->setup(tAttrInfo, aValue) == 0) {
- theErrorLine++;
- return tRecAttr;
- } else {
- setErrorCodeAbort(4000);
- return NULL;
- }
- } else {
+ * Get a Receive Attribute object and link it into the operation object.
+ ***********************************************************************/
+ if((tRecAttr = theReceiver.getValue(tAttrInfo, aValue)) != 0){
+ theErrorLine++;
+ return tRecAttr;
+ } else {
setErrorCodeAbort(4000);
return NULL;
- }//if getRecAttr failure
+ }
} else {
return NULL;
}//if insertATTRINFO failure
@@ -604,47 +548,6 @@ NdbOperation::setValue( const NdbColumnImpl* tAttrInfo,
return 0;
}//NdbOperation::setValue()
-/*
- * Define bound on index column in range scan.
- */
-int
-NdbOperation::setBound(const NdbColumnImpl* tAttrInfo, int type, const void* aValue, Uint32 len)
-{
- if (theOperationType == OpenRangeScanRequest &&
- theStatus == SetBound &&
- (0 <= type && type <= 4) &&
- aValue != NULL &&
- len <= 8000) {
- // bound type
- insertATTRINFO(type);
- // attribute header
- Uint32 sizeInBytes = tAttrInfo->m_attrSize * tAttrInfo->m_arraySize;
- if (len != sizeInBytes && (len != 0)) {
- setErrorCodeAbort(4209);
- return -1;
- }
- len = sizeInBytes;
- Uint32 tIndexAttrId = tAttrInfo->m_attrId;
- Uint32 sizeInWords = (len + 3) / 4;
- AttributeHeader ah(tIndexAttrId, sizeInWords);
- insertATTRINFO(ah.m_value);
- // attribute data
- if ((UintPtr(aValue) & 0x3) == 0 && (len & 0x3) == 0)
- insertATTRINFOloop((const Uint32*)aValue, sizeInWords);
- else {
- Uint32 temp[2000];
- memcpy(temp, aValue, len);
- while ((len & 0x3) != 0)
- ((char*)temp)[len++] = 0;
- insertATTRINFOloop(temp, sizeInWords);
- }
- return 0;
- } else {
- setErrorCodeAbort(4228); // XXX wrong code
- return -1;
- }
-}
-
/****************************************************************************
* int insertATTRINFO( Uint32 aData );
*
diff --git a/ndb/src/ndbapi/NdbOperationExec.cpp b/ndb/src/ndbapi/NdbOperationExec.cpp
index b2a6f99880c..9ae4f9f3cbd 100644
--- a/ndb/src/ndbapi/NdbOperationExec.cpp
+++ b/ndb/src/ndbapi/NdbOperationExec.cpp
@@ -46,83 +46,6 @@ Documentation:
#include
-/******************************************************************************
-int doSend()
-
-Return Value: Return >0 : send was succesful, returns number of signals sent
- Return -1: In all other case.
-Parameters: aProcessorId: Receiving processor node
-Remark: Sends the ATTRINFO signal(s)
-******************************************************************************/
-int
-NdbOperation::doSendScan(int aProcessorId)
-{
- Uint32 tSignalCount = 0;
- NdbApiSignal* tSignal;
-
- if (theInterpretIndicator != 1 ||
- (theOperationType != OpenScanRequest &&
- theOperationType != OpenRangeScanRequest)) {
- setErrorCodeAbort(4005);
- return -1;
- }
-
- assert(theSCAN_TABREQ != NULL);
- tSignal = theSCAN_TABREQ;
- if (tSignal->setSignal(GSN_SCAN_TABREQ) == -1) {
- setErrorCode(4001);
- return -1;
- }
- // Update the "attribute info length in words" in SCAN_TABREQ before
- // sending it. This could not be done in openScan because
- // we created the ATTRINFO signals after the SCAN_TABREQ signal.
- ScanTabReq * const scanTabReq = CAST_PTR(ScanTabReq, tSignal->getDataPtrSend());
- scanTabReq->attrLen = theTotalCurrAI_Len;
- if (theOperationType == OpenRangeScanRequest)
- scanTabReq->attrLen += theTotalBoundAI_Len;
- TransporterFacade *tp = TransporterFacade::instance();
- if (tp->sendSignal(tSignal, aProcessorId) == -1) {
- setErrorCode(4002);
- return -1;
- }
- tSignalCount++;
-
- tSignal = theFirstSCAN_TABINFO_Send;
- while (tSignal != NULL){
- if (tp->sendSignal(tSignal, aProcessorId)) {
- setErrorCode(4002);
- return -1;
- }
- tSignalCount++;
- tSignal = tSignal->next();
- }
-
- if (theOperationType == OpenRangeScanRequest) {
- // must have at least one signal since it contains attrLen for bounds
- assert(theBoundATTRINFO != NULL);
- tSignal = theBoundATTRINFO;
- while (tSignal != NULL) {
- if (tp->sendSignal(tSignal,aProcessorId) == -1){
- setErrorCode(4002);
- return -1;
- }
- tSignalCount++;
- tSignal = tSignal->next();
- }
- }
-
- tSignal = theFirstATTRINFO;
- while (tSignal != NULL) {
- if (tp->sendSignal(tSignal,aProcessorId) == -1){
- setErrorCode(4002);
- return -1;
- }
- tSignalCount++;
- tSignal = tSignal->next();
- }
- theStatus = WaitResponse;
- return tSignalCount;
-}//NdbOperation::doSendScan()
void
NdbOperation::setLastFlag(NdbApiSignal* signal, Uint32 lastFlag)
@@ -177,62 +100,6 @@ NdbOperation::doSend(int aNodeId, Uint32 lastFlag)
return tSignalCount;
}//NdbOperation::doSend()
-/***************************************************************************
-int prepareSendScan(Uint32 aTC_ConnectPtr,
- Uint64 aTransactionId)
-
-Return Value: Return 0 : preparation of send was succesful.
- Return -1: In all other case.
-Parameters: aTC_ConnectPtr: the Connect pointer to TC.
- aTransactionId: the Transaction identity of the transaction.
-Remark: Puts the the final data into ATTRINFO signal(s) after this
- we know the how many signal to send and their sizes
-***************************************************************************/
-int NdbOperation::prepareSendScan(Uint32 aTC_ConnectPtr,
- Uint64 aTransactionId){
-
- if (theInterpretIndicator != 1 ||
- (theOperationType != OpenScanRequest &&
- theOperationType != OpenRangeScanRequest)) {
- setErrorCodeAbort(4005);
- return -1;
- }
-
- if (theStatus == SetBound) {
- saveBoundATTRINFO();
- theStatus = GetValue;
- }
-
- theErrorLine = 0;
-
- // In preapareSendInterpreted we set the sizes (word 4-8) in the
- // first ATTRINFO signal.
- if (prepareSendInterpreted() == -1)
- return -1;
-
- const Uint32 transId1 = (Uint32) (aTransactionId & 0xFFFFFFFF);
- const Uint32 transId2 = (Uint32) (aTransactionId >> 32);
-
- if (theOperationType == OpenRangeScanRequest) {
- NdbApiSignal* tSignal = theBoundATTRINFO;
- do{
- tSignal->setData(aTC_ConnectPtr, 1);
- tSignal->setData(transId1, 2);
- tSignal->setData(transId2, 3);
- tSignal = tSignal->next();
- } while (tSignal != NULL);
- }
- theCurrentATTRINFO->setLength(theAI_LenInCurrAI);
- NdbApiSignal* tSignal = theFirstATTRINFO;
- do{
- tSignal->setData(aTC_ConnectPtr, 1);
- tSignal->setData(transId1, 2);
- tSignal->setData(transId2, 3);
- tSignal = tSignal->next();
- } while (tSignal != NULL);
- return 0;
-}
-
/***************************************************************************
int prepareSend(Uint32 aTC_ConnectPtr,
Uint64 aTransactionId)
@@ -457,6 +324,7 @@ NdbOperation::prepareSend(Uint32 aTC_ConnectPtr, Uint64 aTransId)
theTCREQ->setLength(tcKeyReq->getAIInTcKeyReq(tReqInfo) +
tAttrInfoIndex + TcKeyReq::StaticLength);
+
tAIDataPtr[0] = Tdata1;
tAIDataPtr[1] = Tdata2;
tAIDataPtr[2] = Tdata3;
@@ -479,9 +347,8 @@ NdbOperation::prepareSend(Uint32 aTC_ConnectPtr, Uint64 aTransId)
tSignal = tnextSignal;
} while (tSignal != NULL);
}//if
- NdbRecAttr* tRecAttrObject = theFirstRecAttr;
theStatus = WaitResponse;
- theCurrentRecAttr = tRecAttrObject;
+ theReceiver.prepareSend();
return 0;
}//NdbOperation::prepareSend()
@@ -648,71 +515,10 @@ NdbOperation::prepareSendInterpreted()
theFirstATTRINFO->setData(tFinalReadSize, 7);
theFirstATTRINFO->setData(tSubroutineSize, 8);
}//if
+ theReceiver.prepareSend();
return 0;
}//NdbOperation::prepareSendInterpreted()
-/***************************************************************************
-int TCOPCONF(int anAttrInfoLen)
-
-Return Value: Return 0 : send was succesful.
- Return -1: In all other case.
-Parameters: anAttrInfoLen: The length of the attribute information from TC.
-Remark: Handles the reception of the TC[KEY/INDX]CONF signal.
-***************************************************************************/
-void
-NdbOperation::TCOPCONF(Uint32 anAttrInfoLen)
-{
- Uint32 tCurrRecLen = theCurrRecAI_Len;
- if (theStatus == WaitResponse) {
- theTotalRecAI_Len = anAttrInfoLen;
- if (anAttrInfoLen == tCurrRecLen) {
- Uint32 tAI_ElemLen = theAI_ElementLen;
- NdbRecAttr* tCurrRecAttr = theCurrentRecAttr;
- theStatus = Finished;
-
- if ((tAI_ElemLen == 0) &&
- (tCurrRecAttr == NULL)) {
- NdbRecAttr* tRecAttr = theFirstRecAttr;
- while (tRecAttr != NULL) {
- if (tRecAttr->copyoutRequired()) // copy to application buffer
- tRecAttr->copyout();
- tRecAttr = tRecAttr->next();
- }
- theNdbCon->OpCompleteSuccess();
- return;
- } else if (tAI_ElemLen != 0) {
- setErrorCode(4213);
- theNdbCon->OpCompleteFailure();
- return;
- } else {
- setErrorCode(4214);
- theNdbCon->OpCompleteFailure();
- return;
- }//if
- } else if (anAttrInfoLen > tCurrRecLen) {
- return;
- } else {
- theStatus = Finished;
-
- if (theAI_ElementLen != 0) {
- setErrorCode(4213);
- theNdbCon->OpCompleteFailure();
- return;
- }//if
- if (theCurrentRecAttr != NULL) {
- setErrorCode(4214);
- theNdbCon->OpCompleteFailure();
- return;
- }//if
- theNdbCon->OpCompleteFailure();
- return;
- }//if
- } else {
- setErrorCode(4004);
- }//if
- return;
-}//NdbOperation::TCKEYOPCONF()
-
int
NdbOperation::checkState_TransId(NdbApiSignal* aSignal)
{
@@ -777,188 +583,13 @@ NdbOperation::receiveTCKEYREF( NdbApiSignal* aSignal)
}//NdbOperation::receiveTCKEYREF()
-/***************************************************************************
-int receiveREAD_CONF( NdbApiSignal* aSignal)
-
-Return Value: Return 0 : send was succesful.
- Return -1: In all other case.
-Parameters: aSignal: the signal object that contains the READCONF signal from TUP.
-Remark: Handles the reception of the READCONF signal.
-***************************************************************************/
-int
-NdbOperation::receiveREAD_CONF(const Uint32* aDataPtr, Uint32 aDataLength)
-{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tCondFlag = (Uint32)(theStatus - WaitResponse);
- Uint32 tTotLen = aDataPtr[3];
-
- tRecTransId = (Uint64)aDataPtr[1] + ((Uint64)aDataPtr[2] << 32);
- tCurrTransId = theNdbCon->getTransactionId();
- tCondFlag |= (Uint32)((tRecTransId - tCurrTransId) != (Uint64)0);
- tCondFlag |= (Uint32)(aDataLength < 4);
-
- if (tCondFlag == 0) {
- theTotalRecAI_Len = tTotLen;
- int tRetValue = receiveREAD_AI((Uint32*)&aDataPtr[4], (aDataLength - 4));
- if (theStatus == Finished) {
- return tRetValue;
- } else {
- theStatus = Finished;
- return theNdbCon->OpCompleteFailure();
- }//if
- }//if
-#ifdef NDB_NO_DROPPED_SIGNAL
- abort();
-#endif
- return -1;
-}//NdbOperation::receiveREAD_CONF()
-
-/***************************************************************************
-int receiveTRANSID_AI( NdbApiSignal* aSignal)
-
-Return Value: Return 0 : send was succesful.
- Return -1: In all other case.
-Parameters: aSignal: the signal object that contains the TRANSID_AI signal.
-Remark: Handles the reception of the TRANSID_AI signal.
-***************************************************************************/
-int
-NdbOperation::receiveTRANSID_AI(const Uint32* aDataPtr, Uint32 aDataLength)
-{
- Uint64 tRecTransId, tCurrTransId;
- Uint32 tCondFlag = (Uint32)(theStatus - WaitResponse);
-
- tRecTransId = (Uint64)aDataPtr[1] + ((Uint64)aDataPtr[2] << 32);
- tCurrTransId = theNdbCon->getTransactionId();
- tCondFlag |= (Uint32)((tRecTransId - tCurrTransId) != (Uint64)0);
- tCondFlag |= (Uint32)(aDataLength < 3);
-
- if (tCondFlag == 0) {
- return receiveREAD_AI((Uint32*)&aDataPtr[3], (aDataLength - 3));
- }//if
-#ifdef NDB_NO_DROPPED_SIGNAL
- abort();
-#endif
- return -1;
-}//NdbOperation::receiveTRANSID_AI()
-
-/***************************************************************************
-int receiveREAD_AI( NdbApiSignal* aSignal, int aLength, int aStartPos)
-
-Return Value: Return 0 : send was succesoccurredful.
- Return -1: In all other case.
-Parameters: aSignal: the signal object that contains the LEN_ATTRINFO11 signal.
- aLength:
- aStartPos:
-Remark: Handles the reception of the LEN_ATTRINFO11 signal.
-***************************************************************************/
-int
-NdbOperation::receiveREAD_AI(Uint32* aDataPtr, Uint32 aLength)
-{
-
- register Uint32 tAI_ElementLen = theAI_ElementLen;
- register Uint32* tCurrElemPtr = theCurrElemPtr;
- if (theError.code == 0) {
- // If inconsistency error occurred we will still continue
- // receiving signals since we need to know whether commit
- // has occurred.
-
- register Uint32 tData;
- for (register Uint32 i = 0; i < aLength ; i++, aDataPtr++)
- {
- // Code to receive Attribute Information
- tData = *aDataPtr;
- if (tAI_ElementLen != 0) {
- tAI_ElementLen--;
- *tCurrElemPtr = tData;
- tCurrElemPtr++;
- continue;
- } else {
- // Waiting for a new attribute element
- NdbRecAttr* tWorkingRecAttr;
-
- tWorkingRecAttr = theCurrentRecAttr;
- AttributeHeader ah(tData);
- const Uint32 tAttrId = ah.getAttributeId();
- const Uint32 tAttrSize = ah.getDataSize();
- if ((tWorkingRecAttr != NULL) &&
- (tWorkingRecAttr->attrId() == tAttrId)) {
- ;
- } else {
- setErrorCode(4211);
- break;
- }//if
- theCurrentRecAttr = tWorkingRecAttr->next();
- NdbColumnImpl * col = m_currentTable->getColumn(tAttrId);
- if (ah.isNULL()) {
- // Return a Null value from the NDB to the attribute.
- if(col != 0 && col->m_nullable) {
- tWorkingRecAttr->setNULL();
- tAI_ElementLen = 0;
- } else {
- setErrorCode(4212);
- break;
- }//if
- } else {
- // Return a value from the NDB to the attribute.
- tWorkingRecAttr->setNotNULL();
- const Uint32 sizeInBytes = col->m_attrSize * col->m_arraySize;
- const Uint32 sizeInWords = (sizeInBytes + 3) / 4;
- tAI_ElementLen = tAttrSize;
- tCurrElemPtr = (Uint32*)tWorkingRecAttr->aRef();
- if (sizeInWords == tAttrSize){
- continue;
- } else {
- setErrorCode(4201);
- break;
- }//if
- }//if
- }//if
- }//for
- }//if
- Uint32 tCurrRecLen = theCurrRecAI_Len;
- Uint32 tTotRecLen = theTotalRecAI_Len;
- theAI_ElementLen = tAI_ElementLen;
- theCurrElemPtr = tCurrElemPtr;
- tCurrRecLen = tCurrRecLen + aLength;
- theCurrRecAI_Len = tCurrRecLen; // Update Current Received AI Length
- if (tTotRecLen == tCurrRecLen){ // Operation completed
- NdbRecAttr* tCurrRecAttr = theCurrentRecAttr;
- theStatus = Finished;
-
- NdbConnection* tNdbCon = theNdbCon;
- if ((tAI_ElementLen == 0) &&
- (tCurrRecAttr == NULL)) {
- NdbRecAttr* tRecAttr = theFirstRecAttr;
- while (tRecAttr != NULL) {
- if (tRecAttr->copyoutRequired()) // copy to application buffer
- tRecAttr->copyout();
- tRecAttr = tRecAttr->next();
- }
- return tNdbCon->OpCompleteSuccess();
- } else if (tAI_ElementLen != 0) {
- setErrorCode(4213);
- return tNdbCon->OpCompleteFailure();
- } else {
- setErrorCode(4214);
- return tNdbCon->OpCompleteFailure();
- }//if
- }
- else if ((tCurrRecLen > tTotRecLen) &&
- (tTotRecLen > 0)) { /* == 0 if TCKEYCONF not yet received */
- setErrorCode(4215);
- theStatus = Finished;
-
- return theNdbCon->OpCompleteFailure();
- }//if
- return -1; // Continue waiting for more signals of this operation
-}//NdbOperation::receiveREAD_AI()
void
NdbOperation::handleFailedAI_ElemLen()
{
- NdbRecAttr* tRecAttr = theFirstRecAttr;
+ NdbRecAttr* tRecAttr = theReceiver.theFirstRecAttr;
while (tRecAttr != NULL) {
- tRecAttr->setUNDEFINED();
+ tRecAttr->setNULL();
tRecAttr = tRecAttr->next();
}//while
}//NdbOperation::handleFailedAI_ElemLen()
diff --git a/ndb/src/ndbapi/NdbOperationInt.cpp b/ndb/src/ndbapi/NdbOperationInt.cpp
index be23a1c274c..dda4eded59c 100644
--- a/ndb/src/ndbapi/NdbOperationInt.cpp
+++ b/ndb/src/ndbapi/NdbOperationInt.cpp
@@ -34,6 +34,7 @@ Adjust: 991029 UABRONM First version.
#include "AttrType.hpp"
#include "NdbUtil.hpp"
#include "Interpreter.hpp"
+#include
#ifdef VM_TRACE
#include
@@ -44,6 +45,31 @@ Adjust: 991029 UABRONM First version.
#define INT_DEBUG(x)
#endif
+void
+NdbOperation::initInterpreter(){
+ theFirstLabel = NULL;
+ theLastLabel = NULL;
+ theFirstBranch = NULL;
+ theLastBranch = NULL;
+
+ theFirstCall = NULL;
+ theLastCall = NULL;
+ theFirstSubroutine = NULL;
+ theLastSubroutine = NULL;
+
+ theNoOfLabels = 0;
+ theNoOfSubroutines = 0;
+
+ theSubroutineSize = 0;
+ theInitialReadSize = 0;
+ theInterpretedSize = 0;
+ theFinalUpdateSize = 0;
+ theFinalReadSize = 0;
+ theInterpretIndicator = 1;
+
+ theTotalCurrAI_Len = 5;
+}
+
int
NdbOperation::incCheck(const NdbColumnImpl* tNdbColumnImpl)
{
@@ -192,7 +218,7 @@ NdbOperation::initial_interpreterCheck()
{
if ((theInterpretIndicator == 1)) {
if (theStatus == SetBound) {
- saveBoundATTRINFO();
+ ((NdbScanOperation*)this)->saveBoundATTRINFO();
theStatus = GetValue;
}
if (theStatus == ExecInterpretedValue) {
diff --git a/ndb/src/ndbapi/NdbOperationScan.cpp b/ndb/src/ndbapi/NdbOperationScan.cpp
index df4f2421ec0..283eb591bdb 100644
--- a/ndb/src/ndbapi/NdbOperationScan.cpp
+++ b/ndb/src/ndbapi/NdbOperationScan.cpp
@@ -14,563 +14,3 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
-#include "NdbOperation.hpp"
-#include "NdbScanReceiver.hpp"
-
-#include
-#include
-#include
-#include
-
-
-/******************************************************************************
- * int openScanRead();
- *****************************************************************************/
-int
-NdbOperation::openScanRead(Uint32 aParallelism)
-{
- aParallelism = checkParallelism(aParallelism);
-
- if ((theNdbCon->theCommitStatus != Started) &&
- (theStatus != Init) &&
- (aParallelism == 0)) {
- setErrorCode(4200);
- return -1;
- }
- return openScan(aParallelism, false, false, false);
-}
-
-/****************************************************************************
- * int openScanExclusive();
- ****************************************************************************/
-int
-NdbOperation::openScanExclusive(Uint32 aParallelism)
-{
- aParallelism = checkParallelism(aParallelism);
-
- if ((theNdbCon->theCommitStatus != Started) &&
- (theStatus != Init) &&
- (aParallelism == 0)) {
- setErrorCode(4200);
- return -1;
- }
- return openScan(aParallelism, true, true, false);
-}
-
-/******************************************************************************
- * int openScanReadHoldLock();
- *****************************************************************************/
-int
-NdbOperation::openScanReadHoldLock(Uint32 aParallelism)
-{
- aParallelism = checkParallelism(aParallelism);
-
- if ((theNdbCon->theCommitStatus != Started) &&
- (theStatus != Init) &&
- (aParallelism == 0)) {
- setErrorCode(4200);
- return -1;
- }
- return openScan(aParallelism, false, true, false);
-}
-
-/******************************************************************************
- * int openScanReadCommitted();
- *****************************************************************************/
-int
-NdbOperation::openScanReadCommitted(Uint32 aParallelism)
-{
- aParallelism = checkParallelism(aParallelism);
-
- if ((theNdbCon->theCommitStatus != Started) &&
- (theStatus != Init) &&
- (aParallelism == 0)) {
- setErrorCode(4200);
- return -1;
- }
- return openScan(aParallelism, false, false, true);
-}
-
-/****************************************************************************
- * int checkParallelism();
- * Remark If the parallelism is set wrong the number of scan-operations
- * will not correspond to the number of TRANSID_AI signals returned
- * from NDB and the result will be a crash, therefore
- * we adjust it or return an error if the value is totally wrong.
- ****************************************************************************/
-int
-NdbOperation::checkParallelism(Uint32 aParallelism)
-{
- if (aParallelism == 0) {
- setErrorCodeAbort(4232);
- return 0;
- }
- if (aParallelism > 16) {
- if (aParallelism <= 240) {
-
- /**
- * If tscanConcurrency > 16 it must be a multiple of 16
- */
- if (((aParallelism >> 4) << 4) < aParallelism) {
- aParallelism = ((aParallelism >> 4) << 4) + 16;
- }//if
-
- /*---------------------------------------------------------------*/
- /* We cannot have a parallelism > 16 per node */
- /*---------------------------------------------------------------*/
- if ((aParallelism / theNdb->theNoOfDBnodes) > 16) {
- aParallelism = theNdb->theNoOfDBnodes * 16;
- }//if
-
- } else {
- setErrorCodeAbort(4232);
- aParallelism = 0;
- }//if
- }//if
- return aParallelism;
-}//NdbOperation::checkParallelism()
-
-/**********************************************************************
- * int openScan();
- *************************************************************************/
-int
-NdbOperation::openScan(Uint32 aParallelism,
- bool lockMode, bool lockHoldMode, bool readCommitted)
-{
- aParallelism = checkParallelism(aParallelism);
- if(aParallelism == 0){
- return 0;
- }
- NdbScanReceiver* tScanRec;
- // It is only possible to call openScan if
- // 1. this transcation don't already contain another scan operation
- // 2. this transaction don't already contain other operations
- // 3. theScanOp contains a NdbScanOperation
- if (theNdbCon->theScanningOp != NULL){
- setErrorCode(4605);
- return -1;
- }
-
- if ((theNdbCon->theFirstOpInList != this) ||
- (theNdbCon->theLastOpInList != this)) {
- setErrorCode(4603);
- return -1;
- }
- theNdbCon->theScanningOp = this;
-
- initScan();
- theParallelism = aParallelism;
-
- // If the scan is on ordered index then it is a range scan
- 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);
- // Modify operation state
- theStatus = SetBound;
- theOperationType = OpenRangeScanRequest;
- }
-
- theScanReceiversArray = new NdbScanReceiver* [aParallelism];
- if (theScanReceiversArray == NULL){
- setErrorCodeAbort(4000);
- return -1;
- }
-
- for (Uint32 i = 0; i < aParallelism; i ++) {
- tScanRec = theNdb->getNdbScanRec();
- if (tScanRec == NULL) {
- setErrorCodeAbort(4000);
- return -1;
- }//if
- tScanRec->init(this, lockMode);
- theScanReceiversArray[i] = tScanRec;
- }
-
- theSCAN_TABREQ = theNdb->getSignal();
- if (theSCAN_TABREQ == NULL) {
- setErrorCodeAbort(4000);
- return -1;
- }//if
- ScanTabReq * const scanTabReq = CAST_PTR(ScanTabReq, theSCAN_TABREQ->getDataPtrSend());
- scanTabReq->apiConnectPtr = theNdbCon->theTCConPtr;
- scanTabReq->tableId = m_accessTable->m_tableId;
- scanTabReq->tableSchemaVersion = m_accessTable->m_version;
- scanTabReq->storedProcId = 0xFFFF;
- scanTabReq->buddyConPtr = theNdbCon->theBuddyConPtr;
-
- Uint32 reqInfo = 0;
- ScanTabReq::setParallelism(reqInfo, aParallelism);
- ScanTabReq::setLockMode(reqInfo, lockMode);
- ScanTabReq::setHoldLockFlag(reqInfo, lockHoldMode);
- ScanTabReq::setReadCommittedFlag(reqInfo, readCommitted);
- if (theOperationType == OpenRangeScanRequest)
- ScanTabReq::setRangeScanFlag(reqInfo, true);
- scanTabReq->requestInfo = reqInfo;
-
- Uint64 transId = theNdbCon->getTransactionId();
- scanTabReq->transId1 = (Uint32) transId;
- scanTabReq->transId2 = (Uint32) (transId >> 32);
-
- for (Uint32 i = 0; i < 16 && i < aParallelism ; i++) {
- scanTabReq->apiOperationPtr[i] = theScanReceiversArray[i]->ptr2int();
- }//for
-
- // Create one additional SCAN_TABINFO for each
- // 16 of parallelism
- NdbApiSignal* tSignal;
- Uint32 tParallelism = aParallelism;
- while (tParallelism > 16) {
- tSignal = theNdb->getSignal();
- if (tSignal == NULL) {
- setErrorCodeAbort(4000);
- return -1;
- }//if
- if (tSignal->setSignal(GSN_SCAN_TABINFO) == -1) {
- setErrorCode(4001);
- return -1;
- }
- tSignal->next(theFirstSCAN_TABINFO_Send);
- theFirstSCAN_TABINFO_Send = tSignal;
- tParallelism -= 16;
- }//while
-
- // Format all SCAN_TABINFO signals
- tParallelism = 16;
- tSignal = theFirstSCAN_TABINFO_Send;
- while (tSignal != NULL) {
- tSignal->setData(theNdbCon->theTCConPtr, 1);
- for (int i = 0; i < 16 ; i++) {
- tSignal->setData(theScanReceiversArray[i + tParallelism]->ptr2int(), i + 2);
- }//for
- tSignal = tSignal->next();
- tParallelism += 16;
- }//while
-
- getFirstATTRINFOScan();
- return 0;
-}//NdbScanOperation::openScan()
-
-/*****************************************************************************
- * int getFirstATTRINFOScan( U_int32 aData )
- *
- * Return Value: Return 0: Successful
- * Return -1: All other cases
- * Parameters: None: Only allocate the first signal.
- * Remark: When a scan is defined we need to use this method instead
- * of insertATTRINFO for the first signal.
- * This is because we need not to mess up the code in
- * insertATTRINFO with if statements since we are not
- * interested in the TCKEYREQ signal.
- *****************************************************************************/
-int
-NdbOperation::getFirstATTRINFOScan()
-{
- NdbApiSignal* tSignal;
-
- tSignal = theNdb->getSignal();
- if (tSignal == NULL){
- setErrorCodeAbort(4000);
- return -1;
- }
- tSignal->setSignal(m_attrInfoGSN);
- theAI_LenInCurrAI = 8;
- theATTRINFOptr = &tSignal->getDataPtrSend()[8];
- theFirstATTRINFO = tSignal;
- theCurrentATTRINFO = tSignal;
- theCurrentATTRINFO->next(NULL);
- return 0;
-}
-
-/*
- * After setBound() are done, move the accumulated ATTRINFO signals to
- * a separate list. Then continue with normal scan.
- */
-int
-NdbOperation::saveBoundATTRINFO()
-{
- theCurrentATTRINFO->setLength(theAI_LenInCurrAI);
- theBoundATTRINFO = theFirstATTRINFO;
- theTotalBoundAI_Len = theTotalCurrAI_Len;
- theTotalCurrAI_Len = 5;
- theBoundATTRINFO->setData(theTotalBoundAI_Len, 4);
- theBoundATTRINFO->setData(0, 5);
- theBoundATTRINFO->setData(0, 6);
- theBoundATTRINFO->setData(0, 7);
- theBoundATTRINFO->setData(0, 8);
- theStatus = GetValue;
- return getFirstATTRINFOScan();
-}
-
-/*****************************************************************************
- * void releaseScan()
- *
- * Return Value No return value.
- * Parameters: No parameters.
- * Remark: Release objects after scanning.
- *****************************************************************************/
-void
-NdbOperation::releaseScan()
-{
- NdbScanReceiver* tScanRec;
- TransporterFacade::instance()->lock_mutex();
- for (Uint32 i = 0; i < theParallelism && theScanReceiversArray != NULL; i++) {
- tScanRec = theScanReceiversArray[i];
- if (tScanRec != NULL) {
- tScanRec->release();
- tScanRec->next(NULL);
- }
- }
- TransporterFacade::instance()->unlock_mutex();
- releaseSignals();
-
- if (theScanReceiversArray != NULL) {
- for (Uint32 i = 0; i < theParallelism; i++) {
- NdbScanReceiver* tScanRec;
- tScanRec = theScanReceiversArray[i];
- if (tScanRec != NULL) {
- theNdb->releaseNdbScanRec(tScanRec);
- theScanReceiversArray[i] = NULL;
- }
- }
-
- delete [] theScanReceiversArray;
- }//if
- theScanReceiversArray = NULL;
-
- if (theSCAN_TABREQ != NULL){
- theNdb->releaseSignal(theSCAN_TABREQ);
- theSCAN_TABREQ = NULL;
- }
-}
-
-void NdbOperation::releaseSignals(){
- theNdb->releaseSignalsInList(&theFirstSCAN_TABINFO_Send);
- theFirstSCAN_TABINFO_Send = NULL;
- theLastSCAN_TABINFO_Send = NULL;
- // theNdb->releaseSignalsInList(&theFirstSCAN_TABINFO_Recv);
-
- while(theFirstSCAN_TABINFO_Recv != NULL){
- NdbApiSignal* tmp = theFirstSCAN_TABINFO_Recv;
- theFirstSCAN_TABINFO_Recv = tmp->next();
- delete tmp;
- }
- theFirstSCAN_TABINFO_Recv = NULL;
- theLastSCAN_TABINFO_Recv = NULL;
- if (theSCAN_TABCONF_Recv != NULL){
- // theNdb->releaseSignal(theSCAN_TABCONF_Recv);
- delete theSCAN_TABCONF_Recv;
- theSCAN_TABCONF_Recv = NULL;
- }
-}
-
-
-void NdbOperation::prepareNextScanResult(){
- NdbScanReceiver* tScanRec;
- for (Uint32 i = 0; i < theParallelism; i++) {
- tScanRec = theScanReceiversArray[i];
- assert(tScanRec != NULL);
- tScanRec->prepareNextScanResult();
- tScanRec->next(NULL);
- }
- releaseSignals();
-}
-
-/******************************************************************************
- * void initScan();
- *
- * Return Value: Return 0 : init was successful.
- * Return -1: In all other case.
- * Remark: Initiates operation record after allocation.
- *****************************************************************************/
-void
-NdbOperation::initScan()
-{
- theTotalRecAI_Len = 0;
- theCurrRecAI_Len = 0;
- theStatus = GetValue;
- theOperationType = OpenScanRequest;
- theCurrentRecAttr = theFirstRecAttr;
- theScanInfo = 0;
- theMagicNumber = 0xABCDEF01;
- theTotalCurrAI_Len = 5;
-
- theFirstLabel = NULL;
- theLastLabel = NULL;
- theFirstBranch = NULL;
- theLastBranch = NULL;
-
- theFirstCall = NULL;
- theLastCall = NULL;
- theFirstSubroutine = NULL;
- theLastSubroutine = NULL;
-
- theNoOfLabels = 0;
- theNoOfSubroutines = 0;
-
- theSubroutineSize = 0;
- theInitialReadSize = 0;
- theInterpretedSize = 0;
- theFinalUpdateSize = 0;
- theFinalReadSize = 0;
- theInterpretIndicator = 1;
-
-
- theFirstSCAN_TABINFO_Send = NULL;
- theLastSCAN_TABINFO_Send = NULL;
- theFirstSCAN_TABINFO_Recv = NULL;
- theLastSCAN_TABINFO_Recv = NULL;
- theSCAN_TABCONF_Recv = NULL;
-
- theScanReceiversArray = NULL;
-
- theTotalBoundAI_Len = 0;
- theBoundATTRINFO = NULL;
- return;
-}
-
-NdbOperation* NdbOperation::takeOverForDelete(NdbConnection* updateTrans){
- return takeOverScanOp(DeleteRequest, updateTrans);
-}
-
-NdbOperation* NdbOperation::takeOverForUpdate(NdbConnection* updateTrans){
- return takeOverScanOp(UpdateRequest, updateTrans);
-}
-/******************************************************************************
- * NdbOperation* takeOverScanOp(NdbConnection* updateTrans);
- *
- * Parameters: The update transactions NdbConnection pointer.
- * Return Value: A reference to the transferred operation object
- * or NULL if no success.
- * Remark: Take over the scanning transactions NdbOperation
- * object for a tuple to an update transaction,
- * which is the last operation read in nextScanResult()
- * (theNdbCon->thePreviousScanRec)
- *
- * FUTURE IMPLEMENTATION: (This note was moved from header file.)
- * In the future, it will even be possible to transfer
- * to a NdbConnection on another Ndb-object.
- * In this case the receiving NdbConnection-object must call
- * a method receiveOpFromScan to actually receive the information.
- * This means that the updating transactions can be placed
- * in separate threads and thus increasing the parallelism during
- * the scan process.
- *****************************************************************************/
-NdbOperation*
-NdbOperation::takeOverScanOp(OperationType opType, NdbConnection* updateTrans)
-{
- if (opType != UpdateRequest && opType != DeleteRequest) {
- setErrorCode(4604);
- return NULL;
- }
-
- const NdbScanReceiver* tScanRec = theNdbCon->thePreviousScanRec;
- if (tScanRec == NULL){
- // No operation read by nextScanResult
- setErrorCode(4609);
- return NULL;
- }
-
- if (tScanRec->theFirstKEYINFO20_Recv == NULL){
- // No KEYINFO20 received
- setErrorCode(4608);
- return NULL;
- }
-
- NdbOperation * newOp = updateTrans->getNdbOperation(m_currentTable);
- if (newOp == NULL){
- return NULL;
- }
-
- /**
- * Copy and caclulate attributes from the scanned operation to the
- * new operation
- */
- const KeyInfo20 * const firstKeyInfo20 =
- CAST_CONSTPTR(KeyInfo20, tScanRec->theFirstKEYINFO20_Recv->getDataPtr());
- const Uint32 totalKeyLen = firstKeyInfo20->keyLen;
- newOp->theTupKeyLen = totalKeyLen;
-
- newOp->theOperationType = opType;
- if (opType == DeleteRequest) {
- newOp->theStatus = GetValue;
- } else {
- newOp->theStatus = SetValue;
- }
- const Uint32 tScanInfo = firstKeyInfo20->scanInfo_Node & 0xFFFF;
- const Uint32 tTakeOverNode = firstKeyInfo20->scanInfo_Node >> 16;
- {
- UintR scanInfo = 0;
- TcKeyReq::setTakeOverScanFlag(scanInfo, 1);
- TcKeyReq::setTakeOverScanNode(scanInfo, tTakeOverNode);
- TcKeyReq::setTakeOverScanInfo(scanInfo, tScanInfo);
- newOp->theScanInfo = scanInfo;
- }
-
- /**
- * Copy received KEYINFO20 signals into TCKEYREQ and KEYINFO signals
- * put them in list of the new op
- */
- TcKeyReq * const tcKeyReq =
- CAST_PTR(TcKeyReq, newOp->theTCREQ->getDataPtrSend());
-
- // Copy the first 8 words of key info from KEYINF20 into TCKEYREQ
- for (Uint32 i = 0; i < TcKeyReq::MaxKeyInfo; i++) {
- tcKeyReq->keyInfo[i] = firstKeyInfo20->keyData[i];
- }
- if (totalKeyLen > TcKeyReq::MaxKeyInfo) {
-
- Uint32 keyWordsCopied = TcKeyReq::MaxKeyInfo;
-
- // Create KEYINFO signals in newOp
- for (Uint32 i = keyWordsCopied; i < totalKeyLen; i += KeyInfo::DataLength){
- NdbApiSignal* tSignal = theNdb->getSignal();
- if (tSignal == NULL){
- setErrorCodeAbort(4000);
- return NULL;
- }
- if (tSignal->setSignal(GSN_KEYINFO) == -1){
- setErrorCodeAbort(4001);
- return NULL;
- }
- tSignal->next(newOp->theFirstKEYINFO);
- newOp->theFirstKEYINFO = tSignal;
- }
-
- // Init pointers to KEYINFO20 signal
- NdbApiSignal* currKeyInfo20 = tScanRec->theFirstKEYINFO20_Recv;
- const KeyInfo20 * keyInfo20 =
- CAST_CONSTPTR(KeyInfo20, currKeyInfo20->getDataPtr());
- Uint32 posInKeyInfo20 = keyWordsCopied;
-
- // Init pointers to KEYINFO signal
- NdbApiSignal* currKeyInfo = newOp->theFirstKEYINFO;
- KeyInfo * keyInfo = CAST_PTR(KeyInfo, currKeyInfo->getDataPtrSend());
- Uint32 posInKeyInfo = 0;
-
- // Copy from KEYINFO20 to KEYINFO
- while(keyWordsCopied < totalKeyLen){
- keyInfo->keyData[posInKeyInfo++] = keyInfo20->keyData[posInKeyInfo20++];
- keyWordsCopied++;
- if(keyWordsCopied >= totalKeyLen)
- break;
- if (posInKeyInfo20 >=
- (currKeyInfo20->getLength()-KeyInfo20::HeaderLength)){
- currKeyInfo20 = currKeyInfo20->next();
- keyInfo20 = CAST_CONSTPTR(KeyInfo20, currKeyInfo20->getDataPtr());
- posInKeyInfo20 = 0;
- }
- if (posInKeyInfo >= KeyInfo::DataLength){
- currKeyInfo = currKeyInfo->next();
- keyInfo = CAST_PTR(KeyInfo, currKeyInfo->getDataPtrSend());
- posInKeyInfo = 0;
- }
- }
- }
-
- return newOp;
-}
-
-
-
diff --git a/ndb/src/ndbapi/NdbRecAttr.cpp b/ndb/src/ndbapi/NdbRecAttr.cpp
index 0f7baeac4f5..18ce59745d0 100644
--- a/ndb/src/ndbapi/NdbRecAttr.cpp
+++ b/ndb/src/ndbapi/NdbRecAttr.cpp
@@ -57,6 +57,8 @@ NdbRecAttr::setup(const NdbColumnImpl* anAttrInfo, char* aValue)
theAttrSize = tAttrSize;
theArraySize = tArraySize;
theValue = aValue;
+ theNULLind = 0;
+ m_nullable = anAttrInfo->m_nullable;
// check alignment to signal data
// a future version could check alignment per data type as well
@@ -124,3 +126,19 @@ NdbRecAttr::clone() const {
memcpy(ret->theRef, theRef, n);
return ret;
}
+
+bool
+NdbRecAttr::receive_data(const Uint32 * data, Uint32 sz){
+ const Uint32 n = (theAttrSize * theArraySize + 3) >> 2;
+ if(n == sz){
+ if(!copyoutRequired())
+ memcpy(theRef, data, 4 * sz);
+ else
+ memcpy(theValue, data, theAttrSize * theArraySize);
+ return true;
+ } else if(sz == 0){
+ setNULL();
+ return true;
+ }
+ return false;
+}
diff --git a/ndb/src/ndbapi/NdbReceiver.cpp b/ndb/src/ndbapi/NdbReceiver.cpp
index 4c461698a4a..7a538de3d7c 100644
--- a/ndb/src/ndbapi/NdbReceiver.cpp
+++ b/ndb/src/ndbapi/NdbReceiver.cpp
@@ -16,6 +16,10 @@
#include "NdbImpl.hpp"
#include
+#include "NdbDictionaryImpl.hpp"
+#include
+#include
+#include
NdbReceiver::NdbReceiver(Ndb *aNdb) :
theMagicNumber(0),
@@ -24,10 +28,11 @@ NdbReceiver::NdbReceiver(Ndb *aNdb) :
m_type(NDB_UNINITIALIZED),
m_owner(0)
{
+ theCurrentRecAttr = theFirstRecAttr = 0;
}
void
-NdbReceiver::init(ReceiverType type, void* owner)
+NdbReceiver::init(ReceiverType type, void* owner, bool keyInfo)
{
theMagicNumber = 0x11223344;
m_type = type;
@@ -36,6 +41,24 @@ NdbReceiver::init(ReceiverType type, void* owner)
if (m_ndb)
m_id = m_ndb->theNdbObjectIdMap->map(this);
}
+
+ theFirstRecAttr = NULL;
+ theCurrentRecAttr = NULL;
+ m_key_info = (keyInfo ? 1 : 0);
+ m_defined_rows = 0;
+}
+
+void
+NdbReceiver::release(){
+ NdbRecAttr* tRecAttr = theFirstRecAttr;
+ while (tRecAttr != NULL)
+ {
+ NdbRecAttr* tSaveRecAttr = tRecAttr;
+ tRecAttr = tRecAttr->next();
+ m_ndb->releaseRecAttr(tSaveRecAttr);
+ }
+ theFirstRecAttr = NULL;
+ theCurrentRecAttr = NULL;
}
NdbReceiver::~NdbReceiver()
@@ -44,3 +67,150 @@ NdbReceiver::~NdbReceiver()
m_ndb->theNdbObjectIdMap->unmap(m_id, this);
}
}
+
+NdbRecAttr *
+NdbReceiver::getValue(const NdbColumnImpl* tAttrInfo, char * user_dst_ptr){
+ NdbRecAttr* tRecAttr = m_ndb->getRecAttr();
+ if(tRecAttr && !tRecAttr->setup(tAttrInfo, user_dst_ptr)){
+ if (theFirstRecAttr == NULL)
+ theFirstRecAttr = tRecAttr;
+ else
+ theCurrentRecAttr->next(tRecAttr);
+ theCurrentRecAttr = tRecAttr;
+ tRecAttr->next(NULL);
+ return tRecAttr;
+ }
+ if(tRecAttr){
+ m_ndb->releaseRecAttr(tRecAttr);
+ }
+ return 0;
+}
+
+#define KEY_ATTR_ID (~0)
+
+void
+NdbReceiver::do_get_value(NdbReceiver * org, Uint32 rows, Uint32 key_size){
+ m_defined_rows = rows;
+ m_rows = new NdbRecAttr*[rows + 1]; m_rows[rows] = 0;
+
+ NdbColumnImpl key;
+ if(key_size){
+ key.m_attrId = KEY_ATTR_ID;
+ key.m_arraySize = key_size+1;
+ key.m_attrSize = 4;
+ key.m_nullable = true; // So that receive works w.r.t KEYINFO20
+ }
+
+ for(Uint32 i = 0; itheFirstRecAttr;
+ while(tRecAttr != 0){
+ if(getValue(&NdbColumnImpl::getImpl(*tRecAttr->m_column), (char*)0))
+ tRecAttr = tRecAttr->next();
+ else
+ break;
+ }
+
+ if(tRecAttr){
+ abort();
+ return ;// -1;
+ }
+
+ // Store first recAttr for each row in m_rows[i]
+ if(prev){
+ m_rows[i] = prev->next();
+ } else {
+ m_rows[i] = theFirstRecAttr;
+ }
+ }
+
+ prepareSend();
+ return ; //0;
+}
+
+void
+NdbReceiver::copyout(NdbReceiver & dstRec){
+ NdbRecAttr* src = m_rows[m_current_row++];
+ NdbRecAttr* dst = dstRec.theFirstRecAttr;
+ Uint32 tmp = m_key_info;
+ if(tmp > 0){
+ src = src->next();
+ }
+
+ while(dst){
+ Uint32 len = ((src->theAttrSize * src->theArraySize)+3)/4;
+ dst->receive_data((Uint32*)src->aRef(), len);
+ src = src->next();
+ dst = dst->next();
+ }
+}
+
+int
+NdbReceiver::execTRANSID_AI(const Uint32* aDataPtr, Uint32 aLength)
+{
+ bool ok = true;
+ NdbRecAttr* currRecAttr = theCurrentRecAttr;
+ NdbRecAttr* prevRecAttr = currRecAttr;
+
+ for (Uint32 used = 0; used < aLength ; used++){
+ AttributeHeader ah(* aDataPtr++);
+ const Uint32 tAttrId = ah.getAttributeId();
+ const Uint32 tAttrSize = ah.getDataSize();
+
+ /**
+ * Set all results to NULL if not found...
+ */
+ while(currRecAttr && currRecAttr->attrId() != tAttrId){
+ ok &= currRecAttr->setNULL();
+ prevRecAttr = currRecAttr;
+ currRecAttr = currRecAttr->next();
+ }
+
+ if(ok && currRecAttr && currRecAttr->receive_data(aDataPtr, tAttrSize)){
+ used += tAttrSize;
+ aDataPtr += tAttrSize;
+ prevRecAttr = currRecAttr;
+ currRecAttr = currRecAttr->next();
+ } else {
+ ndbout_c("%p: ok: %d tAttrId: %d currRecAttr: %p",
+ this,ok, tAttrId, currRecAttr);
+ abort();
+ return -1;
+ }
+ }
+
+ theCurrentRecAttr = currRecAttr;
+
+ /**
+ * Update m_received_result_length
+ */
+ Uint32 tmp = m_received_result_length + aLength;
+ m_received_result_length = tmp;
+
+ return (tmp == m_expected_result_length ? 1 : 0);
+}
+
+int
+NdbReceiver::execKEYINFO20(Uint32 info, const Uint32* aDataPtr, Uint32 aLength)
+{
+ NdbRecAttr* currRecAttr = m_rows[m_current_row++];
+ assert(currRecAttr->attrId() == KEY_ATTR_ID);
+ currRecAttr->receive_data(aDataPtr, aLength + 1);
+
+ /**
+ * Save scanInfo in the end of keyinfo
+ */
+ ((Uint32*)currRecAttr->aRef())[aLength] = info;
+
+ Uint32 tmp = m_received_result_length + aLength;
+ m_received_result_length = tmp;
+
+ return (tmp == m_expected_result_length ? 1 : 0);
+}
diff --git a/ndb/src/ndbapi/NdbResultSet.cpp b/ndb/src/ndbapi/NdbResultSet.cpp
index 8397d5eef91..07c8972b4cb 100644
--- a/ndb/src/ndbapi/NdbResultSet.cpp
+++ b/ndb/src/ndbapi/NdbResultSet.cpp
@@ -30,7 +30,7 @@
#include
#include
-NdbResultSet::NdbResultSet(NdbCursorOperation *owner)
+NdbResultSet::NdbResultSet(NdbScanOperation *owner)
: m_operation(owner)
{
}
@@ -55,46 +55,21 @@ void NdbResultSet::close()
NdbOperation*
NdbResultSet::updateTuple(){
- if(m_operation->cursorType() != NdbCursorOperation::ScanCursor){
- m_operation->setErrorCode(4003);
- return 0;
- }
-
- NdbScanOperation * op = (NdbScanOperation*)(m_operation);
- return op->takeOverScanOp(UpdateRequest, op->m_transConnection);
+ return updateTuple(m_operation->m_transConnection);
}
NdbOperation*
NdbResultSet::updateTuple(NdbConnection* takeOverTrans){
- if(m_operation->cursorType() != NdbCursorOperation::ScanCursor){
- m_operation->setErrorCode(4003);
- return 0;
- }
-
return m_operation->takeOverScanOp(UpdateRequest, takeOverTrans);
}
int
NdbResultSet::deleteTuple(){
- if(m_operation->cursorType() != NdbCursorOperation::ScanCursor){
- m_operation->setErrorCode(4003);
- return 0;
- }
-
- NdbScanOperation * op = (NdbScanOperation*)(m_operation);
- void * res = op->takeOverScanOp(DeleteRequest, op->m_transConnection);
- if(res == 0)
- return -1;
- return 0;
+ return deleteTuple(m_operation->m_transConnection);
}
int
NdbResultSet::deleteTuple(NdbConnection * takeOverTrans){
- if(m_operation->cursorType() != NdbCursorOperation::ScanCursor){
- m_operation->setErrorCode(4003);
- return 0;
- }
-
void * res = m_operation->takeOverScanOp(DeleteRequest, takeOverTrans);
if(res == 0)
return -1;
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index ca2c4590017..8a3d041b0d7 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -26,36 +26,57 @@
* Adjust: 2002-04-01 UABMASD First version.
****************************************************************************/
-#include
#include
#include
+#include
#include
#include
#include "NdbApiSignal.hpp"
#include
#include "NdbDictionaryImpl.hpp"
+#include
+#include
+
+#include
+#include
+
+#include
+#include
+#include
+
NdbScanOperation::NdbScanOperation(Ndb* aNdb) :
- NdbCursorOperation(aNdb),
- m_transConnection(NULL),
- m_autoExecute(false),
- m_updateOp(false),
- m_deleteOp(false),
- m_setValueList(new SetValueRecList())
+ NdbOperation(aNdb),
+ m_resultSet(0),
+ m_transConnection(NULL)
{
+ theParallelism = 0;
+ m_allocated_receivers = 0;
+ m_prepared_receivers = 0;
+ m_api_receivers = 0;
+ m_conf_receivers = 0;
+ m_sent_receivers = 0;
+ m_receivers = 0;
}
NdbScanOperation::~NdbScanOperation()
{
- if (m_setValueList) delete m_setValueList;
+ fix_receivers(0, false);
+ if (m_resultSet)
+ delete m_resultSet;
}
-NdbCursorOperation::CursorType
-NdbScanOperation::cursorType()
+NdbResultSet*
+NdbScanOperation::getResultSet()
{
- return NdbCursorOperation::ScanCursor;
+ if (!m_resultSet)
+ m_resultSet = new NdbResultSet(this);
+
+ return m_resultSet;
}
+
+
void
NdbScanOperation::setErrorCode(int aErrorCode){
NdbConnection* tmp = theNdbCon;
@@ -88,267 +109,516 @@ NdbScanOperation::init(NdbTableImpl* tab, NdbConnection* myConnection)
NdbConnection* aScanConnection = theNdb->hupp(myConnection);
if (!aScanConnection)
return -1;
- aScanConnection->theFirstOpInList = this;
- aScanConnection->theLastOpInList = this;
- NdbCursorOperation::cursInit();
+
// NOTE! The hupped trans becomes the owner of the operation
- return NdbOperation::init(tab, aScanConnection);
+ if(NdbOperation::init(tab, aScanConnection) != 0){
+ return -1;
+ }
+
+ initInterpreter();
+
+ theStatus = GetValue;
+ theOperationType = OpenScanRequest;
+
+ theTotalBoundAI_Len = 0;
+ theBoundATTRINFO = NULL;
+
+ return 0;
}
-NdbResultSet* NdbScanOperation::readTuples(Uint32 parallell,
- NdbCursorOperation::LockMode lm)
+NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
+ Uint32 batch,
+ Uint32 parallell)
{
- int res = 0;
+ m_ordered = 0;
+
+ Uint32 fragCount = m_currentTable->m_fragmentCount;
+
+ if(batch + parallell == 0){ // Max speed
+ batch = 16;
+ parallell = fragCount;
+ }
+
+ if(batch == 0 && parallell > 0){ // Backward
+ batch = (parallell >= 16 ? 16 : parallell & 15);
+ parallell = (parallell + 15) / 16;
+
+ if(parallell == 0)
+ parallell = 1;
+ }
+
+ if(parallell > fragCount)
+ parallell = fragCount;
+ else if(parallell == 0)
+ parallell = fragCount;
+
+ assert(parallell > 0);
+
+ // It is only possible to call openScan if
+ // 1. this transcation don't already contain another scan operation
+ // 2. this transaction don't already contain other operations
+ // 3. theScanOp contains a NdbScanOperation
+ if (theNdbCon->theScanningOp != NULL){
+ setErrorCode(4605);
+ return 0;
+ }
+
+ theNdbCon->theScanningOp = this;
+
+ bool lockExcl, lockHoldMode, readCommitted;
switch(lm){
- case NdbCursorOperation::LM_Read:
- parallell = (parallell == 0 ? 240 : parallell);
- res = openScan(parallell, false, true, false);
+ case NdbScanOperation::LM_Read:
+ lockExcl = false;
+ lockHoldMode = true;
+ readCommitted = false;
break;
- case NdbCursorOperation::LM_Exclusive:
- parallell = (parallell == 0 ? 1 : parallell);
- res = openScan(parallell, true, true, false);
+ case NdbScanOperation::LM_Exclusive:
+ lockExcl = true;
+ lockHoldMode = true;
+ readCommitted = false;
break;
- case NdbCursorOperation::LM_Dirty:
- parallell = (parallell == 0 ? 240 : parallell);
- res = openScan(parallell, false, false, true);
+ case NdbScanOperation::LM_Dirty:
+ lockExcl = false;
+ lockHoldMode = false;
+ readCommitted = true;
break;
default:
- res = -1;
setErrorCode(4003);
+ return 0;
}
- if(res == -1){
- return NULL;
+
+ 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);
+ // Modify operation state
+ theStatus = SetBound;
+ theOperationType = OpenRangeScanRequest;
+ range = true;
}
- theNdbCon->theFirstOpInList = 0;
- theNdbCon->theLastOpInList = 0;
+
+ theParallelism = parallell;
+ theBatchSize = batch;
+
+ if(fix_receivers(parallell, lockExcl) == -1){
+ setErrorCodeAbort(4000);
+ return 0;
+ }
+
+ theSCAN_TABREQ = theNdb->getSignal();
+ if (theSCAN_TABREQ == NULL) {
+ setErrorCodeAbort(4000);
+ return 0;
+ }//if
+
+ ScanTabReq * req = CAST_PTR(ScanTabReq, theSCAN_TABREQ->getDataPtrSend());
+ req->apiConnectPtr = theNdbCon->theTCConPtr;
+ req->tableId = m_accessTable->m_tableId;
+ req->tableSchemaVersion = m_accessTable->m_version;
+ req->storedProcId = 0xFFFF;
+ req->buddyConPtr = theNdbCon->theBuddyConPtr;
+
+ Uint32 reqInfo = 0;
+ ScanTabReq::setParallelism(reqInfo, parallell);
+ ScanTabReq::setScanBatch(reqInfo, batch);
+ ScanTabReq::setLockMode(reqInfo, lockExcl);
+ ScanTabReq::setHoldLockFlag(reqInfo, lockHoldMode);
+ ScanTabReq::setReadCommittedFlag(reqInfo, readCommitted);
+ ScanTabReq::setRangeScanFlag(reqInfo, range);
+ req->requestInfo = reqInfo;
+
+ Uint64 transId = theNdbCon->getTransactionId();
+ req->transId1 = (Uint32) transId;
+ req->transId2 = (Uint32) (transId >> 32);
+
+ getFirstATTRINFOScan();
return getResultSet();
}
-int NdbScanOperation::updateTuples(Uint32 parallelism)
-{
- if (openScanExclusive(parallelism) == -1) {
- return -1;
- }
- theNdbCon->theFirstOpInList = 0;
- theNdbCon->theLastOpInList = 0;
-
- m_updateOp = true;
-
- return 0;
-}
-
-int NdbScanOperation::deleteTuples(Uint32 parallelism)
-{
- if (openScanExclusive(parallelism) == -1) {
- return -1;
- }
- theNdbCon->theFirstOpInList = 0;
- theNdbCon->theLastOpInList = 0;
-
- m_deleteOp = true;
-
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, const char* aValue, Uint32 len)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue, len);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, Int32 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, Uint32 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, Uint64 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, Int64 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, float aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(const char* anAttrName, double aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrName) == NULL)
- return -1;
-
- m_setValueList->add(anAttrName, aValue);
- return 0;
-}
-
-
-int NdbScanOperation::setValue(Uint32 anAttrId, const char* aValue, Uint32 len)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue, len);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, Int32 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, Uint32 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, Uint64 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, Int64 aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, float aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-int NdbScanOperation::setValue(Uint32 anAttrId, double aValue)
-{
- // Check if attribute exist
- if (m_currentTable->getColumn(anAttrId) == NULL)
- return -1;
-
- m_setValueList->add(anAttrId, aValue);
- return 0;
-}
-
-// Private methods
-
-int NdbScanOperation::executeCursor(int ProcessorId)
-{
- int result = theNdbCon->executeScan();
- // If the scan started ok and we are updating or deleting
- // iterate over all tuples
- if ((m_updateOp) || (m_deleteOp)) {
- NdbOperation* newOp;
-
- while ((result != -1) && (nextResult() == 0)) {
- if (m_updateOp) {
- newOp = takeOverScanOp(UpdateRequest, m_transConnection);
- // Pass setValues from scan operation to new operation
- m_setValueList->iterate(SetValueRecList::callSetValueFn, *newOp);
- // No need to call updateTuple since scan was taken over for update
- // it should be the same with delete - MASV
- // newOp->updateTuple();
- }
- else if (m_deleteOp) {
- newOp = takeOverScanOp(DeleteRequest, m_transConnection);
- // newOp->deleteTuple();
- }
-#if 0
- // takeOverScanOp will take over the lock that scan aquired
- // the lock is released when nextScanResult is called
- // That means that the "takeover" has to be sent to the kernel
- // before nextScanresult is called - MASV
- if (m_autoExecute){
- m_transConnection->execute(NoCommit);
- }
-#else
- m_transConnection->execute(NoCommit);
-#endif
+int
+NdbScanOperation::fix_receivers(Uint32 parallell, bool keyInfo){
+ if(parallell == 0 || parallell > m_allocated_receivers){
+ if(m_prepared_receivers) delete[] m_prepared_receivers;
+ if(m_receivers) delete[] m_receivers;
+ if(m_api_receivers) delete[] m_api_receivers;
+ if(m_conf_receivers) delete[] m_conf_receivers;
+ if(m_sent_receivers) delete[] m_sent_receivers;
+
+ m_allocated_receivers = parallell;
+ if(parallell == 0){
+ return 0;
}
- closeScan();
+
+ m_prepared_receivers = new Uint32[parallell];
+ m_receivers = new NdbReceiver*[parallell];
+ m_api_receivers = new NdbReceiver*[parallell];
+ m_conf_receivers = new NdbReceiver*[parallell];
+ m_sent_receivers = new NdbReceiver*[parallell];
+
+ NdbReceiver* tScanRec;
+ for (Uint32 i = 0; i < parallell; i ++) {
+ tScanRec = theNdb->getNdbScanRec();
+ if (tScanRec == NULL) {
+ setErrorCodeAbort(4000);
+ return -1;
+ }//if
+ m_receivers[i] = tScanRec;
+ tScanRec->init(NdbReceiver::NDB_SCANRECEIVER, this, keyInfo);
+ }
+ }
+
+ for(Uint32 i = 0; im_list_index = i;
+ m_prepared_receivers[i] = m_receivers[i]->getId();
+ m_sent_receivers[i] = m_receivers[i];
+ m_conf_receivers[i] = 0;
+ m_api_receivers[i] = 0;
}
- return result;
+ m_api_receivers_count = 0;
+ m_current_api_receiver = 0;
+ m_sent_receivers_count = parallell;
+ m_conf_receivers_count = 0;
+ return 0;
+}
+
+/**
+ * Move receiver from send array to conf:ed array
+ */
+void
+NdbScanOperation::receiver_delivered(NdbReceiver* tRec){
+ Uint32 idx = tRec->m_list_index;
+ Uint32 last = m_sent_receivers_count - 1;
+ if(idx != last){
+ NdbReceiver * move = m_sent_receivers[last];
+ m_sent_receivers[idx] = move;
+ move->m_list_index = idx;
+ }
+ m_sent_receivers_count = last;
+
+ last = m_conf_receivers_count;
+ m_conf_receivers[last] = tRec;
+ m_conf_receivers_count = last + 1;
+ tRec->m_list_index = last;
+ tRec->m_current_row = 0;
+}
+
+/**
+ * Remove receiver as it's completed
+ */
+void
+NdbScanOperation::receiver_completed(NdbReceiver* tRec){
+ Uint32 idx = tRec->m_list_index;
+ Uint32 last = m_sent_receivers_count - 1;
+ if(idx != last){
+ NdbReceiver * move = m_sent_receivers[last];
+ m_sent_receivers[idx] = move;
+ move->m_list_index = idx;
+ }
+ m_sent_receivers_count = last;
+}
+
+/*****************************************************************************
+ * int getFirstATTRINFOScan( U_int32 aData )
+ *
+ * Return Value: Return 0: Successful
+ * Return -1: All other cases
+ * Parameters: None: Only allocate the first signal.
+ * Remark: When a scan is defined we need to use this method instead
+ * of insertATTRINFO for the first signal.
+ * This is because we need not to mess up the code in
+ * insertATTRINFO with if statements since we are not
+ * interested in the TCKEYREQ signal.
+ *****************************************************************************/
+int
+NdbScanOperation::getFirstATTRINFOScan()
+{
+ NdbApiSignal* tSignal;
+
+ tSignal = theNdb->getSignal();
+ if (tSignal == NULL){
+ setErrorCodeAbort(4000);
+ return -1;
+ }
+ tSignal->setSignal(m_attrInfoGSN);
+ theAI_LenInCurrAI = 8;
+ theATTRINFOptr = &tSignal->getDataPtrSend()[8];
+ theFirstATTRINFO = tSignal;
+ theCurrentATTRINFO = tSignal;
+ theCurrentATTRINFO->next(NULL);
+
+ return 0;
+}
+
+/**
+ * Constats for theTupleKeyDefined[][0]
+ */
+#define SETBOUND_EQ 1
+#define FAKE_PTR 2
+#define API_PTR 3
+
+
+/*
+ * After setBound() are done, move the accumulated ATTRINFO signals to
+ * a separate list. Then continue with normal scan.
+ */
+int
+NdbScanOperation::saveBoundATTRINFO()
+{
+ theCurrentATTRINFO->setLength(theAI_LenInCurrAI);
+ theBoundATTRINFO = theFirstATTRINFO;
+ theTotalBoundAI_Len = theTotalCurrAI_Len;
+ theTotalCurrAI_Len = 5;
+ theBoundATTRINFO->setData(theTotalBoundAI_Len, 4);
+ theBoundATTRINFO->setData(0, 5);
+ theBoundATTRINFO->setData(0, 6);
+ theBoundATTRINFO->setData(0, 7);
+ theBoundATTRINFO->setData(0, 8);
+ theStatus = GetValue;
+
+ int res = getFirstATTRINFOScan();
+
+ /**
+ * Define each key with getValue (if ordered)
+ * unless the one's with EqBound
+ */
+ if(!res && m_ordered){
+ Uint32 idx = 0;
+ Uint32 cnt = m_currentTable->getNoOfPrimaryKeys();
+ while(!theTupleKeyDefined[idx][0] && idx < cnt){
+ NdbColumnImpl* col = m_currentTable->getColumn(idx);
+ NdbRecAttr* tmp = NdbScanOperation::getValue_impl(col, (char*)-1);
+ UintPtr newVal = UintPtr(tmp);
+ theTupleKeyDefined[idx][0] = FAKE_PTR;
+ theTupleKeyDefined[idx][1] = (newVal & 0xFFFFFFFF);
+#if (SIZEOF_CHARP == 8)
+ theTupleKeyDefined[idx][2] = (newVal >> 32);
+#endif
+ idx++;
+ }
+ }
+ return res;
+}
+
+#define WAITFOR_SCAN_TIMEOUT 120000
+
+int
+NdbScanOperation::executeCursor(int nodeId){
+ NdbConnection * tCon = theNdbCon;
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+ Uint32 seq = tCon->theNodeSequence;
+ if (tp->get_node_alive(nodeId) &&
+ (tp->getNodeSequence(nodeId) == seq)) {
+
+ if(prepareSendScan(tCon->theTCConPtr, tCon->theTransactionId) == -1)
+ return -1;
+
+ tCon->theMagicNumber = 0x37412619;
+
+ if (doSendScan(nodeId) == -1)
+ return -1;
+
+ return 0;
+ } else {
+ if (!(tp->get_node_stopping(nodeId) &&
+ (tp->getNodeSequence(nodeId) == seq))){
+ TRACE_DEBUG("The node is hard dead when attempting to start a scan");
+ setErrorCode(4029);
+ tCon->theReleaseOnClose = true;
+ abort();
+ } else {
+ TRACE_DEBUG("The node is stopping when attempting to start a scan");
+ setErrorCode(4030);
+ }//if
+ tCon->theCommitStatus = Aborted;
+ }//if
+ return -1;
}
int NdbScanOperation::nextResult(bool fetchAllowed)
{
- int result = theNdbCon->nextScanResult(fetchAllowed);
- if (result == -1){
- // Move the error code from hupped transaction
- // to the real trans
- const NdbError err = theNdbCon->getNdbError();
- m_transConnection->setOperationErrorCode(err.code);
+ if(m_ordered)
+ return ((NdbIndexScanOperation*)this)->next_result_ordered(fetchAllowed);
+
+ /**
+ * Check current receiver
+ */
+ int retVal = 2;
+ Uint32 idx = m_current_api_receiver;
+ Uint32 last = m_api_receivers_count;
+
+ /**
+ * Check next buckets
+ */
+ for(; idx < last; idx++){
+ NdbReceiver* tRec = m_api_receivers[idx];
+ if(tRec->nextResult()){
+ tRec->copyout(theReceiver);
+ retVal = 0;
+ break;
+ }
}
- return result;
+
+ /**
+ * We have advanced atleast one bucket
+ */
+ if(!fetchAllowed){
+ m_current_api_receiver = idx;
+ return retVal;
+ }
+
+ Uint32 nodeId = theNdbCon->theDBnode;
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+ Uint32 seq = theNdbCon->theNodeSequence;
+ if(seq == tp->getNodeSequence(nodeId) && send_next_scan(idx, false) == 0){
+
+ idx = m_current_api_receiver;
+ last = m_api_receivers_count;
+
+ do {
+ Uint32 cnt = m_conf_receivers_count;
+ Uint32 sent = m_sent_receivers_count;
+
+ if(cnt > 0){
+ /**
+ * Just move completed receivers
+ */
+ memcpy(m_api_receivers+last, m_conf_receivers, cnt * sizeof(char*));
+ last += cnt;
+ m_conf_receivers_count = 0;
+ } else if(retVal == 2 && sent > 0){
+ /**
+ * No completed...
+ */
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
+ continue;
+ } else {
+ idx = last;
+ retVal = -1; //return_code;
+ }
+ } else if(retVal == 2){
+ /**
+ * No completed & no sent -> EndOfData
+ */
+ if(send_next_scan(0, true) == 0){ // Close scan
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
+ return 1;
+ }
+ retVal = -1; //return_code;
+ } else {
+ retVal = -3;
+ }
+ idx = last;
+ }
+
+ if(retVal == 0)
+ break;
+
+ for(; idx < last; idx++){
+ NdbReceiver* tRec = m_api_receivers[idx];
+ if(tRec->nextResult()){
+ tRec->copyout(theReceiver);
+ retVal = 0;
+ break;
+ }
+ }
+ } while(retVal == 2);
+ } else {
+ retVal = -3;
+ }
+
+ m_api_receivers_count = last;
+ m_current_api_receiver = idx;
+
+ switch(retVal){
+ case 0:
+ case 1:
+ case 2:
+ return retVal;
+ case -1:
+ setErrorCode(4008); // Timeout
+ break;
+ case -2:
+ setErrorCode(4028); // Node fail
+ break;
+ case -3: // send_next_scan -> return fail (set error-code self)
+ break;
+ }
+
+ theNdbCon->theTransactionIsStarted = false;
+ theNdbCon->theReleaseOnClose = true;
+ return -1;
+}
+
+int
+NdbScanOperation::send_next_scan(Uint32 cnt, bool stopScanFlag){
+ if(cnt > 0 || stopScanFlag){
+ NdbApiSignal tSignal(theNdb->theMyRef);
+ tSignal.setSignal(GSN_SCAN_NEXTREQ);
+
+ Uint32* theData = tSignal.getDataPtrSend();
+ theData[0] = theNdbCon->theTCConPtr;
+ theData[1] = stopScanFlag == true ? 1 : 0;
+ Uint64 transId = theNdbCon->theTransactionId;
+ theData[2] = transId;
+ theData[3] = (Uint32) (transId >> 32);
+
+ /**
+ * Prepare ops
+ */
+ Uint32 last = m_sent_receivers_count;
+ Uint32 * prep_array = (cnt > 21 ? m_prepared_receivers : theData + 4);
+ for(Uint32 i = 0; im_list_index = last+i;
+ prep_array[i] = tRec->m_tcPtrI;
+ tRec->prepareSend();
+ }
+ memcpy(&m_api_receivers[0], &m_api_receivers[cnt], cnt * sizeof(char*));
+
+ Uint32 nodeId = theNdbCon->theDBnode;
+ TransporterFacade * tp = TransporterFacade::instance();
+ int ret;
+ if(cnt > 21){
+ tSignal.setLength(4);
+ LinearSectionPtr ptr[3];
+ ptr[0].p = prep_array;
+ ptr[0].sz = cnt;
+ ret = tp->sendFragmentedSignal(&tSignal, nodeId, ptr, 1);
+ } else {
+ tSignal.setLength(4+cnt);
+ ret = tp->sendSignal(&tSignal, nodeId);
+ }
+
+ m_sent_receivers_count = last + cnt + stopScanFlag;
+ m_api_receivers_count -= cnt;
+ m_current_api_receiver = 0;
+
+ return ret;
+ }
+ return 0;
}
int
NdbScanOperation::prepareSend(Uint32 TC_ConnectPtr, Uint64 TransactionId)
{
printf("NdbScanOperation::prepareSend\n");
+ abort();
return 0;
}
@@ -361,300 +631,689 @@ NdbScanOperation::doSend(int ProcessorId)
void NdbScanOperation::closeScan()
{
- if(theNdbCon){
- if (theNdbCon->stopScan() == -1)
- theError = theNdbCon->getNdbError();
- theNdb->closeTransaction(theNdbCon);
- theNdbCon = 0;
- }
+ do {
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+
+ Uint32 seq = theNdbCon->theNodeSequence;
+ Uint32 nodeId = theNdbCon->theDBnode;
+
+ if(seq != tp->getNodeSequence(nodeId)){
+ theNdbCon->theReleaseOnClose = true;
+ break;
+ }
+
+ /**
+ * Wait for all running scans...
+ */
+ while(m_sent_receivers_count){
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ switch(return_code){
+ case 0:
+ break;
+ case -1:
+ setErrorCode(4008);
+ case -2:
+ m_sent_receivers_count = 0;
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ }
+ }
+
+ if(seq != tp->getNodeSequence(nodeId)){
+ theNdbCon->theReleaseOnClose = true;
+ break;
+ }
+
+ if(m_api_receivers_count+m_conf_receivers_count){
+ // Send close scan
+ send_next_scan(0, true); // Close scan
+
+ /**
+ * wait for close scan conf
+ */
+ do {
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ switch(return_code){
+ case 0:
+ break;
+ case -1:
+ setErrorCode(4008);
+ case -2:
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ }
+ } while(m_api_receivers_count+m_conf_receivers_count);
+ }
+ } while(0);
+
+ theNdbCon->theScanningOp = 0;
+ theNdb->closeTransaction(theNdbCon);
+
+ theNdbCon = 0;
m_transConnection = NULL;
}
-void NdbScanOperation::release(){
- closeScan();
- NdbCursorOperation::release();
+void
+NdbScanOperation::execCLOSE_SCAN_REP(Uint32 errCode){
+ /**
+ * We will receive no further signals from this scan
+ */
+ if(!errCode){
+ /**
+ * Normal termination
+ */
+ theNdbCon->theCommitStatus = Committed;
+ theNdbCon->theCompletionStatus = CompletedSuccess;
+ } else {
+ /**
+ * Something is fishy
+ */
+ abort();
+ }
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ m_sent_receivers_count = 0;
}
-void SetValueRecList::add(const char* anAttrName, const char* aValue, Uint32 len)
+void NdbScanOperation::release()
{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_STRING_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->stringStruct.aStringValue = (char *) malloc(len);
- strlcpy(newSetValueRec->stringStruct.aStringValue, aValue, len);
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ if(theNdbCon != 0 || m_transConnection != 0){
+ closeScan();
+ }
+ for(Uint32 i = 0; irelease();
}
}
-void SetValueRecList::add(const char* anAttrName, Int32 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
+/***************************************************************************
+int prepareSendScan(Uint32 aTC_ConnectPtr,
+ Uint64 aTransactionId)
- newSetValueRec->stype = SetValueRec::SET_INT32_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->anInt32Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+Return Value: Return 0 : preparation of send was succesful.
+ Return -1: In all other case.
+Parameters: aTC_ConnectPtr: the Connect pointer to TC.
+ aTransactionId: the Transaction identity of the transaction.
+Remark: Puts the the final data into ATTRINFO signal(s) after this
+ we know the how many signal to send and their sizes
+***************************************************************************/
+int NdbScanOperation::prepareSendScan(Uint32 aTC_ConnectPtr,
+ Uint64 aTransactionId){
+
+ if (theInterpretIndicator != 1 ||
+ (theOperationType != OpenScanRequest &&
+ theOperationType != OpenRangeScanRequest)) {
+ setErrorCodeAbort(4005);
+ return -1;
}
-}
-void SetValueRecList::add(const char* anAttrName, Uint32 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_UINT32_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->anUint32Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ if (theStatus == SetBound) {
+ saveBoundATTRINFO();
+ theStatus = GetValue;
}
-}
-void SetValueRecList::add(const char* anAttrName, Int64 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
+ theErrorLine = 0;
- newSetValueRec->stype = SetValueRec::SET_INT64_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->anInt64Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ // In preapareSendInterpreted we set the sizes (word 4-8) in the
+ // first ATTRINFO signal.
+ if (prepareSendInterpreted() == -1)
+ return -1;
+
+ if(m_ordered){
+ ((NdbIndexScanOperation*)this)->fix_get_values();
}
-}
-
-void SetValueRecList::add(const char* anAttrName, Uint64 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_UINT64_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->anUint64Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+
+ const Uint32 transId1 = (Uint32) (aTransactionId & 0xFFFFFFFF);
+ const Uint32 transId2 = (Uint32) (aTransactionId >> 32);
+
+ if (theOperationType == OpenRangeScanRequest) {
+ NdbApiSignal* tSignal = theBoundATTRINFO;
+ do{
+ tSignal->setData(aTC_ConnectPtr, 1);
+ tSignal->setData(transId1, 2);
+ tSignal->setData(transId2, 3);
+ tSignal = tSignal->next();
+ } while (tSignal != NULL);
}
-}
+ theCurrentATTRINFO->setLength(theAI_LenInCurrAI);
+ NdbApiSignal* tSignal = theFirstATTRINFO;
+ do{
+ tSignal->setData(aTC_ConnectPtr, 1);
+ tSignal->setData(transId1, 2);
+ tSignal->setData(transId2, 3);
+ tSignal = tSignal->next();
+ } while (tSignal != NULL);
-void SetValueRecList::add(const char* anAttrName, float aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_FLOAT_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->aFloatValue = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ /**
+ * Prepare all receivers
+ */
+ theReceiver.prepareSend();
+ bool keyInfo = m_keyInfo;
+ Uint32 key_size = keyInfo ? m_currentTable->m_keyLenInWords : 0;
+ for(Uint32 i = 0; ido_get_value(&theReceiver, theBatchSize, key_size);
}
+ return 0;
}
-void SetValueRecList::add(const char* anAttrName, double aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
+/******************************************************************************
+int doSend()
- newSetValueRec->stype = SetValueRec::SET_DOUBLE_ATTR1;
- newSetValueRec->anAttrName = strdup(anAttrName);
- newSetValueRec->aDoubleValue = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+Return Value: Return >0 : send was succesful, returns number of signals sent
+ Return -1: In all other case.
+Parameters: aProcessorId: Receiving processor node
+Remark: Sends the ATTRINFO signal(s)
+******************************************************************************/
+int
+NdbScanOperation::doSendScan(int aProcessorId)
+{
+ Uint32 tSignalCount = 0;
+ NdbApiSignal* tSignal;
+
+ if (theInterpretIndicator != 1 ||
+ (theOperationType != OpenScanRequest &&
+ theOperationType != OpenRangeScanRequest)) {
+ setErrorCodeAbort(4005);
+ return -1;
}
-}
-
-void SetValueRecList::add(Uint32 anAttrId, const char* aValue, Uint32 len)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_STRING_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->stringStruct.aStringValue = (char *) malloc(len);
- strlcpy(newSetValueRec->stringStruct.aStringValue, aValue, len);
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+
+ assert(theSCAN_TABREQ != NULL);
+ tSignal = theSCAN_TABREQ;
+ if (tSignal->setSignal(GSN_SCAN_TABREQ) == -1) {
+ setErrorCode(4001);
+ return -1;
}
-}
-
-void SetValueRecList::add(Uint32 anAttrId, Int32 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_INT32_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->anInt32Value = aValue;
- last->next = newSetValueRec;
- last = newSetValueRec;
-}
-
-void SetValueRecList::add(Uint32 anAttrId, Uint32 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_UINT32_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->anUint32Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ // Update the "attribute info length in words" in SCAN_TABREQ before
+ // sending it. This could not be done in openScan because
+ // we created the ATTRINFO signals after the SCAN_TABREQ signal.
+ ScanTabReq * const req = CAST_PTR(ScanTabReq, tSignal->getDataPtrSend());
+ req->attrLen = theTotalCurrAI_Len;
+ if (theOperationType == OpenRangeScanRequest)
+ req->attrLen += theTotalBoundAI_Len;
+ TransporterFacade *tp = TransporterFacade::instance();
+ if(theParallelism > 16){
+ LinearSectionPtr ptr[3];
+ ptr[0].p = m_prepared_receivers;
+ ptr[0].sz = theParallelism;
+ if (tp->sendFragmentedSignal(tSignal, aProcessorId, ptr, 1) == -1) {
+ setErrorCode(4002);
+ return -1;
+ }
+ } else {
+ tSignal->setLength(9+theParallelism);
+ memcpy(tSignal->getDataPtrSend()+9, m_prepared_receivers, 4*theParallelism);
+ if (tp->sendSignal(tSignal, aProcessorId) == -1) {
+ setErrorCode(4002);
+ return -1;
+ }
}
-}
-void SetValueRecList::add(Uint32 anAttrId, Int64 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_INT64_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->anInt64Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ if (theOperationType == OpenRangeScanRequest) {
+ // must have at least one signal since it contains attrLen for bounds
+ assert(theBoundATTRINFO != NULL);
+ tSignal = theBoundATTRINFO;
+ while (tSignal != NULL) {
+ if (tp->sendSignal(tSignal,aProcessorId) == -1){
+ setErrorCode(4002);
+ return -1;
+ }
+ tSignalCount++;
+ tSignal = tSignal->next();
+ }
}
-}
+
+ tSignal = theFirstATTRINFO;
+ while (tSignal != NULL) {
+ if (tp->sendSignal(tSignal,aProcessorId) == -1){
+ setErrorCode(4002);
+ return -1;
+ }
+ tSignalCount++;
+ tSignal = tSignal->next();
+ }
+ theStatus = WaitResponse;
+ return tSignalCount;
+}//NdbOperation::doSendScan()
-void SetValueRecList::add(Uint32 anAttrId, Uint64 aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
+/******************************************************************************
+ * NdbOperation* takeOverScanOp(NdbConnection* updateTrans);
+ *
+ * Parameters: The update transactions NdbConnection pointer.
+ * Return Value: A reference to the transferred operation object
+ * or NULL if no success.
+ * Remark: Take over the scanning transactions NdbOperation
+ * object for a tuple to an update transaction,
+ * which is the last operation read in nextScanResult()
+ * (theNdbCon->thePreviousScanRec)
+ *
+ * FUTURE IMPLEMENTATION: (This note was moved from header file.)
+ * In the future, it will even be possible to transfer
+ * to a NdbConnection on another Ndb-object.
+ * In this case the receiving NdbConnection-object must call
+ * a method receiveOpFromScan to actually receive the information.
+ * This means that the updating transactions can be placed
+ * in separate threads and thus increasing the parallelism during
+ * the scan process.
+ *****************************************************************************/
+NdbOperation*
+NdbScanOperation::takeOverScanOp(OperationType opType, NdbConnection* pTrans){
+
+ Uint32 idx = m_current_api_receiver;
+ Uint32 last = m_api_receivers_count;
- newSetValueRec->stype = SetValueRec::SET_UINT64_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->anUint64Value = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
+ Uint32 row;
+ NdbReceiver * tRec;
+ NdbRecAttr * tRecAttr;
+ if(idx < last && (tRec = m_api_receivers[idx])
+ && ((row = tRec->m_current_row) <= tRec->m_defined_rows)
+ && (tRecAttr = tRec->m_rows[row-1])){
+
+ NdbOperation * newOp = pTrans->getNdbOperation(m_currentTable);
+ if (newOp == NULL){
+ return NULL;
+ }
+
+ const Uint32 len = (tRecAttr->attrSize() * tRecAttr->arraySize() + 3)/4-1;
+
+ newOp->theTupKeyLen = len;
+ newOp->theOperationType = opType;
+ if (opType == DeleteRequest) {
+ newOp->theStatus = GetValue;
+ } else {
+ newOp->theStatus = SetValue;
+ }
+
+ const Uint32 * src = (Uint32*)tRecAttr->aRef();
+ const Uint32 tScanInfo = src[len] & 0xFFFF;
+ const Uint32 tTakeOverNode = src[len] >> 16;
+ {
+ UintR scanInfo = 0;
+ TcKeyReq::setTakeOverScanFlag(scanInfo, 1);
+ TcKeyReq::setTakeOverScanNode(scanInfo, tTakeOverNode);
+ TcKeyReq::setTakeOverScanInfo(scanInfo, tScanInfo);
+ newOp->theScanInfo = scanInfo;
+ }
+
+ // Copy the first 8 words of key info from KEYINF20 into TCKEYREQ
+ TcKeyReq * tcKeyReq = CAST_PTR(TcKeyReq,newOp->theTCREQ->getDataPtrSend());
+ Uint32 i = 0;
+ for (i = 0; i < TcKeyReq::MaxKeyInfo && i < len; i++) {
+ tcKeyReq->keyInfo[i] = * src++;
+ }
+
+ if(i < len){
+ NdbApiSignal* tSignal = theNdb->getSignal();
+ newOp->theFirstKEYINFO = tSignal;
+
+ Uint32 left = len - i;
+ while(tSignal && left > KeyInfo::DataLength){
+ tSignal->setSignal(GSN_KEYINFO);
+ KeyInfo * keyInfo = CAST_PTR(KeyInfo, tSignal->getDataPtrSend());
+ memcpy(keyInfo->keyData, src, 4 * KeyInfo::DataLength);
+ src += KeyInfo::DataLength;
+ left -= KeyInfo::DataLength;
+
+ tSignal->next(theNdb->getSignal());
+ tSignal = tSignal->next();
+ }
+
+ if(tSignal && left > 0){
+ tSignal->setSignal(GSN_KEYINFO);
+ KeyInfo * keyInfo = CAST_PTR(KeyInfo, tSignal->getDataPtrSend());
+ memcpy(keyInfo->keyData, src, 4 * left);
+ }
+ }
+ return newOp;
}
+ return 0;
}
-void SetValueRecList::add(Uint32 anAttrId, float aValue)
+NdbIndexScanOperation::NdbIndexScanOperation(Ndb* aNdb)
+ : NdbScanOperation(aNdb)
{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_FLOAT_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->aFloatValue = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
- }
}
-void SetValueRecList::add(Uint32 anAttrId, double aValue)
-{
- SetValueRec* newSetValueRec = new SetValueRec();
-
- newSetValueRec->stype = SetValueRec::SET_DOUBLE_ATTR2;
- newSetValueRec->anAttrId = anAttrId;
- newSetValueRec->aDoubleValue = aValue;
- if (!last)
- first = last = newSetValueRec;
- else {
- last->next = newSetValueRec;
- last = newSetValueRec;
- }
-}
-
-void
-SetValueRecList::callSetValueFn(SetValueRec& aSetValueRec, NdbOperation& oper)
-{
- switch(aSetValueRec.stype) {
- case(SetValueRec::SET_STRING_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.stringStruct.aStringValue, aSetValueRec.stringStruct.len);
- break;
- case(SetValueRec::SET_INT32_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.anInt32Value);
- break;
- case(SetValueRec::SET_UINT32_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.anUint32Value);
- break;
- case(SetValueRec::SET_INT64_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.anInt64Value);
- break;
- case(SetValueRec::SET_UINT64_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.anUint64Value);
- break;
- case(SetValueRec::SET_FLOAT_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.aFloatValue);
- break;
- case(SetValueRec::SET_DOUBLE_ATTR1):
- oper.setValue(aSetValueRec.anAttrName, aSetValueRec.aDoubleValue);
- break;
- case(SetValueRec::SET_STRING_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.stringStruct.aStringValue, aSetValueRec.stringStruct.len);
- break;
- case(SetValueRec::SET_INT32_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.anInt32Value);
- break;
- case(SetValueRec::SET_UINT32_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.anUint32Value);
- break;
- case(SetValueRec::SET_INT64_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.anInt64Value);
- break;
- case(SetValueRec::SET_UINT64_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.anUint64Value);
- break;
- case(SetValueRec::SET_FLOAT_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.aFloatValue);
- break;
- case(SetValueRec::SET_DOUBLE_ATTR2):
- oper.setValue(aSetValueRec.anAttrId, aSetValueRec.aDoubleValue);
- break;
- }
-}
-
-SetValueRec::~SetValueRec()
-{
- if ((stype == SET_STRING_ATTR1) ||
- (stype == SET_INT32_ATTR1) ||
- (stype == SET_UINT32_ATTR1) ||
- (stype == SET_INT64_ATTR1) ||
- (stype == SET_UINT64_ATTR1) ||
- (stype == SET_FLOAT_ATTR1) ||
- (stype == SET_DOUBLE_ATTR1))
- free(anAttrName);
-
- if ((stype == SET_STRING_ATTR1) ||
- (stype == SET_STRING_ATTR2))
- free(stringStruct.aStringValue);
- if (next) delete next;
- next = 0;
+NdbIndexScanOperation::~NdbIndexScanOperation(){
}
int
-NdbScanOperation::equal_impl(const NdbColumnImpl* anAttrObject,
- const char* aValue,
- Uint32 len){
+NdbIndexScanOperation::setBound(const char* anAttrName, int type, const void* aValue, Uint32 len)
+{
+ return setBound(m_accessTable->getColumn(anAttrName), type, aValue, len);
+}
+
+int
+NdbIndexScanOperation::setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len)
+{
+ return setBound(m_accessTable->getColumn(anAttrId), type, aValue, len);
+}
+
+int
+NdbIndexScanOperation::equal_impl(const NdbColumnImpl* anAttrObject,
+ const char* aValue,
+ Uint32 len){
return setBound(anAttrObject, BoundEQ, aValue, len);
}
+NdbRecAttr*
+NdbIndexScanOperation::getValue_impl(const NdbColumnImpl* attrInfo,
+ char* aValue){
+ if(!attrInfo->getPrimaryKey() || !m_ordered){
+ return NdbScanOperation::getValue_impl(attrInfo, aValue);
+ }
+
+ Uint32 id = attrInfo->m_attrId;
+ Uint32 marker = theTupleKeyDefined[id][0];
+ if(marker == SETBOUND_EQ){
+ return NdbScanOperation::getValue_impl(attrInfo, aValue);
+ } else if(marker == API_PTR){
+ return NdbScanOperation::getValue_impl(attrInfo, aValue);
+ }
+
+ UintPtr oldVal;
+ oldVal = theTupleKeyDefined[id][1];
+#if (SIZEOF_CHARP == 8)
+ oldVal = oldVal | (((UintPtr)theTupleKeyDefined[id][2]) << 32);
+#endif
+ theTupleKeyDefined[id][0] = API_PTR;
+
+ NdbRecAttr* tmp = (NdbRecAttr*)oldVal;
+ tmp->setup(attrInfo, aValue);
+ return tmp;
+}
+
+#include
+/*
+ * Define bound on index column in range scan.
+ */
+int
+NdbIndexScanOperation::setBound(const NdbColumnImpl* tAttrInfo,
+ int type, const void* aValue, Uint32 len)
+{
+ if (theOperationType == OpenRangeScanRequest &&
+ theStatus == SetBound &&
+ (0 <= type && type <= 4) &&
+ aValue != NULL &&
+ len <= 8000) {
+ // bound type
+
+ insertATTRINFO(type);
+ // attribute header
+ Uint32 sizeInBytes = tAttrInfo->m_attrSize * tAttrInfo->m_arraySize;
+ if (len != sizeInBytes && (len != 0)) {
+ setErrorCodeAbort(4209);
+ return -1;
+ }
+ len = sizeInBytes;
+ Uint32 tIndexAttrId = tAttrInfo->m_attrId;
+ Uint32 sizeInWords = (len + 3) / 4;
+ AttributeHeader ah(tIndexAttrId, sizeInWords);
+ insertATTRINFO(ah.m_value);
+ // attribute data
+ if ((UintPtr(aValue) & 0x3) == 0 && (len & 0x3) == 0)
+ insertATTRINFOloop((const Uint32*)aValue, sizeInWords);
+ else {
+ Uint32 temp[2000];
+ memcpy(temp, aValue, len);
+ while ((len & 0x3) != 0)
+ ((char*)temp)[len++] = 0;
+ insertATTRINFOloop(temp, sizeInWords);
+ }
+
+ /**
+ * Do sorted stuff
+ */
+
+ /**
+ * The primary keys for an ordered index is defined in the beginning
+ * so it's safe to use [tIndexAttrId]
+ * (instead of looping as is NdbOperation::equal_impl)
+ */
+ if(!theTupleKeyDefined[tIndexAttrId][0]){
+ theNoOfTupKeyDefined++;
+ theTupleKeyDefined[tIndexAttrId][0] = SETBOUND_EQ;
+ m_sort_columns -= m_ordered;
+ }
+
+ return 0;
+ } else {
+ setErrorCodeAbort(4228); // XXX wrong code
+ return -1;
+ }
+}
+
+NdbResultSet*
+NdbIndexScanOperation::readTuples(LockMode lm,
+ Uint32 batch,
+ Uint32 parallel,
+ bool order_by){
+ NdbResultSet * rs = NdbScanOperation::readTuples(lm, batch, 0);
+ if(rs && order_by){
+ m_ordered = 1;
+ m_sort_columns = m_accessTable->getNoOfPrimaryKeys();
+ m_current_api_receiver = m_sent_receivers_count;
+ }
+ return rs;
+}
+
+void
+NdbIndexScanOperation::fix_get_values(){
+ /**
+ * Loop through all getValues and set buffer pointer to "API" pointer
+ */
+ NdbRecAttr * curr = theReceiver.theFirstRecAttr;
+
+ Uint32 cnt = m_sort_columns;
+ assert(cnt < MAXNROFTUPLEKEY);
+
+ Uint32 idx = 0;
+ NdbTableImpl * tab = m_currentTable;
+ while(cnt > 0){ // To MAXNROFTUPLEKEY loops
+ NdbColumnImpl * col = tab->getColumn(idx);
+ if(col->getPrimaryKey()){
+ Uint32 val = theTupleKeyDefined[idx][0];
+ switch(val){
+ case FAKE_PTR:
+ curr->setup(col, 0);
+ // Fall-through
+ case API_PTR:
+ cnt--;
+ break;
+ case SETBOUND_EQ:
+ (void)1;
+#ifdef VM_TRACE
+ break;
+ default:
+ abort();
+#endif
+ }
+ }
+ idx++;
+ }
+}
+
+int
+NdbIndexScanOperation::compare(Uint32 skip, Uint32 cols,
+ const NdbReceiver* t1,
+ const NdbReceiver* t2){
+
+ NdbRecAttr * r1 = t1->m_rows[t1->m_current_row];
+ NdbRecAttr * r2 = t2->m_rows[t2->m_current_row];
+
+ r1 = (skip ? r1->next() : r1);
+ r2 = (skip ? r2->next() : r2);
+
+ while(cols > 0){
+ Uint32 * d1 = (Uint32*)r1->aRef();
+ Uint32 * d2 = (Uint32*)r2->aRef();
+ unsigned r1_null = r1->isNULL();
+ if((r1_null ^ (unsigned)r2->isNULL())){
+ return (r1_null ? 1 : -1);
+ }
+ Uint32 type = NdbColumnImpl::getImpl(* r1->m_column).m_extType;
+ Uint32 size = (r1->theAttrSize * r1->theArraySize + 3) / 4;
+ if(!r1_null){
+ char r = NdbSqlUtil::cmp(type, d1, d2, size, size);
+ if(r){
+ assert(r != NdbSqlUtil::CmpUnknown);
+ assert(r != NdbSqlUtil::CmpError);
+ return r;
+ }
+ }
+ cols--;
+ r1 = r1->next();
+ r2 = r2->next();
+ }
+ return 0;
+}
+
+#define DEBUG_NEXT_RESULT 0
+
+int
+NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
+
+ Uint32 u_idx = m_current_api_receiver; // start of unsorted
+ Uint32 u_last = u_idx + 1; // last unsorted
+ Uint32 s_idx = u_last; // start of sorted
+ Uint32 s_last = theParallelism; // last sorted
+
+ NdbReceiver** arr = m_api_receivers;
+ NdbReceiver* tRec = arr[u_idx];
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("nextOrderedResult(%d) nextResult: %d",
+ fetchAllowed,
+ (u_idx < s_last ? tRec->nextResult() : 0));
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("u=[%d %d] s=[%d %d]",
+ u_idx, u_last,
+ s_idx, s_last);
+
+ bool fetchNeeded = (u_idx == s_last) || !tRec->nextResult();
+
+ if(fetchNeeded){
+ if(fetchAllowed){
+ if(DEBUG_NEXT_RESULT) ndbout_c("performing fetch...");
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+ Uint32 seq = theNdbCon->theNodeSequence;
+ Uint32 nodeId = theNdbCon->theDBnode;
+ if(seq == tp->getNodeSequence(nodeId) && !send_next_scan_ordered(u_idx)){
+ Uint32 tmp = m_sent_receivers_count;
+ while(m_sent_receivers_count > 0){
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
+ continue;
+ }
+ return -1;
+ }
+
+ u_idx = 0;
+ u_last = m_conf_receivers_count;
+ s_idx = (u_last > 1 ? s_last : s_idx);
+ m_conf_receivers_count = 0;
+ memcpy(arr, m_conf_receivers, u_last * sizeof(char*));
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("sent: %d recv: %d", tmp, u_last);
+ }
+ } else {
+ return 2;
+ }
+ }
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("u=[%d %d] s=[%d %d]",
+ u_idx, u_last,
+ s_idx, s_last);
+
+
+ Uint32 cols = m_sort_columns;
+ Uint32 skip = m_keyInfo;
+ while(u_idx < u_last){
+ u_last--;
+ tRec = arr[u_last];
+
+ // Do binary search instead to find place
+ Uint32 place = s_idx;
+ for(; place < s_last; place++){
+ if(compare(skip, cols, tRec, arr[place]) <= 0){
+ break;
+ }
+ }
+
+ if(place != s_idx){
+ if(DEBUG_NEXT_RESULT)
+ ndbout_c("memmove(%d, %d, %d)", s_idx-1, s_idx, (place - s_idx));
+ memmove(arr+s_idx-1, arr+s_idx, sizeof(char*)*(place - s_idx));
+ }
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("putting %d @ %d", u_last, place - 1);
+ m_api_receivers[place-1] = tRec;
+ s_idx--;
+ }
+
+ if(DEBUG_NEXT_RESULT) ndbout_c("u=[%d %d] s=[%d %d]",
+ u_idx, u_last,
+ s_idx, s_last);
+
+ m_current_api_receiver = s_idx;
+
+ if(DEBUG_NEXT_RESULT)
+ for(Uint32 i = s_idx; inextResult()){
+ tRec->copyout(theReceiver);
+ return 0;
+ }
+
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+ Uint32 seq = theNdbCon->theNodeSequence;
+ Uint32 nodeId = theNdbCon->theDBnode;
+ if(seq == tp->getNodeSequence(nodeId) && send_next_scan(0, true) == 0){
+ return 1;
+ }
+ return -1;
+}
+
+int
+NdbIndexScanOperation::send_next_scan_ordered(Uint32 idx){
+ if(idx == theParallelism)
+ return 0;
+
+ NdbApiSignal tSignal(theNdb->theMyRef);
+ tSignal.setSignal(GSN_SCAN_NEXTREQ);
+
+ Uint32* theData = tSignal.getDataPtrSend();
+ theData[0] = theNdbCon->theTCConPtr;
+ theData[1] = 0;
+ Uint64 transId = theNdbCon->theTransactionId;
+ theData[2] = transId;
+ theData[3] = (Uint32) (transId >> 32);
+
+ /**
+ * Prepare ops
+ */
+ Uint32 last = m_sent_receivers_count;
+ Uint32 * prep_array = theData + 4;
+
+ NdbReceiver * tRec = m_api_receivers[idx];
+ m_sent_receivers[last] = tRec;
+ tRec->m_list_index = last;
+ prep_array[0] = tRec->m_tcPtrI;
+ tRec->prepareSend();
+
+ m_sent_receivers_count = last + 1;
+
+ Uint32 nodeId = theNdbCon->theDBnode;
+ TransporterFacade * tp = TransporterFacade::instance();
+ tSignal.setLength(4+1);
+ return tp->sendSignal(&tSignal, nodeId);
+}
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index b3e5b300e8d..60eda978397 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -18,11 +18,9 @@
#include "NdbApiSignal.hpp"
#include "AttrType.hpp"
#include "NdbImpl.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp"
#include "NdbOperation.hpp"
#include "NdbIndexOperation.hpp"
-#include "NdbScanReceiver.hpp"
+#include "NdbScanOperation.hpp"
#include "NdbConnection.hpp"
#include "NdbRecAttr.hpp"
#include "NdbReceiver.hpp"
@@ -35,6 +33,9 @@
#include
#include
#include
+#include
+#include
+#include
#include
#include
@@ -301,26 +302,28 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
NdbOperation* tOp;
NdbIndexOperation* tIndexOp;
NdbConnection* tCon;
- int tReturnCode;
+ int tReturnCode = -1;
const Uint32* tDataPtr = aSignal->getDataPtr();
const Uint32 tWaitState = theWaiter.m_state;
const Uint32 tSignalNumber = aSignal->readSignalNumber();
const Uint32 tFirstData = *tDataPtr;
+ const Uint32 tLen = aSignal->getLength();
+ void * tFirstDataPtr;
/*
- In order to support 64 bit processes in the application we need to use
- id's rather than a direct pointer to the object used. It is also a good
- idea that one cannot corrupt the application code by sending a corrupt
- memory pointer.
-
- All signals received by the API requires the first data word to be such
- an id to the receiving object.
+ In order to support 64 bit processes in the application we need to use
+ id's rather than a direct pointer to the object used. It is also a good
+ idea that one cannot corrupt the application code by sending a corrupt
+ memory pointer.
+
+ All signals received by the API requires the first data word to be such
+ an id to the receiving object.
*/
-
+
switch (tSignalNumber){
case GSN_TCKEYCONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const TcKeyConf * const keyConf = (TcKeyConf *)tDataPtr;
@@ -329,7 +332,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == sendTC_OP)) {
- tReturnCode = tCon->receiveTCKEYCONF(keyConf, aSignal->getLength());
+ tReturnCode = tCon->receiveTCKEYCONF(keyConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
@@ -345,93 +348,50 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}//if
goto InvalidSignal;
- return;
- }
- case GSN_READCONF:
- {
- void* tFirstDataPtr = int2void(tFirstData);
- if (tFirstDataPtr == 0) goto InvalidSignal;
-
- tOp = void2rec_op(tFirstDataPtr);
- if (tOp->checkMagicNumber() == 0) {
- tCon = tOp->theNdbCon;
- if (tCon != NULL) {
- if (tCon->theSendStatus == sendTC_OP) {
- tReturnCode = tOp->receiveREAD_CONF(tDataPtr,
- aSignal->getLength());
- if (tReturnCode != -1) {
- completedTransaction(tCon);
- }//if
- }//if
- }//if
- }//if
return;
}
case GSN_TRANSID_AI:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
+ assert(tFirstDataPtr);
if (tFirstDataPtr == 0) goto InvalidSignal;
-
- // ndbout << "*** GSN_TRANSID_AI ***" << endl;
NdbReceiver* tRec = void2rec(tFirstDataPtr);
- if (tRec->getType() == NdbReceiver::NDB_OPERATION){
- // tOp = (NdbOperation*)tRec->getOwner();
- tOp = void2rec_op(tFirstDataPtr);
- // ndbout << "NDB_OPERATION" << endl;
- if (tOp->checkMagicNumber() == 0) {
- tCon = tOp->theNdbCon;
- if (tCon != NULL) {
- if (tCon->theSendStatus == sendTC_OP) {
- tReturnCode = tOp->receiveTRANSID_AI(tDataPtr,
- aSignal->getLength());
- if (tReturnCode != -1) {
- completedTransaction(tCon);
- break;
- }
- }
- }
+ assert(tRec->checkMagicNumber());
+ assert(tRec->getTransaction());
+ assert(tRec->getTransaction()->checkState_TransId(((const TransIdAI*)tDataPtr)->transId));
+ if(tRec->checkMagicNumber() && (tCon = tRec->getTransaction()) &&
+ tCon->checkState_TransId(((const TransIdAI*)tDataPtr)->transId)){
+ Uint32 com;
+ if(aSignal->m_noOfSections > 0){
+ com = tRec->execTRANSID_AI(ptr[0].p, ptr[0].sz);
+ } else {
+ com = tRec->execTRANSID_AI(tDataPtr + TransIdAI::HeaderLength,
+ tLen - TransIdAI::HeaderLength);
}
- } else if (tRec->getType() == NdbReceiver::NDB_INDEX_OPERATION){
- // tOp = (NdbIndexOperation*)tRec->getOwner();
- tOp = void2rec_iop(tFirstDataPtr);
- // ndbout << "NDB_INDEX_OPERATION" << endl;
- if (tOp->checkMagicNumber() == 0) {
- tCon = tOp->theNdbCon;
- if (tCon != NULL) {
- if (tCon->theSendStatus == sendTC_OP) {
- tReturnCode = tOp->receiveTRANSID_AI(tDataPtr,
- aSignal->getLength());
- if (tReturnCode != -1) {
- completedTransaction(tCon);
- break;
- }
- }
- }
- }
- } else if (tRec->getType() == NdbReceiver::NDB_SCANRECEIVER) {
- // NdbScanReceiver* tScanRec = (NdbScanReceiver*)tRec->getOwner();
- // NdbScanReceiver* tScanRec =
- // (NdbScanReceiver*)(void2rec(tFirstDataPtr)->getOwner());
- NdbScanReceiver* tScanRec = void2rec_srec(tFirstDataPtr);
- // ndbout << "NDB_SCANRECEIVER" << endl;
- if(tScanRec->checkMagicNumber() == 0){
- tReturnCode = tScanRec->receiveTRANSID_AI_SCAN(aSignal);
- if (tReturnCode != -1) {
+
+ if(com == 1){
+ switch(tRec->getType()){
+ case NdbReceiver::NDB_OPERATION:
+ case NdbReceiver::NDB_INDEX_OPERATION:
+ if(tCon->OpCompleteSuccess() != -1)
+ completedTransaction(tCon);
+ break;
+ case NdbReceiver::NDB_SCANRECEIVER:
+ tCon->theScanningOp->receiver_delivered(tRec);
theWaiter.m_state = NO_WAIT;
break;
+ default:
+ goto InvalidSignal;
}
}
+ break;
} else {
-#ifdef NDB_NO_DROPPED_SIGNAL
- abort();
-#endif
goto InvalidSignal;
}
- return;
}
case GSN_TCKEY_FAILCONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const TcKeyFailConf * const failConf = (TcKeyFailConf *)tDataPtr;
@@ -462,7 +422,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCKEY_FAILREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tOp = void2rec_op(tFirstDataPtr);
@@ -483,7 +443,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCKEYREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tOp = void2rec_op(tFirstDataPtr);
@@ -504,7 +464,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TC_COMMITCONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const TcCommitConf * const commitConf = (TcCommitConf *)tDataPtr;
@@ -532,7 +492,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
case GSN_TC_COMMITREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
@@ -548,7 +508,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCROLLBACKCONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
@@ -563,7 +523,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCROLLBACKREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
@@ -579,7 +539,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCROLLBACKREP:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
@@ -593,7 +553,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCSEIZECONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_SEIZE) {
@@ -613,7 +573,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCSEIZEREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_SEIZE) {
@@ -633,7 +593,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCRELEASECONF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_RELEASE) {
@@ -651,7 +611,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_TCRELEASEREF:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_RELEASE) {
@@ -705,7 +665,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
case GSN_DIHNDBTAMPER:
{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_NDB_TAMPER)
@@ -719,27 +679,34 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
break;
}
case GSN_SCAN_TABCONF:
- {
- void* tFirstDataPtr = int2void(tFirstData);
- if (tFirstDataPtr == 0) goto InvalidSignal;
-
- //ndbout << "*** GSN_SCAN_TABCONF *** " << endl;
- if (tWaitState != WAIT_SCAN){
- return;
- }
- tCon = void2con(tFirstDataPtr);
- if (tCon->checkMagicNumber() != 0)
- return;
- tReturnCode = tCon->receiveSCAN_TABCONF(aSignal);
- if (tReturnCode != -1)
- theWaiter.m_state = NO_WAIT;
- break;
+ {
+ tFirstDataPtr = int2void(tFirstData);
+ assert(tFirstDataPtr);
+ assert(void2con(tFirstDataPtr));
+ assert(void2con(tFirstDataPtr)->checkMagicNumber() == 0);
+ if(tFirstDataPtr &&
+ (tCon = void2con(tFirstDataPtr)) && (tCon->checkMagicNumber() == 0)){
+
+ if(aSignal->m_noOfSections > 0){
+ tReturnCode = tCon->receiveSCAN_TABCONF(aSignal, ptr[0].p, ptr[0].sz);
+ } else {
+ tReturnCode =
+ tCon->receiveSCAN_TABCONF(aSignal,
+ tDataPtr + ScanTabConf::SignalLength,
+ tLen - ScanTabConf::SignalLength);
+ }
+ if (tReturnCode != -1)
+ theWaiter.m_state = NO_WAIT;
+ break;
+ } else {
+ goto InvalidSignal;
}
+ }
case GSN_SCAN_TABREF:
- {
- void* tFirstDataPtr = int2void(tFirstData);
+ {
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
-
+
if (tWaitState == WAIT_SCAN){
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() == 0){
@@ -754,35 +721,41 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
}
case GSN_SCAN_TABINFO:
{
- void* tFirstDataPtr = int2void(tFirstData);
- if (tFirstDataPtr == 0) goto InvalidSignal;
-
- //ndbout << "*** GSN_SCAN_TABINFO ***" << endl;
- if (tWaitState != WAIT_SCAN)
- return;
- tCon = void2con(tFirstDataPtr);
- if (tCon->checkMagicNumber() != 0)
- return;
- tReturnCode = tCon->receiveSCAN_TABINFO(aSignal);
- if (tReturnCode != -1)
- theWaiter.m_state = NO_WAIT;
- break;
+ goto InvalidSignal;
}
case GSN_KEYINFO20: {
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
+ NdbReceiver* tRec = void2rec(tFirstDataPtr);
+
+ if(tRec->checkMagicNumber() && (tCon = tRec->getTransaction()) &&
+ tCon->checkState_TransId(&((const KeyInfo20*)tDataPtr)->transId1)){
- //ndbout << "*** GSN_KEYINFO20 ***" << endl;
- NdbScanReceiver* tScanRec = void2rec_srec(tFirstDataPtr);
- if (tScanRec->checkMagicNumber() != 0)
- return;
- tReturnCode = tScanRec->receiveKEYINFO20(aSignal);
- if (tReturnCode != -1)
- theWaiter.m_state = NO_WAIT;
- break;
+ Uint32 len = ((const KeyInfo20*)tDataPtr)->keyLen;
+ Uint32 info = ((const KeyInfo20*)tDataPtr)->scanInfo_Node;
+ int com = -1;
+ if(aSignal->m_noOfSections > 0 && len == ptr[0].sz){
+ com = tRec->execKEYINFO20(info, ptr[0].p, len);
+ } else if(len == tLen - KeyInfo20::HeaderLength){
+ com = tRec->execKEYINFO20(info, tDataPtr+KeyInfo20::HeaderLength, len);
+ }
+
+ switch(com){
+ case 1:
+ tCon->theScanningOp->receiver_delivered(tRec);
+ theWaiter.m_state = NO_WAIT;
+ break;
+ case 0:
+ break;
+ case -1:
+ goto InvalidSignal;
+ }
+ break;
+ }
+ goto InvalidSignal;
}
case GSN_TCINDXCONF:{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const TcIndxConf * const indxConf = (TcIndxConf *)tDataPtr;
@@ -790,7 +763,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == sendTC_OP)) {
- tReturnCode = tCon->receiveTCINDXCONF(indxConf, aSignal->getLength());
+ tReturnCode = tCon->receiveTCINDXCONF(indxConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
@@ -805,7 +778,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
break;
}
case GSN_TCINDXREF:{
- void* tFirstDataPtr = int2void(tFirstData);
+ tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tIndexOp = void2rec_iop(tFirstDataPtr);
@@ -895,8 +868,8 @@ Ndb::completedTransaction(NdbConnection* aCon)
ndbout << endl << flush;
#ifdef VM_TRACE
printState("completedTransaction abort");
-#endif
abort();
+#endif
}//if
}//Ndb::completedTransaction()
@@ -1255,8 +1228,7 @@ Return: 0 - Response received
******************************************************************************/
int
-Ndb::receiveResponse(int waitTime)
-{
+Ndb::receiveResponse(int waitTime){
int tResultCode;
TransporterFacade::instance()->checkForceSend(theNdbBlockNumber);
@@ -1310,10 +1282,10 @@ Ndb::sendRecSignal(Uint16 node_id,
if (return_code != -1) {
theWaiter.m_node = node_id;
theWaiter.m_state = aWaitState;
- return receiveResponse();
- // End of protected area
- }//if
- return_code = -3;
+ return_code = receiveResponse();
+ } else {
+ return_code = -3;
+ }
} else {
return_code = -4;
}//if
diff --git a/ndb/src/ndbapi/Ndblist.cpp b/ndb/src/ndbapi/Ndblist.cpp
index 3839cc3291b..26333596408 100644
--- a/ndb/src/ndbapi/Ndblist.cpp
+++ b/ndb/src/ndbapi/Ndblist.cpp
@@ -15,16 +15,13 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include
-#include "Ndb.hpp"
-#include "NdbSchemaOp.hpp"
-#include "NdbSchemaCon.hpp"
-#include "NdbOperation.hpp"
-#include "NdbScanOperation.hpp"
-#include "NdbIndexOperation.hpp"
-#include "NdbConnection.hpp"
+#include
+#include
+#include
+#include
+#include
#include "NdbApiSignal.hpp"
-#include "NdbRecAttr.hpp"
-#include "NdbScanReceiver.hpp"
+#include
#include "NdbUtil.hpp"
#include "API.hpp"
@@ -263,13 +260,13 @@ Ndb::getNdbLabel()
* Remark: Get a NdbScanReceiver from theScanRecList and return the
* object .
****************************************************************************/
-NdbScanReceiver*
+NdbReceiver*
Ndb::getNdbScanRec()
{
- NdbScanReceiver* tNdbScanRec;
+ NdbReceiver* tNdbScanRec;
if ( theScanList == NULL )
{
- tNdbScanRec = new NdbScanReceiver(this);
+ tNdbScanRec = new NdbReceiver(this);
if (tNdbScanRec == NULL)
{
return NULL;
@@ -344,17 +341,17 @@ Return Value: Return theOpList : if the getScanOperation was succesful.
Return NULL : In all other case.
Remark: Get an operation from theScanOpIdleList and return the object .
***************************************************************************/
-NdbScanOperation*
+NdbIndexScanOperation*
Ndb::getScanOperation()
{
- NdbScanOperation* tOp = theScanOpIdleList;
+ NdbIndexScanOperation* tOp = theScanOpIdleList;
if (tOp != NULL ) {
- NdbScanOperation* tOpNext = (NdbScanOperation*) tOp->next();
+ NdbIndexScanOperation* tOpNext = (NdbIndexScanOperation*)tOp->next();
tOp->next(NULL);
theScanOpIdleList = tOpNext;
return tOp;
} else {
- tOp = new NdbScanOperation(this);
+ tOp = new NdbIndexScanOperation(this);
if (tOp != NULL)
tOp->next(NULL);
}
@@ -495,7 +492,7 @@ Parameters: aNdbScanRec: The NdbScanReceiver object.
Remark: Add a NdbScanReceiver object into the Scan idlelist.
***************************************************************************/
void
-Ndb::releaseNdbScanRec(NdbScanReceiver* aNdbScanRec)
+Ndb::releaseNdbScanRec(NdbReceiver* aNdbScanRec)
{
aNdbScanRec->next(theScanList);
theScanList = aNdbScanRec;
@@ -544,12 +541,12 @@ Parameters: aScanOperation : The released NdbScanOperation object.
Remark: Add a NdbScanOperation object into the signal idlelist.
***************************************************************************/
void
-Ndb::releaseScanOperation(NdbScanOperation* aScanOperation)
+Ndb::releaseScanOperation(NdbIndexScanOperation* aScanOperation)
{
aScanOperation->next(theScanOpIdleList);
aScanOperation->theNdbCon = NULL;
aScanOperation->theMagicNumber = 0xFE11D2;
- theScanOpIdleList = (NdbScanOperation*)aScanOperation;
+ theScanOpIdleList = aScanOperation;
}
/***************************************************************************
@@ -623,7 +620,7 @@ void
Ndb::freeScanOperation()
{
NdbScanOperation* tOp = theScanOpIdleList;
- theScanOpIdleList = (NdbScanOperation *) theScanOpIdleList->next();
+ theScanOpIdleList = (NdbIndexScanOperation *) theScanOpIdleList->next();
delete tOp;
}
@@ -674,7 +671,7 @@ Remark: Always release the first item in the free list
void
Ndb::freeNdbScanRec()
{
- NdbScanReceiver* tNdbScanRec = theScanList;
+ NdbReceiver* tNdbScanRec = theScanList;
theScanList = theScanList->next();
delete tNdbScanRec;
}
diff --git a/ndb/src/ndbapi/ObjectMap.hpp b/ndb/src/ndbapi/ObjectMap.hpp
index 4abb54b5081..f67774bb413 100644
--- a/ndb/src/ndbapi/ObjectMap.hpp
+++ b/ndb/src/ndbapi/ObjectMap.hpp
@@ -93,26 +93,28 @@ inline
void *
NdbObjectIdMap::unmap(Uint32 id, void *object){
- int i = id>>2;
+ Uint32 i = id>>2;
// lock();
-
- void * obj = m_map[i].m_obj;
- if (object == obj) {
- m_map[i].m_next = m_firstFree;
- m_firstFree = i;
- } else {
- ndbout_c("Error: NdbObjectIdMap::::unmap(%u, 0x%x) obj=0x%x", id, object, obj);
- return 0;
- }
-
- // unlock();
-
+ if(i < m_size){
+ void * obj = m_map[i].m_obj;
+ if (object == obj) {
+ m_map[i].m_next = m_firstFree;
+ m_firstFree = i;
+ } else {
+ ndbout_c("Error: NdbObjectIdMap::::unmap(%u, 0x%x) obj=0x%x", id, object, obj);
+ return 0;
+ }
+
+ // unlock();
+
#ifdef DEBUG_OBJECTMAP
- ndbout_c("NdbObjectIdMap::unmap(%u) obj=0x%x", id, obj);
+ ndbout_c("NdbObjectIdMap::unmap(%u) obj=0x%x", id, obj);
#endif
-
- return obj;
+
+ return obj;
+ }
+ return 0;
}
inline void *
@@ -120,7 +122,11 @@ NdbObjectIdMap::getObject(Uint32 id){
#ifdef DEBUG_OBJECTMAP
ndbout_c("NdbObjectIdMap::getObject(%u) obj=0x%x", id, m_map[id>>2].m_obj);
#endif
- return m_map[id>>2].m_obj;
+ id >>= 2;
+ if(id < m_size){
+ return m_map[id].m_obj;
+ }
+ return 0;
}
inline void
@@ -129,7 +135,6 @@ NdbObjectIdMap::expand(Uint32 incSize){
MapEntry * tmp = (MapEntry*)malloc(newSize * sizeof(MapEntry));
memcpy(tmp, m_map, m_size * sizeof(MapEntry));
- free(m_map);
m_map = tmp;
for(Uint32 i = m_size; i z
z) NdbConnection (scan)
theScanningOp -> y
theFirstOpInList -> y (until after openScan)
+
+# SU
+
+ScanOpLen: includes KeyInfo
+New protocol
+
+# -- Impl.
+
+1) Scan uses one NdbReceiver per "parallelism"
+2) Each NdbReceiver can handle up to "batch size" rows
+3) API send one "pointer" per parallelism (prev. was one per row)
+4) API handles each receiver independently.
+ It can "nextResult"-one, receive one and close-one
+5) When a recevier has been "nextResult"-ed, the API can fetch from it again
+6) After doing "openScan"-req, no wait is performed
+ (only possible to block on nextResult(true) or closeScan)
+
+7) Instead of "ack"-ing each row with length,
+* Each row is sent in one lonw signal (unless to short)
+* Each NdbReceiver is ack-ed with #rows and sum(#length)
+* KeyInfo20 is one signal and included in sum(#length)
+
+8) The API receive(s) the data into NdbRecAttr-objects
+ (prev. it copied signals using new/delete)
+9) KeyInfo20 is also received into a NdbRecAttr-object
+10)
+
+# -- Close of scan
+
+1) Each NdbReciver gets a signal when it's complete
+ (0 rows is ack-ed)
+2) The API then "closes" this receiver
+3) The API can at any time close then scan for other reason(s)
+ (example dying)
+4) This is signal:ed via a NEXT_SCANREQ (close = 1)
+5) TC responds with a SCAN_TABCONF (close = 1)
+
+
+# -- Sorted
+
+1) The sorted scan is transparent to TC
+ It's a API only impl.
+2) The API makes the following adjustements:
+* Scan all fragments simultaniously (max parallelism)
+* Never return a row to the API if a NdbReciver is "outstanding"
+* Sort Receivers (only top row as they already are sorted within)
diff --git a/ndb/test/include/HugoTransactions.hpp b/ndb/test/include/HugoTransactions.hpp
index 5ff1fef16bc..d859c463acf 100644
--- a/ndb/test/include/HugoTransactions.hpp
+++ b/ndb/test/include/HugoTransactions.hpp
@@ -38,12 +38,12 @@ public:
int scanReadRecords(Ndb*,
int records,
int abort = 0,
- int parallelism = 1,
+ int parallelism = 0,
bool committed = false);
int scanReadCommittedRecords(Ndb*,
int records,
int abort = 0,
- int parallelism = 1);
+ int parallelism = 0);
int pkReadRecords(Ndb*,
int records,
int batchsize = 1,
@@ -52,20 +52,20 @@ public:
int scanUpdateRecords(Ndb*,
int records,
int abort = 0,
- int parallelism = 1);
+ int parallelism = 0);
int scanUpdateRecords1(Ndb*,
int records,
int abort = 0,
- int parallelism = 1);
+ int parallelism = 0);
int scanUpdateRecords2(Ndb*,
int records,
int abort = 0,
- int parallelism = 1);
+ int parallelism = 0);
int scanUpdateRecords3(Ndb*,
int records,
int abort = 0,
- int parallelism = 1);
+ int parallelism = 0);
int pkUpdateRecords(Ndb*,
int records,
@@ -100,24 +100,6 @@ public:
int batchsize = 1);
protected:
- int takeOverAndUpdateRecord(Ndb*,
- NdbOperation*);
-#if 0
- int setValueForAttr(NdbOperation*,
- int attrId,
- int rowId,
- int updateId);
-public:
- int equalForAttr(NdbOperation*,
- int attrId,
- int rowId);
-#endif
-
- int addRowToUpdate(Ndb* pNdb,
- NdbConnection* pUpdTrans,
- NdbOperation* pOrgOp);
-
-
NDBT_ResultRow row;
int m_defaultScanUpdateMethod;
};
diff --git a/ndb/test/include/UtilTransactions.hpp b/ndb/test/include/UtilTransactions.hpp
index b16ab74455e..1298028d591 100644
--- a/ndb/test/include/UtilTransactions.hpp
+++ b/ndb/test/include/UtilTransactions.hpp
@@ -34,24 +34,24 @@ public:
int clearTable(Ndb*,
int records = 0,
- int parallelism = 240);
+ int parallelism = 0);
// Delete all records from the table using a scan
int clearTable1(Ndb*,
int records = 0,
- int parallelism = 16);
+ int parallelism = 0);
// Delete all records from the table using a scan
// Using batching
int clearTable2(Ndb*,
int records = 0,
- int parallelism = 240);
+ int parallelism = 0);
int clearTable3(Ndb*,
int records = 0,
- int parallelism = 240);
+ int parallelism = 0);
int selectCount(Ndb*,
- int parallelism = 16,
+ int parallelism = 0,
int* count_rows = NULL,
ScanLock lock = SL_Read,
NdbConnection* pTrans = NULL);
@@ -64,7 +64,7 @@ public:
ReadCallBackFn* fn = NULL);
int verifyIndex(Ndb*,
const char* indexName,
- int parallelism = 240,
+ int parallelism = 0,
bool transactional = false);
int copyTableData(Ndb*,
@@ -88,7 +88,7 @@ private:
int verifyUniqueIndex(Ndb*,
const char* indexName,
- int parallelism = 240,
+ int parallelism = 0,
bool transactional = false);
int scanAndCompareUniqueIndex(Ndb* pNdb,
diff --git a/ndb/test/ndbapi/Makefile b/ndb/test/ndbapi/Makefile
index 91f0c84c18e..2e20f05ecc9 100644
--- a/ndb/test/ndbapi/Makefile
+++ b/ndb/test/ndbapi/Makefile
@@ -4,12 +4,11 @@ include .defs.mk
ifeq ($(NDB_OS), OSE)
DIRS = basic flexBench flexAsynch
else
-DIRS = lmc-bench bank ronja
+DIRS = lmc-bench ronja
BIN_DIRS = \
flexAsynch \
flexBench \
flexHammer \
- flexScan \
flexTT \
create_tab \
create_all_tabs \
@@ -32,7 +31,6 @@ BIN_DIRS = \
testDataBuffers \
testDict \
acid \
- interpreterInTup \
telco \
indexTest \
test_event \
diff --git a/ndb/test/ndbapi/testBackup/Makefile b/ndb/test/ndbapi/testBackup/Makefile
index ce0e404803c..abf47dcfb2d 100644
--- a/ndb/test/ndbapi/testBackup/Makefile
+++ b/ndb/test/ndbapi/testBackup/Makefile
@@ -3,7 +3,6 @@ include .defs.mk
TYPE = ndbapitest
BIN_TARGET = testBackup
-BIN_TARGET_LIBS += bank
SOURCES = testBackup.cpp
include $(NDB_TOP)/Epilogue.mk
diff --git a/ndb/test/ndbapi/testBackup/testBackup.cpp b/ndb/test/ndbapi/testBackup/testBackup.cpp
index f9ae7ffcbbc..3d085e6a2d9 100644
--- a/ndb/test/ndbapi/testBackup/testBackup.cpp
+++ b/ndb/test/ndbapi/testBackup/testBackup.cpp
@@ -205,6 +205,7 @@ int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
+#if 0
#include "../bank/Bank.hpp"
@@ -394,6 +395,7 @@ int runRestoreBankAndVerify(NDBT_Context* ctx, NDBT_Step* step){
return result;
}
+#endif
NDBT_TESTSUITE(testBackup);
TESTCASE("BackupOne",
@@ -411,6 +413,7 @@ TESTCASE("BackupOne",
FINALIZER(runClearTable);
}
+#if 0
TESTCASE("BackupBank",
"Test that backup and restore works during transaction load\n"
" by backing up the bank"
@@ -429,8 +432,8 @@ TESTCASE("BackupBank",
STEP(runBackupBank);
VERIFIER(runRestoreBankAndVerify);
// FINALIZER(runDropBank);
-
}
+#endif
TESTCASE("NFMaster",
"Test that backup behaves during node failiure\n"){
INITIALIZER(setMaster);
diff --git a/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp b/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
index b8e0fef6cef..e9e60f34b59 100644
--- a/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
+++ b/ndb/test/ndbapi/testDataBuffers/testDataBuffers.cpp
@@ -84,6 +84,8 @@ static NdbSchemaCon* tcon = 0;
static NdbSchemaOp* top = 0;
static NdbConnection* con = 0;
static NdbOperation* op = 0;
+static NdbScanOperation* sop = 0;
+static NdbResultSet* rs = 0;
static int
ndberror(char const* fmt, ...)
@@ -438,9 +440,9 @@ testcase(int flag)
int newkey = 0;
if ((con = ndb->startTransaction()) == 0)
return ndberror("startTransaction key=%d", key);
- if ((op = con->getNdbOperation(tab)) == 0)
+ if ((sop = con->getNdbScanOperation(tab)) == 0)
return ndberror("getNdbOperation key=%d", key);
- if (op->openScanRead(1) < 0)
+ if ((rs = sop->readTuples(1)) == 0)
return ndberror("openScanRead key=%d", key);
{
col& c = ccol[0];
@@ -481,10 +483,10 @@ testcase(int flag)
}
}
}
- if (con->executeScan() < 0)
+ if (con->execute(NoCommit) < 0)
return ndberror("executeScan key=%d", key);
int ret, cnt = 0;
- while ((ret = con->nextScanResult()) == 0) {
+ while ((ret = rs->nextResult()) == 0) {
if (key != newkey)
return ndberror("unexpected key=%d newkey=%d", key, newkey);
for (int i = 1; i < attrcnt; i++) {
diff --git a/ndb/test/ndbapi/testGrep/Makefile b/ndb/test/ndbapi/testGrep/Makefile
index 34fdd7113d0..6bad3d56a00 100644
--- a/ndb/test/ndbapi/testGrep/Makefile
+++ b/ndb/test/ndbapi/testGrep/Makefile
@@ -3,7 +3,6 @@ include .defs.mk
TYPE = ndbapitest
DIRS = verify
BIN_TARGET = testGrep
-BIN_TARGET_LIBS += bank
SOURCES = testGrep.cpp
include $(NDB_TOP)/Epilogue.mk
diff --git a/ndb/test/ndbapi/testGrep/testGrep.cpp b/ndb/test/ndbapi/testGrep/testGrep.cpp
index 4b870f6f9a9..b8966d15c5e 100644
--- a/ndb/test/ndbapi/testGrep/testGrep.cpp
+++ b/ndb/test/ndbapi/testGrep/testGrep.cpp
@@ -254,6 +254,7 @@ int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
+#if 0
#include "../bank/Bank.hpp"
@@ -444,6 +445,8 @@ int runRestoreBankAndVerify(NDBT_Context* ctx, NDBT_Step* step){
return result;
}
*/
+#endif
+
NDBT_TESTSUITE(testGrep);
TESTCASE("GrepBasic",
"Test that Global Replication works on one table \n"
@@ -473,7 +476,7 @@ TESTCASE("GrepNodeRestart",
}
-
+#if 0
TESTCASE("GrepBank",
"Test that grep and restore works during transaction load\n"
@@ -495,6 +498,8 @@ TESTCASE("GrepBank",
// FINALIZER(runDropBank);
}
+#endif
+
TESTCASE("NFMaster",
"Test that grep behaves during node failiure\n"){
INITIALIZER(setMaster);
diff --git a/ndb/test/ndbapi/testGrep/verify/Makefile b/ndb/test/ndbapi/testGrep/verify/Makefile
index 4e6182de6b2..256e3c98f36 100644
--- a/ndb/test/ndbapi/testGrep/verify/Makefile
+++ b/ndb/test/ndbapi/testGrep/verify/Makefile
@@ -3,7 +3,6 @@ include .defs.mk
TYPE = ndbapitest
BIN_TARGET = testGrepVerify
-BIN_TARGET_LIBS += bank
SOURCES = testGrepVerify.cpp
CFLAGS_testGrepVerify.cpp += -I$(call fixpath,$(NDB_TOP)/include/kernel) -I$(call fixpath,$(NDB_TOP)/include/mgmcommon)
diff --git a/ndb/test/ndbapi/testIndex/testIndex.cpp b/ndb/test/ndbapi/testIndex/testIndex.cpp
index 47db0b3cff7..d93c7f6a8a0 100644
--- a/ndb/test/ndbapi/testIndex/testIndex.cpp
+++ b/ndb/test/ndbapi/testIndex/testIndex.cpp
@@ -1130,7 +1130,7 @@ runUniqueNullTransactions(NDBT_Context* ctx, NDBT_Step* step){
if(!pTrans) goto done;
sOp = pTrans->getNdbScanOperation(pTab->getName());
if(!sOp) goto done;
- rs = sOp->readTuples(240, NdbScanOperation::LM_Exclusive);
+ rs = sOp->readTuples(NdbScanOperation::LM_Exclusive);
if(!rs) goto done;
if(pTrans->execute(NoCommit) == -1) goto done;
while((eof = rs->nextResult(true)) == 0){
diff --git a/ndb/test/ndbapi/testOIBasic/testOIBasic.cpp b/ndb/test/ndbapi/testOIBasic/testOIBasic.cpp
index a47d9d2099e..4b82cadffa5 100644
--- a/ndb/test/ndbapi/testOIBasic/testOIBasic.cpp
+++ b/ndb/test/ndbapi/testOIBasic/testOIBasic.cpp
@@ -551,7 +551,8 @@ struct Con {
NdbConnection* m_tx;
NdbOperation* m_op;
NdbConnection* m_scantx;
- NdbOperation* m_scanop;
+ NdbIndexScanOperation* m_scanop;
+ NdbResultSet* m_resultSet;
enum ScanMode { ScanNo = 0, Committed, Latest, Exclusive };
ScanMode m_scanmode;
enum ErrType { ErrNone = 0, ErrDeadlock, ErrOther };
@@ -632,7 +633,7 @@ Con::getNdbOperation(const Tab& tab)
int
Con::getNdbOperation(const ITab& itab, const Tab& tab)
{
- CHKCON((m_op = m_tx->getNdbOperation(itab.m_name, tab.m_name)) != 0, *this);
+ CHKCON((m_scanop = m_tx->getNdbIndexScanOperation(itab.m_name, tab.m_name)) != 0, *this);
return 0;
}
@@ -664,7 +665,7 @@ int
Con::setBound(int num, int type, const void* value)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON(m_op->setBound(num, type, value) == 0, *this);
+ CHKCON(m_scanop->setBound(num, type, value) == 0, *this);
return 0;
}
@@ -680,7 +681,7 @@ int
Con::openScanRead(unsigned parallelism)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON(m_op->openScanRead(parallelism) == 0, *this);
+ CHKCON((m_resultSet = m_scanop->readTuples(parallelism)) != 0, *this);
return 0;
}
@@ -688,14 +689,14 @@ int
Con::openScanExclusive(unsigned parallelism)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON(m_op->openScanExclusive(parallelism) == 0, *this);
+ CHKCON((m_resultSet = m_scanop->readTuplesExclusive(parallelism)) != 0, *this);
return 0;
}
int
Con::executeScan()
{
- CHKCON(m_tx->executeScan() == 0, *this);
+ CHKCON(m_tx->execute(NoCommit) == 0, *this);
return 0;
}
@@ -703,7 +704,8 @@ int
Con::nextScanResult()
{
int ret;
- CHKCON((ret = m_tx->nextScanResult()) != -1, *this);
+ assert(m_resultSet != 0);
+ CHKCON((ret = m_resultSet->nextResult()) != -1, *this);
assert(ret == 0 || ret == 1);
return ret;
}
@@ -712,7 +714,7 @@ int
Con::takeOverForUpdate(Con& scan)
{
assert(m_tx != 0 && scan.m_op != 0);
- CHKCON((m_op = scan.m_op->takeOverForUpdate(m_tx)) != 0, scan);
+ CHKCON((m_op = scan.m_resultSet->updateTuple(m_tx)) != 0, scan);
return 0;
}
@@ -720,7 +722,7 @@ int
Con::takeOverForDelete(Con& scan)
{
assert(m_tx != 0 && scan.m_op != 0);
- CHKCON((m_op = scan.m_op->takeOverForUpdate(m_tx)) != 0, scan);
+ CHKCON(scan.m_resultSet->deleteTuple(m_tx) == 0, scan);
return 0;
}
diff --git a/ndb/test/ndbapi/testScan/ScanFunctions.hpp b/ndb/test/ndbapi/testScan/ScanFunctions.hpp
index 36d01909861..e0a88ab9e94 100644
--- a/ndb/test/ndbapi/testScan/ScanFunctions.hpp
+++ b/ndb/test/ndbapi/testScan/ScanFunctions.hpp
@@ -80,7 +80,8 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
int sleepTime = 10;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
+ NdbResultSet *rs;
while (true){
if (retryAttempt >= retryMax){
@@ -104,69 +105,36 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
// Execute the scan without defining a scan operation
if(action != ExecuteScanWithOutOpenScan){
-
- if (action == OnlyOneOpBeforeOpenScan){
- // There can only be one operation defined when calling openScan
- NdbOperation* pOp3;
- pOp3 = pTrans->getNdbOperation(tab.getName());
- if (pOp3 == NULL) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- if (exclusive == true)
- check = pOp->openScanExclusive(parallelism);
- else
- check = pOp->openScanRead(parallelism);
- if( check == -1 ) {
+
+ rs = pOp->readTuples(exclusive ?
+ NdbScanOperation::LM_Exclusive :
+ NdbScanOperation::LM_Read);
+
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
- if (action == OnlyOneScanPerTrans){
- // There can only be one operation in a scan transaction
- NdbOperation* pOp4;
- pOp4 = pTrans->getNdbOperation(tab.getName());
- if (pOp4 == NULL) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
-
+
if (action == OnlyOpenScanOnce){
// Call openScan one more time when it's already defined
- check = pOp->openScanRead(parallelism);
- if( check == -1 ) {
+ NdbResultSet* rs2 = pOp->readTuples(NdbScanOperation::LM_Read);
+ if( rs2 == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
}
-
- if (action == OnlyOneOpInScanTrans){
- // Try to add another op to this scanTransaction
- NdbOperation* pOp2;
- pOp2 = pTrans->getNdbOperation(tab.getName());
- if (pOp2 == NULL) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
-
-
+
if (action==EqualAfterOpenScan){
check = pOp->equal(tab.getColumn(0)->getName(), 10);
if( check == -1 ) {
@@ -191,7 +159,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
}
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -203,7 +171,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
bool abortTrans = (action==CloseWithoutStop);
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -213,7 +181,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
if (action != CloseWithoutStop){
// Test that we can closeTrans without stopScan
- check = pTrans->stopScan();
+ rs->close();
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -236,7 +204,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
}
}
- eof = pTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
@@ -246,7 +214,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
// Be cruel, call nextScanResult after error
for(int i=0; i<10; i++){
- eof =pTrans->nextScanResult();
+ eof = rs->nextResult();
if(eof == 0){
g_err << "nextScanResult returned eof = " << eof << endl
<< " That is an error when there are no more records" << endl;
@@ -276,7 +244,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
if (action == NextScanWhenNoMore){
g_info << "Calling nextScanresult when there are no more records" << endl;
for(int i=0; i<10; i++){
- eof =pTrans->nextScanResult();
+ eof = rs->nextResult();
if(eof == 0){
g_err << "nextScanResult returned eof = " << eof << endl
<< " That is an error when there are no more records" << endl;
@@ -285,7 +253,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
}
}
- if(action ==CheckInactivityBeforeClose){
+ if(action == CheckInactivityBeforeClose){
// Sleep for a long time before calling close
g_info << "NdbSleep_SecSleep(5) before close transaction" << endl;
NdbSleep_SecSleep(5);
diff --git a/ndb/test/ndbapi/testScanInterpreter/ScanInterpretTest.hpp b/ndb/test/ndbapi/testScanInterpreter/ScanInterpretTest.hpp
index 3862de34111..e8a0d4b6dca 100644
--- a/ndb/test/ndbapi/testScanInterpreter/ScanInterpretTest.hpp
+++ b/ndb/test/ndbapi/testScanInterpreter/ScanInterpretTest.hpp
@@ -197,7 +197,7 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
while (true){
@@ -220,16 +220,17 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
- check = pOp->openScanRead(parallelism);
- //check = pOp->openScanExclusive(parallelism);
- if( check == -1 ) {
+
+ NdbResultSet * rs = pOp->readTuples(NdbScanOperation::LM_Read,
+ 0, parallelism);
+
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -250,7 +251,7 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
return NDBT_FAILED;
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -261,32 +262,22 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
int rows = 0;
NdbConnection* pInsTrans;
- while((eof = pTrans->nextScanResult(true)) == 0){
- pInsTrans = pNdb->startTransaction();
- if (pInsTrans == NULL) {
- const NdbError err = pNdb->getNdbError();
- ERR(err);
- return NDBT_FAILED;
- }
+ while((eof = rs->nextResult(true)) == 0){
do {
rows++;
- if (addRowToInsert(pNdb, pInsTrans) != 0){
+ if (addRowToInsert(pNdb, pTrans) != 0){
pNdb->closeTransaction(pTrans);
- pNdb->closeTransaction(pInsTrans);
return NDBT_FAILED;
}
- } while((eof = pTrans->nextScanResult(false)) == 0);
+ } while((eof = rs->nextResult(false)) == 0);
- check = pInsTrans->execute(Commit);
+ check = pTrans->execute(Commit);
if( check == -1 ) {
- const NdbError err = pInsTrans->getNdbError();
+ const NdbError err = pTrans->getNdbError();
ERR(err);
- pNdb->closeTransaction(pInsTrans);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- pNdb->closeTransaction(pInsTrans);
-
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
@@ -322,7 +313,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
while (true){
@@ -346,7 +337,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) { if (pOp->getValue("KOL2") == 0){
ERR(pNdb->getNdbError());
return NDBT_FAILED;
@@ -357,9 +348,10 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
- check = pOp->openScanRead(parallelism);
- if( check == -1 ) {
+
+ NdbResultSet * rs = pOp->readTuples(NdbScanOperation::LM_Read,
+ 0, parallelism);
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -382,7 +374,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
return NDBT_FAILED;
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -400,7 +392,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
NdbConnection* pExistTrans;
NdbConnection* pNoExistTrans;
- while((eof = pTrans->nextScanResult(true)) == 0){
+ while((eof = rs->nextResult(true)) == 0){
pExistTrans = pNdb->startTransaction();
if (pExistTrans == NULL) {
const NdbError err = pNdb->getNdbError();
@@ -432,7 +424,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
return NDBT_FAILED;
}
}
- } while((eof = pTrans->nextScanResult(false)) == 0);
+ } while((eof = rs->nextResult(false)) == 0);
// Execute the transaction containing reads of
diff --git a/ndb/test/src/HugoOperations.cpp b/ndb/test/src/HugoOperations.cpp
index 91263aa29b4..f4b814adee2 100644
--- a/ndb/test/src/HugoOperations.cpp
+++ b/ndb/test/src/HugoOperations.cpp
@@ -295,6 +295,7 @@ int HugoOperations::pkDeleteRecord(Ndb* pNdb,
int HugoOperations::scanReadRecords(Ndb* pNdb,
Uint32 parallelism, ScanLock lock){
+#ifdef JONAS_NOT_DONE
NdbConnection * pCon = pNdb->hupp(pTrans);
NDBT_ResultRow * m_tmpRow = new NDBT_ResultRow(tab);
ScanTmp tmp(pCon, m_tmpRow);
@@ -350,6 +351,7 @@ int HugoOperations::scanReadRecords(Ndb* pNdb,
m_scans.push_back(tmp);
return 0;
+#endif
}
int HugoOperations::executeScanRead(Ndb* pNdb){
@@ -414,6 +416,7 @@ int HugoOperations::execute_Commit(Ndb* pNdb,
int
HugoOperations::run(ScanTmp & tmp){
+#if JONAS_NOT_DONE
int count = 0;
if(tmp.m_op == ScanTmp::DONE)
abort();
@@ -443,6 +446,7 @@ HugoOperations::run(ScanTmp & tmp){
if(count == 0)
return 626;
+#endif
return 0;
}
diff --git a/ndb/test/src/HugoTransactions.cpp b/ndb/test/src/HugoTransactions.cpp
index 7f12484ddc8..7c26baa3ec2 100644
--- a/ndb/test/src/HugoTransactions.cpp
+++ b/ndb/test/src/HugoTransactions.cpp
@@ -48,7 +48,7 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
while (true){
@@ -72,19 +72,18 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- if (committed == true)
- check = pOp->openScanReadCommitted(parallelism);
- else
- check = pOp->openScanRead(parallelism);
+ NdbResultSet * rs;
+ rs = pOp ->readTuples(committed ? NdbScanOperation::LM_CommittedRead :
+ NdbScanOperation::LM_Read);
- if( check == -1 ) {
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -106,7 +105,7 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError){
@@ -130,12 +129,10 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
if (abortCount < abortPercent)
abortTrans = true;
}
-
+
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
-
- while(eof == 0){
+ while((eof = rs->nextResult(true)) == 0){
rows++;
if (calc.verifyRowValues(&row) != 0){
pNdb->closeTransaction(pTrans);
@@ -145,22 +142,20 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
if (abortCount == rows && abortTrans == true){
ndbout << "Scan is aborted" << endl;
g_info << "Scan is aborted" << endl;
- check = pTrans->stopScan();
+ rs->close();
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
+
pNdb->closeTransaction(pTrans);
return NDBT_OK;
}
-
- eof = pTrans->nextScanResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
-
+
if (err.status == NdbError::TemporaryError){
ERR_INFO(err);
pNdb->closeTransaction(pTrans);
@@ -199,106 +194,6 @@ HugoTransactions::scanReadRecords(Ndb* pNdb,
#define RESTART_SCAN 99
-// Take over one record from pOrgOp and update it
-int
-HugoTransactions::takeOverAndUpdateRecord(Ndb* pNdb,
- NdbOperation* pOrgOp){
- int retryAttempt = 0;
- const int retryMax = 10;
- int check;
- NdbConnection *pUpdTrans;
- NdbOperation *pUpdOp;
-
- while (true){
-
- if (retryAttempt >= retryMax){
- g_info << "ERROR: has retried this operation " << retryAttempt
- << " times, failing!" << endl;
- return NDBT_FAILED;
- }
-
- pUpdTrans = pNdb->startTransaction();
- if (pUpdTrans == NULL) {
- const NdbError err = pNdb->getNdbError();
-
- if (err.status == NdbError::TemporaryError){
- ERR(err);
- NdbSleep_MilliSleep(50);
- retryAttempt++;
- continue;
- }
- ERR(err);
- return NDBT_FAILED;
- }
-
- if ((pUpdOp = pOrgOp->takeOverForUpdate(pUpdTrans)) == NULL){
- ERR(pNdb->getNdbError());
- return NDBT_FAILED;
- }
-
- int updates = calc.getUpdatesValue(&row) + 1;
- int id = calc.getIdValue(&row);
-
- // Set a calculated value for each non-PK attribute in this table
- for (int a = 0; agetPrimaryKey() == false){
- if(setValueForAttr(pUpdOp, a, id, updates ) != 0){
- ERR(pUpdTrans->getNdbError());
- pNdb->closeTransaction(pUpdTrans);
- return NDBT_FAILED;
- }
- }
- }
- check = pUpdTrans->execute( Commit );
- if(check == -1 ) {
- const NdbError err = pUpdTrans->getNdbError();
- pNdb->closeTransaction(pUpdTrans);
-
- ERR(err);
- if(err.code == 499 || err.code == 250){
- return RESTART_SCAN;
- }
-
- switch(err.status){
- case NdbError::Success:
- g_info << "ERROR: NdbError reports success when transcaction failed"
- << endl;
- return NDBT_FAILED;
- break;
-
- case NdbError::TemporaryError:
- NdbSleep_MilliSleep(50+50*retryAttempt);
- retryAttempt++;
- continue;
- break;
-
- case NdbError::UnknownResult:
- return NDBT_FAILED;
- break;
-
- default:
- case NdbError::PermanentError:
- switch (err.code){
- case 499:
- case 250:
- return NDBT_TEMPORARY;
-
- default:
- return NDBT_FAILED;
- break;
- }
- break;
- }
- }
- else{
- pNdb->closeTransaction(pUpdTrans);
- }
-
- return NDBT_OK;
- }
- return NDBT_FAILED;
-}
-
int
HugoTransactions::scanUpdateRecords(Ndb* pNdb,
int records,
@@ -320,6 +215,9 @@ HugoTransactions::scanUpdateRecords1(Ndb* pNdb,
int records,
int abortPercent,
int parallelism){
+#if 1
+ return scanUpdateRecords3(pNdb, records, abortPercent, 1);
+#else
int retryAttempt = 0;
const int retryMax = 100;
int check;
@@ -472,9 +370,9 @@ HugoTransactions::scanUpdateRecords1(Ndb* pNdb,
return NDBT_OK;
}
return NDBT_FAILED;
+#endif
}
-
// Scan all records exclusive and update
// them batched by asking nextScanResult to
// give us all cached records before fetching new
@@ -484,6 +382,9 @@ HugoTransactions::scanUpdateRecords2(Ndb* pNdb,
int records,
int abortPercent,
int parallelism){
+#if 1
+ return scanUpdateRecords3(pNdb, records, abortPercent, parallelism);
+#else
int retryAttempt = 0;
const int retryMax = 100;
int check;
@@ -642,35 +543,9 @@ HugoTransactions::scanUpdateRecords2(Ndb* pNdb,
return NDBT_OK;
}
return NDBT_FAILED;
+#endif
}
-int
-HugoTransactions::addRowToUpdate(Ndb* pNdb,
- NdbConnection* pUpdTrans,
- NdbOperation* pOrgOp){
-
- int updates = calc.getUpdatesValue(&row) + 1;
- int r = calc.getIdValue(&row);
-
- NdbOperation* pUpdOp = pOrgOp->takeOverForUpdate(pUpdTrans);
- if (pUpdOp == NULL){
- ERR(pNdb->getNdbError());
- return NDBT_FAILED;
- }
-
- for(int a = 0; agetPrimaryKey() == false){
- if(setValueForAttr(pUpdOp, a, r, updates ) != 0){
- ERR(pUpdTrans->getNdbError());
- pNdb->closeTransaction(pUpdTrans);
- return NDBT_FAILED;
- }
- }
- }
- return NDBT_OK;
-}
-
-
int
HugoTransactions::scanUpdateRecords3(Ndb* pNdb,
int records,
@@ -759,7 +634,6 @@ HugoTransactions::scanUpdateRecords3(Ndb* pNdb,
}
const int updates = calc.getUpdatesValue(&row) + 1;
const int r = calc.getIdValue(&row);
-
for(int a = 0; agetPrimaryKey() == false){
if(setValueForAttr(pUp, a, r, updates ) != 0){
@@ -794,7 +668,7 @@ HugoTransactions::scanUpdateRecords3(Ndb* pNdb,
return NDBT_FAILED;
}
}
-
+
const NdbError err = pTrans->getNdbError();
if( check == -1 ) {
pNdb->closeTransaction(pTrans);
@@ -2083,7 +1957,7 @@ HugoTransactions::indexReadRecords(Ndb* pNdb,
int check;
NdbConnection *pTrans;
NdbOperation *pOp;
- NdbScanOperation *sOp;
+ NdbIndexScanOperation *sOp;
NdbResultSet * rs;
const NdbDictionary::Index* pIndex
@@ -2134,7 +2008,7 @@ HugoTransactions::indexReadRecords(Ndb* pNdb,
}
check = pOp->readTuple();
} else {
- pOp = sOp = pTrans->getNdbScanOperation(idxName, tab.getName());
+ pOp = sOp = pTrans->getNdbIndexScanOperation(idxName, tab.getName());
if (sOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -2284,7 +2158,7 @@ HugoTransactions::indexUpdateRecords(Ndb* pNdb,
return NDBT_FAILED;
}
} else {
- pOp = sOp = pTrans->getNdbScanOperation(idxName, tab.getName());
+ pOp = sOp = pTrans->getNdbIndexScanOperation(idxName, tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
diff --git a/ndb/test/src/NDBT_Tables.cpp b/ndb/test/src/NDBT_Tables.cpp
index 548e755a3fb..8fd2d4042fd 100644
--- a/ndb/test/src/NDBT_Tables.cpp
+++ b/ndb/test/src/NDBT_Tables.cpp
@@ -835,7 +835,7 @@ NDBT_Tables::printAll(){
if (tab == NULL){
abort();
}
- ndbout << (* tab) << endl;
+ ndbout << (* (NDBT_Table*)tab) << endl;
}
return NDBT_OK;
diff --git a/ndb/test/src/UtilTransactions.cpp b/ndb/test/src/UtilTransactions.cpp
index 2e6ff360123..060368322c4 100644
--- a/ndb/test/src/UtilTransactions.cpp
+++ b/ndb/test/src/UtilTransactions.cpp
@@ -47,10 +47,14 @@ UtilTransactions::clearTable(Ndb* pNdb,
}
}
+
int
UtilTransactions::clearTable1(Ndb* pNdb,
int records,
int parallelism){
+#if 1
+ return clearTable3(pNdb, records, 1);
+#else
// Scan all records exclusive and delete
// them one by one
int retryAttempt = 0;
@@ -191,12 +195,16 @@ UtilTransactions::clearTable1(Ndb* pNdb,
return NDBT_OK;
}
return NDBT_FAILED;
+#endif
}
int
UtilTransactions::clearTable2(Ndb* pNdb,
int records,
int parallelism){
+#if 1
+ return clearTable3(pNdb, records, parallelism);
+#else
// Scan all records exclusive and delete
// them one by one
int retryAttempt = 0;
@@ -336,6 +344,7 @@ UtilTransactions::clearTable2(Ndb* pNdb,
return NDBT_OK;
}
return NDBT_FAILED;
+#endif
}
int
@@ -451,7 +460,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
int parallelism = 240;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
NDBT_ResultRow row(tab);
while (true){
@@ -477,14 +486,15 @@ UtilTransactions::copyTableData(Ndb* pNdb,
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(parallelism);
+ NdbResultSet* rs = pOp->readTuples(NdbScanOperation::LM_Read,
+ parallelism);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -508,7 +518,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -516,39 +526,27 @@ UtilTransactions::copyTableData(Ndb* pNdb,
}
int eof;
- NdbConnection* pInsTrans;
-
- while((eof = pTrans->nextScanResult(true)) == 0){
- pInsTrans = pNdb->startTransaction();
- if (pInsTrans == NULL) {
- const NdbError err = pNdb->getNdbError();
- ERR(err);
- pNdb->closeTransaction(pInsTrans);
- return NDBT_FAILED;
- }
+ while((eof = rs->nextResult(true)) == 0){
do {
insertedRows++;
- if (addRowToInsert(pNdb, pInsTrans, row, destName) != 0){
- pNdb->closeTransaction(pInsTrans);
+ if (addRowToInsert(pNdb, pTrans, row, destName) != 0){
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- } while((eof = pTrans->nextScanResult(false)) == 0);
-
- check = pInsTrans->execute(Commit);
+ } while((eof = rs->nextResult(false)) == 0);
+
+ check = pTrans->execute(Commit);
+ pTrans->releaseCompletedOperations();
if( check == -1 ) {
- const NdbError err = pInsTrans->getNdbError();
+ const NdbError err = pTrans->getNdbError();
ERR(err);
- pNdb->closeTransaction(pInsTrans);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- pNdb->closeTransaction(pInsTrans);
-
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
-
+
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans);
@@ -562,29 +560,16 @@ UtilTransactions::copyTableData(Ndb* pNdb,
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
+
pNdb->closeTransaction(pTrans);
-
+
g_info << insertedRows << " rows copied" << endl;
-
+
return NDBT_OK;
}
return NDBT_FAILED;
}
-int
-UtilTransactions::addRowToDelete(Ndb* pNdb,
- NdbConnection* pDelTrans,
- NdbOperation* pOrgOp){
-
- NdbOperation* pDelOp = pOrgOp->takeOverForDelete(pDelTrans);
- if (pDelOp == NULL){
- ERR(pNdb->getNdbError());
- return NDBT_FAILED;
- }
- return NDBT_OK;
-}
-
int
UtilTransactions::addRowToInsert(Ndb* pNdb,
NdbConnection* pInsTrans,
@@ -621,101 +606,6 @@ UtilTransactions::addRowToInsert(Ndb* pNdb,
return NDBT_OK;
}
-// Take over one record from pOrgOp and delete it
-int
-UtilTransactions::takeOverAndDeleteRecord(Ndb* pNdb,
- NdbOperation* pOrgOp){
-
- int retryAttempt = 0;
- const int retryMax = 10;
- int check;
- NdbConnection *pDelTrans;
- NdbOperation *pDelOp;
-
- while (true){
-
- if (retryAttempt >= retryMax){
- g_info << "ERROR: has retried this operation " << retryAttempt
- << " times, failing!" << endl;
- return NDBT_FAILED;
- }
-
- pDelTrans = pNdb->startTransaction();
- if (pDelTrans == NULL) {
- const NdbError err = pNdb->getNdbError();
-
- if (err.status == NdbError::TemporaryError){
- ERR(err);
- NdbSleep_MilliSleep(50);
- retryAttempt++;
- continue;
- }
- ERR(err);
- return NDBT_FAILED;
- }
-
- if ((pDelOp = pOrgOp->takeOverForDelete(pDelTrans)) == NULL){
- ERR(pNdb->getNdbError());
- return NDBT_FAILED;
- }
-
-#if 0
- // It should not be necessary to call deleteTuple HERE!!!
- check = pDelOp->deleteTuple();
- if( check == -1 ) {
- ERR(pDelTrans->getNdbError());
- pNdb->closeTransaction(pDelTrans);
- return NDBT_FAILED;
- }
-#endif
-
- check = pDelTrans->execute( Commit );
- if(check == -1 ) {
- const NdbError err = pDelTrans->getNdbError();
- pNdb->closeTransaction(pDelTrans);
-
- ERR(err);
- if(err.code == 250 || err.code == 499)
- return RESTART_SCAN;
-
- switch(err.status){
- case NdbError::Success:
- g_info << "ERROR: NdbError reports success when transcaction failed"
- << endl;
- RETURN_FAIL(err);
- break;
-
- case NdbError::TemporaryError:
- NdbSleep_MilliSleep(50+50*retryAttempt);
- retryAttempt++;
- continue;
- break;
-
- case NdbError::UnknownResult:
- RETURN_FAIL(err);
- break;
-
- default:
- case NdbError::PermanentError:
- switch (err.classification){
- default:
- RETURN_FAIL(err);
- break;
- }
- break;
- }
- }
- else{
- pNdb->closeTransaction(pDelTrans);
- }
-
- return NDBT_OK;
- }
- return NDBT_FAILED;
-}
-
-
-
int
UtilTransactions::scanReadRecords(Ndb* pNdb,
@@ -730,7 +620,7 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
NDBT_ResultRow row(tab);
while (true){
@@ -755,18 +645,18 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
- if (exclusive == true)
- check = pOp->openScanExclusive(parallelism);
- else
- check = pOp->openScanRead(parallelism);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples(exclusive ?
+ NdbScanOperation::LM_Exclusive :
+ NdbScanOperation::LM_Read,
+ 0, parallelism);
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -778,7 +668,7 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
+
// Call getValue for all the attributes supplied in attrib_list
// ************************************************
for (int a = 0; a < noAttribs; a++){
@@ -793,8 +683,8 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
}
}
// *************************************************
-
- check = pTrans->executeScan();
+
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
@@ -812,15 +702,14 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
- while(eof == 0){
+
+ while((eof = rs->nextResult()) == 0){
rows++;
// Call callback for each record returned
if(fn != NULL)
fn(&row);
- eof = pTrans->nextScanResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
@@ -856,14 +745,15 @@ UtilTransactions::selectCount(Ndb* pNdb,
int parallelism,
int* count_rows,
ScanLock lock,
- NdbConnection* pBuddyTrans){
+ NdbConnection* pTrans){
int retryAttempt = 0;
const int retryMax = 100;
int check;
- NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
+ if(!pTrans)
+ pTrans = pNdb->startTransaction();
while (true){
if (retryAttempt >= retryMax){
@@ -871,39 +761,27 @@ UtilTransactions::selectCount(Ndb* pNdb,
<< " times, failing!" << endl;
return NDBT_FAILED;
}
-
- pTrans = pNdb->hupp(pBuddyTrans);
- if (pTrans == NULL) {
- const NdbError err = pNdb->getNdbError();
-
- if (err.status == NdbError::TemporaryError){
- NdbSleep_MilliSleep(50);
- retryAttempt++;
- continue;
- }
- ERR(err);
- return NDBT_FAILED;
- }
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
+ NdbResultSet * rs;
switch(lock){
case SL_ReadHold:
- check = pOp->openScanReadHoldLock(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Read);
break;
case SL_Exclusive:
- check = pOp->openScanExclusive(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Exclusive);
break;
case SL_Read:
default:
- check = pOp->openScanRead(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead);
}
- if( check == -1 ) {
+ if( rs == 0) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -922,9 +800,9 @@ UtilTransactions::selectCount(Ndb* pNdb,
return NDBT_FAILED;
}
}
-
-
- check = pTrans->executeScan();
+
+
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -933,15 +811,14 @@ UtilTransactions::selectCount(Ndb* pNdb,
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
+
- while(eof == 0){
+ while((eof = rs->nextResult()) == 0){
rows++;
- eof = pTrans->nextScanResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
-
+
if (err.status == NdbError::TemporaryError){
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
@@ -952,7 +829,7 @@ UtilTransactions::selectCount(Ndb* pNdb,
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
+
pNdb->closeTransaction(pTrans);
if (count_rows != NULL){
@@ -963,7 +840,6 @@ UtilTransactions::selectCount(Ndb* pNdb,
}
return NDBT_FAILED;
}
-
int
UtilTransactions::verifyIndex(Ndb* pNdb,
@@ -1028,7 +904,7 @@ UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
NDBT_ResultRow row(tab);
parallelism = 1;
@@ -1055,20 +931,21 @@ UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(tab.getName());
+ pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
+ NdbResultSet* rs;
if(transactional){
- check = pOp->openScanReadHoldLock(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism);
} else {
- check = pOp->openScanRead(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallelism);
}
-
- if( check == -1 ) {
+
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -1091,10 +968,10 @@ UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
-
+
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans);
@@ -1109,14 +986,14 @@ UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
- while(eof == 0){
+
+ while((eof = rs->nextResult()) == 0){
rows++;
-
+
// ndbout << row.c_str().c_str() << endl;
-
-
+
+
if (readRowFromTableAndIndex(pNdb,
pTrans,
indexName,
@@ -1124,11 +1001,6 @@ UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
-
-
-
- eof = pTrans->nextScanResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
@@ -1265,13 +1137,13 @@ UtilTransactions::readRowFromTableAndIndex(Ndb* pNdb,
* Read the record from INDEX_TABLE
*/
NdbIndexOperation* pIndexOp= NULL;
- NdbScanOperation *pScanOp= NULL;
+ NdbIndexScanOperation *pScanOp= NULL;
{
void* pOpCheck= NULL;
if (indexType == NdbDictionary::Index::UniqueHashIndex) {
pOpCheck= pIndexOp= pTrans1->getNdbIndexOperation(indexName, tab.getName());
} else {
- pOpCheck= pScanOp= pTrans1->getNdbScanOperation(indexName, tab.getName());
+ pOpCheck= pScanOp= pTrans1->getNdbIndexScanOperation(indexName, tab.getName());
}
if (pOpCheck == NULL) {
@@ -1308,7 +1180,7 @@ UtilTransactions::readRowFromTableAndIndex(Ndb* pNdb,
// setBound not possible for null attributes
if ( !row.attributeStore(col->getName())->isNULL() ) {
r = pScanOp->setBound(col->getName(),
- NdbOperation::BoundEQ,
+ NdbIndexScanOperation::BoundEQ,
row.attributeStore(col->getName())->aRef());
}
}
diff --git a/ndb/tools/create_index/create_index.cpp b/ndb/tools/create_index/create_index.cpp
index dc9e6c606d6..f883755ea24 100644
--- a/ndb/tools/create_index/create_index.cpp
+++ b/ndb/tools/create_index/create_index.cpp
@@ -29,10 +29,13 @@ main(int argc, const char** argv){
const char* _dbname = "TEST_DB";
int _help = 0;
+ int _ordered, _pk;
struct getargs args[] = {
{ "database", 'd', arg_string, &_dbname, "dbname",
"Name of database table is in"},
+ { "ordered", 'o', arg_flag, &_ordered, "Create ordered index", "" },
+ { "pk", 'p', arg_flag, &_pk, "Create index on primary key", "" },
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
@@ -73,14 +76,21 @@ main(int argc, const char** argv){
}
NdbDictionary::Index ind;
+ if(_ordered){
+ ind.setType(NdbDictionary::Index::OrderedIndex);
+ ind.setLogging(false);
+ } else {
+ ind.setType(NdbDictionary::Index::UniqueHashIndex);
+ }
char buf[512];
- sprintf(buf, "IND_%s", argv[i]);
+ sprintf(buf, "IND_%s_%s_%c",
+ argv[i], (_pk ? "PK" : "FULL"), (_ordered ? 'O' : 'U'));
ind.setName(buf);
ind.setTable(argv[i]);
- ind.setType(NdbDictionary::Index::UniqueHashIndex);
- for(int c = 0; cgetNoOfColumns(); c++)
- ind.addIndexColumn(tab->getColumn(c)->getName());
-
+ for(int c = 0; cgetNoOfColumns(); c++){
+ if(!_pk || tab->getColumn(c)->getPrimaryKey())
+ ind.addIndexColumn(tab->getColumn(c)->getName());
+ }
ndbout << "creating index " << buf << " on table " << argv[i] << "...";
const int res = dict->createIndex(ind);
if(res != 0)
diff --git a/ndb/tools/select_all/select_all.cpp b/ndb/tools/select_all/select_all.cpp
index 34f63a095bb..329ed87bc48 100644
--- a/ndb/tools/select_all/select_all.cpp
+++ b/ndb/tools/select_all/select_all.cpp
@@ -29,11 +29,13 @@
int scanReadRecords(Ndb*,
const NdbDictionary::Table*,
+ const NdbDictionary::Index*,
int parallel,
int lockType,
bool headers,
bool useHexFormat,
- char delim);
+ char delim,
+ bool orderby);
int main(int argc, const char** argv){
int _parallelism = 240;
@@ -44,6 +46,7 @@ int main(int argc, const char** argv){
const char* _dbname = "TEST_DB";
int _help = 0;
int _lock = 0;
+ int _order = 0;
struct getargs args[] = {
{ "database", 'd', arg_string, &_dbname, "dbname",
@@ -57,7 +60,8 @@ int main(int argc, const char** argv){
"delimiter" },
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "lock", 'l', arg_integer, &_lock,
- "Read(0), Read-hold(1), Exclusive(2)", "lock"}
+ "Read(0), Read-hold(1), Exclusive(2)", "lock"},
+ { "order", 'o', arg_flag, &_order, "Sort resultset according to index", ""}
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
@@ -90,6 +94,11 @@ int main(int argc, const char** argv){
// Check if table exists in db
const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(&MyNdb, _tabname);
+ const NdbDictionary::Index * pIdx = 0;
+ if(optind+1 < argc){
+ pIdx = MyNdb.getDictionary()->getIndex(argv[optind+1], _tabname);
+ }
+
if(pTab == NULL){
ndbout << " Table " << _tabname << " does not exist!" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
@@ -97,11 +106,12 @@ int main(int argc, const char** argv){
if (scanReadRecords(&MyNdb,
pTab,
+ pIdx,
_parallelism,
_lock,
_header,
_useHexFormat,
- (char)*_delimiter) != 0){
+ (char)*_delimiter, _order) != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
@@ -111,17 +121,19 @@ int main(int argc, const char** argv){
int scanReadRecords(Ndb* pNdb,
const NdbDictionary::Table* pTab,
+ const NdbDictionary::Index* pIdx,
int parallel,
int _lock,
bool headers,
bool useHexFormat,
- char delimiter){
+ char delimiter, bool order){
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
+ NdbIndexScanOperation * pIOp;
NDBT_ResultRow * row = new NDBT_ResultRow(*pTab, delimiter);
@@ -146,29 +158,45 @@ int scanReadRecords(Ndb* pNdb,
return -1;
}
- pOp = pTrans->getNdbOperation(pTab->getName());
+
+ pOp = (!pIdx) ? pTrans->getNdbScanOperation(pTab->getName()) :
+ pIOp=pTrans->getNdbIndexScanOperation(pIdx->getName(), pTab->getName());
+
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
- switch(_lock){
+ NdbResultSet * rs;
+ switch(_lock + (3 * order)){
case 1:
- check = pOp->openScanReadHoldLock(parallel);
+ rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallel);
break;
case 2:
- check = pOp->openScanExclusive(parallel);
+ rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallel);
break;
+ case 3:
+ rs = pIOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallel,
+ true);
+ break;
+ case 4:
+ rs = pIOp->readTuples(NdbScanOperation::LM_Read, 0, parallel, true);
+ break;
+ case 5:
+ rs = pIOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallel, true);
+ break;
+ case 0:
default:
- check = pOp->openScanRead(parallel);
+ rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallel);
+ break;
}
- if( check == -1 ) {
+ if( rs == 0 ){
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
-
+
if(0){
NdbScanFilter sf(pOp);
#if 0
@@ -229,10 +257,10 @@ int scanReadRecords(Ndb* pNdb,
}
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
-
+
if (err.status == NdbError::TemporaryError){
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
@@ -246,11 +274,11 @@ int scanReadRecords(Ndb* pNdb,
if (headers)
row->header(ndbout) << endl;
-
+
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
-
+ eof = rs->nextResult();
+
while(eof == 0){
rows++;
@@ -260,7 +288,7 @@ int scanReadRecords(Ndb* pNdb,
ndbout << (*row) << endl;
}
- eof = pTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
From 1d965d98191691ec5fd2d2c20ba378cd4746789c Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Thu, 27 May 2004 21:21:48 +0200
Subject: [PATCH 002/579] Fix AttrType moves
---
ndb/src/ndbapi/Makefile.am | 3 +-
ndb/src/ndbapi/NdbConnection.cpp | 42 ++++++++--------
ndb/src/ndbapi/NdbScanOperation.cpp | 8 +--
ndb/src/ndbapi/Ndbif.cpp | 75 ++++++++++++++---------------
4 files changed, 63 insertions(+), 65 deletions(-)
diff --git a/ndb/src/ndbapi/Makefile.am b/ndb/src/ndbapi/Makefile.am
index 8baee612fb5..28ef57fd3c8 100644
--- a/ndb/src/ndbapi/Makefile.am
+++ b/ndb/src/ndbapi/Makefile.am
@@ -22,8 +22,7 @@ libndbapi_la_SOURCES_loc = \
NdbOperationDefine.cpp \
NdbOperationExec.cpp \
NdbResultSet.cpp \
- NdbCursorOperation.cpp \
- NdbScanReceiver.cpp NdbScanOperation.cpp NdbScanFilter.cpp \
+ NdbScanOperation.cpp NdbScanFilter.cpp \
NdbIndexOperation.cpp \
NdbEventOperation.cpp \
NdbEventOperationImpl.cpp \
diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index 8ccd0aa8523..5aaf14302a6 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -1359,16 +1359,16 @@ NdbConnection::receiveTCKEY_FAILCONF(const TcKeyFailConf * failConf)
* in committing the transaction.
*/
switch(tOp->theOperationType){
- case UpdateRequest:
- case InsertRequest:
- case DeleteRequest:
- case WriteRequest:
+ case NdbOperation::UpdateRequest:
+ case NdbOperation::InsertRequest:
+ case NdbOperation::DeleteRequest:
+ case NdbOperation::WriteRequest:
tOp = tOp->next();
break;
- case ReadRequest:
- case ReadExclusive:
- case OpenScanRequest:
- case OpenRangeScanRequest:
+ case NdbOperation::ReadRequest:
+ case NdbOperation::ReadExclusive:
+ case NdbOperation::OpenScanRequest:
+ case NdbOperation::OpenRangeScanRequest:
theCompletionStatus = CompletedFailure;
setOperationErrorCodeAbort(4115);
tOp = NULL;
@@ -1403,18 +1403,18 @@ NdbConnection::receiveTCKEY_FAILREF(NdbApiSignal* aSignal)
We received an indication of that this transaction was aborted due to a
node failure.
*/
- if (theSendStatus == sendTC_ROLLBACK) {
+ if (theSendStatus == NdbConnection::sendTC_ROLLBACK) {
/*
We were in the process of sending a rollback anyways. We will
report it as a success.
*/
- theCompletionStatus = CompletedSuccess;
+ theCompletionStatus = NdbConnection::CompletedSuccess;
} else {
- theCompletionStatus = CompletedFailure;
+ theCompletionStatus = NdbConnection::CompletedFailure;
theError.code = 4031;
}//if
theReleaseOnClose = true;
- theCommitStatus = Aborted;
+ theCommitStatus = NdbConnection::Aborted;
return 0;
}
return -1;
@@ -1463,8 +1463,8 @@ NdbConnection::receiveTCINDXCONF(const TcIndxConf * indxConf,
// no Commit flag set. This is clearly an anomaly.
/**********************************************************************/
theError.code = 4011;
- theCompletionStatus = CompletedFailure;
- theCommitStatus = Aborted;
+ theCompletionStatus = NdbConnection::CompletedFailure;
+ theCommitStatus = NdbConnection::Aborted;
return 0;
}//if
if (tNoComp >= tNoSent) {
@@ -1497,8 +1497,8 @@ NdbConnection::receiveTCINDXREF( NdbApiSignal* aSignal)
/* and we only need to report completion and return with the */
/* error code to the application. */
/**********************************************************************/
- theCompletionStatus = CompletedFailure;
- theCommitStatus = Aborted;
+ theCompletionStatus = NdbConnection::CompletedFailure;
+ theCommitStatus = NdbConnection::Aborted;
return 0;
}
return -1;
@@ -1517,7 +1517,7 @@ NdbConnection::OpCompleteFailure()
{
Uint32 tNoComp = theNoOfOpCompleted;
Uint32 tNoSent = theNoOfOpSent;
- theCompletionStatus = CompletedFailure;
+ theCompletionStatus = NdbConnection::CompletedFailure;
tNoComp++;
theNoOfOpCompleted = tNoComp;
if (tNoComp == tNoSent) {
@@ -1528,7 +1528,7 @@ NdbConnection::OpCompleteFailure()
//operation is not really part of that transaction.
//------------------------------------------------------------------------
if (theSimpleState == 1) {
- theCommitStatus = Aborted;
+ theCommitStatus = NdbConnection::Aborted;
}//if
return 0; // Last operation received
} else if (tNoComp > tNoSent) {
@@ -1556,7 +1556,7 @@ NdbConnection::OpCompleteSuccess()
theNoOfOpCompleted = tNoComp;
if (tNoComp == tNoSent) { // Last operation completed
if (theSimpleState == 1) {
- theCommitStatus = Committed;
+ theCommitStatus = NdbConnection::Committed;
}//if
return 0;
} else if (tNoComp < tNoSent) {
@@ -1564,7 +1564,7 @@ NdbConnection::OpCompleteSuccess()
} else {
setOperationErrorCodeAbort(4113); // Too many operations,
// stop waiting for more
- theCompletionStatus = CompletedFailure;
+ theCompletionStatus = NdbConnection::CompletedFailure;
return 0;
}//if
}//NdbConnection::OpCompleteSuccess()
@@ -1577,7 +1577,7 @@ Remark: Get global checkpoint identity of the transaction
int
NdbConnection::getGCI()
{
- if (theCommitStatus == Committed) {
+ if (theCommitStatus == NdbConnection::Committed) {
return theGlobalCheckpointId;
}//if
return 0;
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 8a22d6a3c0f..7cbf35ab4fd 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -439,7 +439,7 @@ NdbScanOperation::executeCursor(int nodeId){
TRACE_DEBUG("The node is stopping when attempting to start a scan");
setErrorCode(4030);
}//if
- tCon->theCommitStatus = Aborted;
+ tCon->theCommitStatus = NdbConnection::Aborted;
}//if
return -1;
}
@@ -709,8 +709,8 @@ NdbScanOperation::execCLOSE_SCAN_REP(Uint32 errCode){
/**
* Normal termination
*/
- theNdbCon->theCommitStatus = Committed;
- theNdbCon->theCompletionStatus = CompletedSuccess;
+ theNdbCon->theCommitStatus = NdbConnection::Committed;
+ theNdbCon->theCompletionStatus = NdbConnection::CompletedSuccess;
} else {
/**
* Something is fishy
@@ -1111,7 +1111,7 @@ NdbIndexScanOperation::fix_get_values(){
NdbRecAttr * curr = theReceiver.theFirstRecAttr;
Uint32 cnt = m_sort_columns;
- assert(cnt < MAXNROFTUPLEKEY);
+ assert(cnt < NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY);
Uint32 idx = 0;
NdbTableImpl * tab = m_currentTable;
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index 60eda978397..f7d537dafa5 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -16,7 +16,6 @@
#include "NdbApiSignal.hpp"
-#include "AttrType.hpp"
#include "NdbImpl.hpp"
#include "NdbOperation.hpp"
#include "NdbIndexOperation.hpp"
@@ -255,8 +254,8 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
for (int i = tNoSentTransactions - 1; i >= 0; i--) {
NdbConnection* localCon = theSentTransactionsArray[i];
if (localCon->getConnectedNodeId() == aNodeId ) {
- const SendStatusType sendStatus = localCon->theSendStatus;
- if (sendStatus == sendTC_OP || sendStatus == sendTC_COMMIT) {
+ const NdbConnection::SendStatusType sendStatus = localCon->theSendStatus;
+ if (sendStatus == NdbConnection::sendTC_OP || sendStatus == NdbConnection::sendTC_COMMIT) {
/*
A transaction was interrupted in the prepare phase by a node
failure. Since the transaction was not found in the phase
@@ -264,13 +263,13 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
we report a normal node failure abort.
*/
localCon->setOperationErrorCodeAbort(4010);
- localCon->theCompletionStatus = CompletedFailure;
- } else if (sendStatus == sendTC_ROLLBACK) {
+ localCon->theCompletionStatus = NdbConnection::CompletedFailure;
+ } else if (sendStatus == NdbConnection::sendTC_ROLLBACK) {
/*
We aimed for abort and abort we got even if it was by a node
failure. We will thus report it as a success.
*/
- localCon->theCompletionStatus = CompletedSuccess;
+ localCon->theCompletionStatus = NdbConnection::CompletedSuccess;
} else {
#ifdef VM_TRACE
printState("abortTransactionsAfterNodeFailure %x", this);
@@ -282,7 +281,7 @@ Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
intact since the node was failing and they were aborted. Thus we
set commit state to Aborted and set state to release on close.
*/
- localCon->theCommitStatus = Aborted;
+ localCon->theCommitStatus = NdbConnection::Aborted;
localCon->theReleaseOnClose = true;
completedTransaction(localCon);
}//if
@@ -331,7 +330,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_OP)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_OP)) {
tReturnCode = tCon->receiveTCKEYCONF(keyConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -402,8 +401,8 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
if (tOp->checkMagicNumber() == 0) {
tCon = tOp->theNdbCon;
if (tCon != NULL) {
- if ((tCon->theSendStatus == sendTC_OP) ||
- (tCon->theSendStatus == sendTC_COMMIT)) {
+ if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
+ (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTCKEY_FAILCONF(failConf);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -429,8 +428,8 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
if (tOp->checkMagicNumber() == 0) {
tCon = tOp->theNdbCon;
if (tCon != NULL) {
- if ((tCon->theSendStatus == sendTC_OP) ||
- (tCon->theSendStatus == sendTC_ROLLBACK)) {
+ if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
+ (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCKEY_FAILREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -450,7 +449,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
if (tOp->checkMagicNumber() == 0) {
tCon = tOp->theNdbCon;
if (tCon != NULL) {
- if (tCon->theSendStatus == sendTC_OP) {
+ if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
tReturnCode = tOp->receiveTCKEYREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -472,7 +471,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_COMMIT)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTC_COMMITCONF(commitConf);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -497,7 +496,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_COMMIT)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTC_COMMITREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -513,7 +512,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_ROLLBACK)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCROLLBACKCONF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -528,7 +527,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_ROLLBACK)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCROLLBACKREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -762,7 +761,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
const BlockReference aTCRef = aSignal->theSendersBlockRef;
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
- (tCon->theSendStatus == sendTC_OP)) {
+ (tCon->theSendStatus == NdbConnection::sendTC_OP)) {
tReturnCode = tCon->receiveTCINDXCONF(indxConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -785,7 +784,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
if (tIndexOp->checkMagicNumber() == 0) {
tCon = tIndexOp->theNdbCon;
if (tCon != NULL) {
- if (tCon->theSendStatus == sendTC_OP) {
+ if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
tReturnCode = tIndexOp->receiveTCINDXREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
@@ -839,7 +838,7 @@ Ndb::completedTransaction(NdbConnection* aCon)
Uint32 tTransArrayIndex = aCon->theTransArrayIndex;
Uint32 tNoSentTransactions = theNoOfSentTransactions;
Uint32 tNoCompletedTransactions = theNoOfCompletedTransactions;
- if ((tNoSentTransactions > 0) && (aCon->theListState == InSendList) &&
+ if ((tNoSentTransactions > 0) && (aCon->theListState == NdbConnection::InSendList) &&
(tTransArrayIndex < tNoSentTransactions)) {
NdbConnection* tMoveCon = theSentTransactionsArray[tNoSentTransactions - 1];
@@ -853,7 +852,7 @@ Ndb::completedTransaction(NdbConnection* aCon)
theNoOfCompletedTransactions = tNoCompletedTransactions + 1;
theNoOfSentTransactions = tNoSentTransactions - 1;
- aCon->theListState = InCompletedList;
+ aCon->theListState = NdbConnection::InCompletedList;
aCon->handleExecuteCompletion();
if ((theMinNoOfEventsToWakeUp != 0) &&
(theNoOfCompletedTransactions >= theMinNoOfEventsToWakeUp)) {
@@ -888,7 +887,7 @@ Ndb::reportCallback(NdbConnection** aCopyArray, Uint32 aNoOfCompletedTrans)
NdbAsynchCallback aCallback = aCopyArray[i]->theCallbackFunction;
int tResult = 0;
if (aCallback != NULL) {
- if (aCopyArray[i]->theReturnStatus == ReturnFailure) {
+ if (aCopyArray[i]->theReturnStatus == NdbConnection::ReturnFailure) {
tResult = -1;
}//if
(*aCallback)(tResult, aCopyArray[i], anyObject);
@@ -912,13 +911,13 @@ Ndb::pollCompleted(NdbConnection** aCopyArray)
if (tNoCompletedTransactions > 0) {
for (i = 0; i < tNoCompletedTransactions; i++) {
aCopyArray[i] = theCompletedTransactionsArray[i];
- if (aCopyArray[i]->theListState != InCompletedList) {
+ if (aCopyArray[i]->theListState != NdbConnection::InCompletedList) {
ndbout << "pollCompleted error ";
ndbout << aCopyArray[i]->theListState << endl;
abort();
}//if
theCompletedTransactionsArray[i] = NULL;
- aCopyArray[i]->theListState = NotInList;
+ aCopyArray[i]->theListState = NdbConnection::NotInList;
}//for
}//if
theNoOfCompletedTransactions = 0;
@@ -940,8 +939,8 @@ Ndb::check_send_timeout()
a_con->printState();
#endif
a_con->setOperationErrorCodeAbort(4012);
- a_con->theCommitStatus = Aborted;
- a_con->theCompletionStatus = CompletedFailure;
+ a_con->theCommitStatus = NdbConnection::Aborted;
+ a_con->theCompletionStatus = NdbConnection::CompletedFailure;
a_con->handleExecuteCompletion();
remove_sent_list(i);
insert_completed_list(a_con);
@@ -970,7 +969,7 @@ Ndb::insert_completed_list(NdbConnection* a_con)
Uint32 no_of_comp = theNoOfCompletedTransactions;
theCompletedTransactionsArray[no_of_comp] = a_con;
theNoOfCompletedTransactions = no_of_comp + 1;
- a_con->theListState = InCompletedList;
+ a_con->theListState = NdbConnection::InCompletedList;
a_con->theTransArrayIndex = no_of_comp;
return no_of_comp;
}
@@ -981,7 +980,7 @@ Ndb::insert_sent_list(NdbConnection* a_con)
Uint32 no_of_sent = theNoOfSentTransactions;
theSentTransactionsArray[no_of_sent] = a_con;
theNoOfSentTransactions = no_of_sent + 1;
- a_con->theListState = InSendList;
+ a_con->theListState = NdbConnection::InSendList;
a_con->theTransArrayIndex = no_of_sent;
return no_of_sent;
}
@@ -1019,10 +1018,10 @@ Ndb::sendPrepTrans(int forceSend)
if ((tp->getNodeSequence(node_id) == a_con->theNodeSequence) &&
tp->get_node_alive(node_id) ||
(tp->get_node_stopping(node_id) &&
- ((a_con->theSendStatus == sendABORT) ||
- (a_con->theSendStatus == sendABORTfail) ||
- (a_con->theSendStatus == sendCOMMITstate) ||
- (a_con->theSendStatus == sendCompleted)))) {
+ ((a_con->theSendStatus == NdbConnection::sendABORT) ||
+ (a_con->theSendStatus == NdbConnection::sendABORTfail) ||
+ (a_con->theSendStatus == NdbConnection::sendCOMMITstate) ||
+ (a_con->theSendStatus == NdbConnection::sendCompleted)))) {
/*
We will send if
1) Node is alive and sequences are correct OR
@@ -1054,13 +1053,13 @@ Ndb::sendPrepTrans(int forceSend)
again and will thus set the state to Aborted to avoid a more or
less eternal loop of tries.
*/
- if (a_con->theSendStatus == sendOperations) {
+ if (a_con->theSendStatus == NdbConnection::sendOperations) {
a_con->setOperationErrorCodeAbort(4021);
- a_con->theCommitStatus = NeedAbort;
+ a_con->theCommitStatus = NdbConnection::NeedAbort;
TRACE_DEBUG("Send buffer full and sendOperations");
} else {
a_con->setOperationErrorCodeAbort(4026);
- a_con->theCommitStatus = Aborted;
+ a_con->theCommitStatus = NdbConnection::Aborted;
TRACE_DEBUG("Send buffer full, set state to Aborted");
}//if
}//if
@@ -1077,7 +1076,7 @@ Ndb::sendPrepTrans(int forceSend)
*/
TRACE_DEBUG("Abort a transaction when stopping a node");
a_con->setOperationErrorCodeAbort(4023);
- a_con->theCommitStatus = NeedAbort;
+ a_con->theCommitStatus = NdbConnection::NeedAbort;
} else {
/*
The node is hard dead and we cannot continue. We will also release
@@ -1087,10 +1086,10 @@ Ndb::sendPrepTrans(int forceSend)
a_con->setOperationErrorCodeAbort(4025);
a_con->theReleaseOnClose = true;
a_con->theTransactionIsStarted = false;
- a_con->theCommitStatus = Aborted;
+ a_con->theCommitStatus = NdbConnection::Aborted;
}//if
}//if
- a_con->theCompletionStatus = CompletedFailure;
+ a_con->theCompletionStatus = NdbConnection::CompletedFailure;
a_con->handleExecuteCompletion();
insert_completed_list(a_con);
}//for
From 3ee18c99eef7d1b802abc81008d2a7110ad98071 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Thu, 27 May 2004 21:54:35 +0200
Subject: [PATCH 003/579] Fix bank
---
ndb/test/ndbapi/Makefile.am | 2 -
ndb/test/ndbapi/bank/Bank.cpp | 102 +++++++++++++++---------------
ndb/test/ndbapi/bank/BankLoad.cpp | 12 ++--
ndb/test/ndbapi/testBackup.cpp | 5 --
ndb/test/ndbapi/testGrep.cpp | 8 +--
5 files changed, 58 insertions(+), 71 deletions(-)
diff --git a/ndb/test/ndbapi/Makefile.am b/ndb/test/ndbapi/Makefile.am
index f583823c87f..c79a613f32b 100644
--- a/ndb/test/ndbapi/Makefile.am
+++ b/ndb/test/ndbapi/Makefile.am
@@ -9,7 +9,6 @@ create_tab \
flexAsynch \
flexBench \
flexHammer \
-flexScan \
flexTT \
testBackup \
testBasic \
@@ -40,7 +39,6 @@ drop_all_tabs_SOURCES = drop_all_tabs.cpp
flexAsynch_SOURCES = flexAsynch.cpp
flexBench_SOURCES = flexBench.cpp
flexHammer_SOURCES = flexHammer.cpp
-flexScan_SOURCES = flexScan.cpp
flexTT_SOURCES = flexTT.cpp
#flexTimedAsynch_SOURCES = flexTimedAsynch.cpp
#flex_bench_mysql_SOURCES = flex_bench_mysql.cpp
diff --git a/ndb/test/ndbapi/bank/Bank.cpp b/ndb/test/ndbapi/bank/Bank.cpp
index 14883205693..7a2c5b057a1 100644
--- a/ndb/test/ndbapi/bank/Bank.cpp
+++ b/ndb/test/ndbapi/bank/Bank.cpp
@@ -670,15 +670,15 @@ int Bank::findLastGL(Uint64 &lastTime){
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("GL");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -698,7 +698,7 @@ int Bank::findLastGL(Uint64 &lastTime){
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -707,7 +707,7 @@ int Bank::findLastGL(Uint64 &lastTime){
int eof;
int rows = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
lastTime = 0;
while(eof == 0){
@@ -717,7 +717,7 @@ int Bank::findLastGL(Uint64 &lastTime){
if (t > lastTime)
lastTime = t;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -1002,15 +1002,15 @@ int Bank::sumTransactionsForGL(const Uint64 glTime,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("TRANSACTION");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanExclusive(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuplesExclusive();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1051,7 +1051,7 @@ int Bank::sumTransactionsForGL(const Uint64 glTime,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1061,7 +1061,7 @@ int Bank::sumTransactionsForGL(const Uint64 glTime,
int eof;
int rows = 0;
int rowsFound = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -1085,7 +1085,7 @@ int Bank::sumTransactionsForGL(const Uint64 glTime,
}
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
if ((rows % 100) == 0){
// "refresh" ownner transaction every 100th row
@@ -1162,15 +1162,15 @@ int Bank::performValidateGL(Uint64 glTime){
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("GL");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1238,7 +1238,7 @@ int Bank::performValidateGL(Uint64 glTime){
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1249,7 +1249,7 @@ int Bank::performValidateGL(Uint64 glTime){
int rows = 0;
int countGlRecords = 0;
int result = NDBT_OK;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -1336,7 +1336,7 @@ int Bank::performValidateGL(Uint64 glTime){
}
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -1426,15 +1426,15 @@ int Bank::getOldestPurgedGL(const Uint32 accountType,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("GL");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1468,7 +1468,7 @@ int Bank::getOldestPurgedGL(const Uint32 accountType,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1477,7 +1477,7 @@ int Bank::getOldestPurgedGL(const Uint32 accountType,
int eof;
int rows = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
oldest = 0;
while(eof == 0){
@@ -1491,7 +1491,7 @@ int Bank::getOldestPurgedGL(const Uint32 accountType,
if (t > oldest)
oldest = t;
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -1518,15 +1518,15 @@ int Bank::getOldestNotPurgedGL(Uint64 &oldest,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("GL");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1560,7 +1560,7 @@ int Bank::getOldestNotPurgedGL(Uint64 &oldest,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1569,7 +1569,7 @@ int Bank::getOldestNotPurgedGL(Uint64 &oldest,
int eof;
int rows = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
oldest = (Uint64)-1;
found = false;
@@ -1586,7 +1586,7 @@ int Bank::getOldestNotPurgedGL(Uint64 &oldest,
accountTypeId = a;
}
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -1615,15 +1615,15 @@ int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("TRANSACTION");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1657,7 +1657,7 @@ int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1667,7 +1667,7 @@ int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
int eof;
int rows = 0;
int found = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -1683,7 +1683,7 @@ int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
<< " ti = " << ti << endl;
found++;
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -1859,15 +1859,15 @@ int Bank::findTransactionsToPurge(const Uint64 glTime,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("TRANSACTION");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanExclusive(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuplesExclusive();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1894,7 +1894,7 @@ int Bank::findTransactionsToPurge(const Uint64 glTime,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -1904,7 +1904,7 @@ int Bank::findTransactionsToPurge(const Uint64 glTime,
int eof;
int rows = 0;
int rowsFound = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -1914,8 +1914,8 @@ int Bank::findTransactionsToPurge(const Uint64 glTime,
if (a == accountType && t == glTime){
rowsFound++;
// One record found
- NdbOperation* pDelOp = pOp->takeOverForDelete(pTrans);
- if (pDelOp == NULL){
+ check = rs->deleteTuple(pTrans);
+ if (check == -1){
ERR(m_ndb.getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -1929,7 +1929,7 @@ int Bank::findTransactionsToPurge(const Uint64 glTime,
return NDBT_FAILED;
}
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
@@ -2348,15 +2348,15 @@ int Bank::getSumAccounts(Uint32 &sumAccounts,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("ACCOUNT");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("ACCOUNT");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanExclusive(64);
- if( check == -1 ) {
+ NdbResultSet * rs = pOp->readTuplesExclusive();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -2376,7 +2376,7 @@ int Bank::getSumAccounts(Uint32 &sumAccounts,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -2391,7 +2391,7 @@ int Bank::getSumAccounts(Uint32 &sumAccounts,
}
int eof;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
Uint32 b = balanceRec->u_32_value();
@@ -2403,7 +2403,7 @@ int Bank::getSumAccounts(Uint32 &sumAccounts,
// << ", sum="<< sumAccounts << endl;
// Take over the operation so that the lock is kept in db
- NdbOperation* pLockOp = pOp->takeOverForUpdate(pTrans);
+ NdbOperation* pLockOp = rs->updateTuple(pTrans);
if (pLockOp == NULL){
ERR(m_ndb.getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -2429,7 +2429,7 @@ int Bank::getSumAccounts(Uint32 &sumAccounts,
return NDBT_FAILED;
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
diff --git a/ndb/test/ndbapi/bank/BankLoad.cpp b/ndb/test/ndbapi/bank/BankLoad.cpp
index 76261b664a6..bbaac27735b 100644
--- a/ndb/test/ndbapi/bank/BankLoad.cpp
+++ b/ndb/test/ndbapi/bank/BankLoad.cpp
@@ -335,15 +335,15 @@ int Bank::getBalanceForAccountType(const Uint32 accountType,
return NDBT_FAILED;
}
- NdbOperation* pOp = pScanTrans->getNdbOperation("ACCOUNT");
+ NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("ACCOUNT");
if (pOp == NULL) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
}
- check = pOp->openScanRead(64);
- if( check == -1 ) {
+ NdbResultSet* rs = pOp->readTuples();
+ if( rs == 0 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
return NDBT_FAILED;
@@ -370,7 +370,7 @@ int Bank::getBalanceForAccountType(const Uint32 accountType,
return NDBT_FAILED;
}
- check = pScanTrans->executeScan();
+ check = pScanTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pScanTrans->getNdbError());
m_ndb.closeTransaction(pScanTrans);
@@ -379,7 +379,7 @@ int Bank::getBalanceForAccountType(const Uint32 accountType,
int eof;
int rows = 0;
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
@@ -391,7 +391,7 @@ int Bank::getBalanceForAccountType(const Uint32 accountType,
balance += b;
}
- eof = pScanTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
ERR(pScanTrans->getNdbError());
diff --git a/ndb/test/ndbapi/testBackup.cpp b/ndb/test/ndbapi/testBackup.cpp
index 6641045942c..07355de2623 100644
--- a/ndb/test/ndbapi/testBackup.cpp
+++ b/ndb/test/ndbapi/testBackup.cpp
@@ -205,8 +205,6 @@ int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
-#if 0
-
#include "bank/Bank.hpp"
int runCreateBank(NDBT_Context* ctx, NDBT_Step* step){
@@ -395,7 +393,6 @@ int runRestoreBankAndVerify(NDBT_Context* ctx, NDBT_Step* step){
return result;
}
-#endif
NDBT_TESTSUITE(testBackup);
TESTCASE("BackupOne",
@@ -413,7 +410,6 @@ TESTCASE("BackupOne",
FINALIZER(runClearTable);
}
-#if 0
TESTCASE("BackupBank",
"Test that backup and restore works during transaction load\n"
" by backing up the bank"
@@ -433,7 +429,6 @@ TESTCASE("BackupBank",
VERIFIER(runRestoreBankAndVerify);
// FINALIZER(runDropBank);
}
-#endif
TESTCASE("NFMaster",
"Test that backup behaves during node failiure\n"){
INITIALIZER(setMaster);
diff --git a/ndb/test/ndbapi/testGrep.cpp b/ndb/test/ndbapi/testGrep.cpp
index b8966d15c5e..0bf84cb4ec8 100644
--- a/ndb/test/ndbapi/testGrep.cpp
+++ b/ndb/test/ndbapi/testGrep.cpp
@@ -254,9 +254,7 @@ int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
-#if 0
-
-#include "../bank/Bank.hpp"
+#include "bank/Bank.hpp"
int runCreateBank(NDBT_Context* ctx, NDBT_Step* step){
Bank bank;
@@ -445,7 +443,6 @@ int runRestoreBankAndVerify(NDBT_Context* ctx, NDBT_Step* step){
return result;
}
*/
-#endif
NDBT_TESTSUITE(testGrep);
TESTCASE("GrepBasic",
@@ -476,8 +473,6 @@ TESTCASE("GrepNodeRestart",
}
-#if 0
-
TESTCASE("GrepBank",
"Test that grep and restore works during transaction load\n"
" by backing up the bank"
@@ -498,7 +493,6 @@ TESTCASE("GrepBank",
// FINALIZER(runDropBank);
}
-#endif
TESTCASE("NFMaster",
"Test that grep behaves during node failiure\n"){
From a3b8d42b0bf623a45bc31118b61e535ce17e1f67 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Tue, 1 Jun 2004 13:28:29 +0200
Subject: [PATCH 004/579] Update error handling of new scan Still known bugs
:-(
---
ndb/include/kernel/signaldata/ScanTab.hpp | 4 +-
ndb/include/ndbapi/NdbConnection.hpp | 25 +-
ndb/include/ndbapi/NdbScanOperation.hpp | 2 +-
.../common/debugger/signaldata/ScanTab.cpp | 4 +-
ndb/src/kernel/blocks/dblqh/DblqhMain.cpp | 16 +-
ndb/src/kernel/blocks/dbtc/Dbtc.hpp | 20 +-
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 641 ++++++++++--------
ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp | 3 +
ndb/src/ndbapi/NdbConnectionScan.cpp | 16 +-
ndb/src/ndbapi/NdbScanOperation.cpp | 70 +-
ndb/src/ndbapi/Ndbif.cpp | 26 +-
11 files changed, 471 insertions(+), 356 deletions(-)
diff --git a/ndb/include/kernel/signaldata/ScanTab.hpp b/ndb/include/kernel/signaldata/ScanTab.hpp
index 6cef4381c07..1c11bdee4ae 100644
--- a/ndb/include/kernel/signaldata/ScanTab.hpp
+++ b/ndb/include/kernel/signaldata/ScanTab.hpp
@@ -367,7 +367,7 @@ public:
/**
* Length of signal
*/
- STATIC_CONST( SignalLength = 4 );
+ STATIC_CONST( SignalLength = 5 );
private:
@@ -380,7 +380,7 @@ private:
UintR transId1; // DATA 1
UintR transId2; // DATA 2
UintR errorCode; // DATA 3
- // UintR sendScanNextReqWithClose; // DATA 4
+ UintR closeNeeded; // DATA 4
};
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp
index 65f6bd2995f..bf5a4f6f0e5 100644
--- a/ndb/include/ndbapi/NdbConnection.hpp
+++ b/ndb/include/ndbapi/NdbConnection.hpp
@@ -633,17 +633,7 @@ private:
#ifdef VM_TRACE
void printState();
#endif
-
- bool checkState_TransId(const Uint32 * transId) const {
- const Uint32 tTmp1 = transId[0];
- const Uint32 tTmp2 = transId[1];
- Uint64 tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
- bool b = theStatus == Connected && theTransactionId == tRecTransId;
-#ifdef NDB_NO_DROPPED_SIGNAL
- if(!b) abort();
-#endif
- return b;
- }
+ bool checkState_TransId(const Uint32 * transId) const;
};
inline
@@ -678,6 +668,19 @@ NdbConnection::checkMagicNumber()
}
}
+inline
+bool
+NdbConnection::checkState_TransId(const Uint32 * transId) const {
+ const Uint32 tTmp1 = transId[0];
+ const Uint32 tTmp2 = transId[1];
+ Uint64 tRecTransId = (Uint64)tTmp1 + ((Uint64)tTmp2 << 32);
+ bool b = theStatus == Connected && theTransactionId == tRecTransId;
+#ifdef NDB_NO_DROPPED_SIGNAL
+ if(!b) abort();
+#endif
+ return b;
+}
+
/************************************************************************************************
void setTransactionId(Uint64 aTransactionId);
diff --git a/ndb/include/ndbapi/NdbScanOperation.hpp b/ndb/include/ndbapi/NdbScanOperation.hpp
index 8ff640dc6ec..a329505ef1b 100644
--- a/ndb/include/ndbapi/NdbScanOperation.hpp
+++ b/ndb/include/ndbapi/NdbScanOperation.hpp
@@ -146,7 +146,7 @@ protected:
int send_next_scan(Uint32 cnt, bool close);
void receiver_delivered(NdbReceiver*);
void receiver_completed(NdbReceiver*);
- void execCLOSE_SCAN_REP(Uint32 errCode);
+ void execCLOSE_SCAN_REP();
NdbOperation* takeOverScanOp(OperationType opType, NdbConnection*);
diff --git a/ndb/src/common/debugger/signaldata/ScanTab.cpp b/ndb/src/common/debugger/signaldata/ScanTab.cpp
index 776e9cf3bfc..b0383d6d6df 100644
--- a/ndb/src/common/debugger/signaldata/ScanTab.cpp
+++ b/ndb/src/common/debugger/signaldata/ScanTab.cpp
@@ -119,8 +119,8 @@ printSCANTABREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiv
sig->transId1, sig->transId2);
fprintf(output, " Errorcode: %u\n", sig->errorCode);
-
- // fprintf(output, " sendScanNextReqWithClose: %u\n", sig->sendScanNextReqWithClose);
+
+ fprintf(output, " closeNeeded: %u\n", sig->closeNeeded);
return false;
}
diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index 463a3d47354..2a744ea746a 100644
--- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -6785,7 +6785,8 @@ void Dblqh::execSCAN_NEXTREQ(Signal* signal)
if (findTransaction(transid1, transid2, senderData) != ZOK){
jam();
- DEBUG("Received SCAN_NEXTREQ in LQH with close flag when closed");
+ DEBUG(senderData <<
+ " Received SCAN_NEXTREQ in LQH with close flag when closed");
ndbrequire(nextReq->closeFlag == ZTRUE);
return;
}
@@ -6825,6 +6826,10 @@ void Dblqh::execSCAN_NEXTREQ(Signal* signal)
return;
}//if
+ if(ERROR_INSERTED(5036)){
+ return;
+ }
+
scanptr.i = tcConnectptr.p->tcScanRec;
ndbrequire(scanptr.i != RNIL);
c_scanRecordPool.getPtr(scanptr);
@@ -6841,6 +6846,10 @@ void Dblqh::execSCAN_NEXTREQ(Signal* signal)
if(ERROR_INSERTED(5034)){
CLEAR_ERROR_INSERT_VALUE;
}
+ if(ERROR_INSERTED(5036)){
+ CLEAR_ERROR_INSERT_VALUE;
+ return;
+ }
closeScanRequestLab(signal);
return;
}//if
@@ -8517,6 +8526,11 @@ void Dblqh::sendKeyinfo20(Signal* signal,
* ------------------------------------------------------------------------ */
void Dblqh::sendScanFragConf(Signal* signal, Uint32 scanCompleted)
{
+ if(ERROR_INSERTED(5037)){
+ CLEAR_ERROR_INSERT_VALUE;
+ return;
+ }
+
scanptr.p->scanTcWaiting = ZFALSE;
ScanFragConf * conf = (ScanFragConf*)&signal->theData[0];
diff --git a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
index 61e7e42621c..501cec1f231 100644
--- a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
+++ b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
@@ -1194,6 +1194,9 @@ public:
// Scan is on ordered index
Uint8 rangeScan;
+
+ // Close is ordered
+ bool m_close_scan_req;
};
typedef Ptr ScanRecordPtr;
@@ -1414,15 +1417,15 @@ private:
Uint32 buddyPtr,
UintR transid1,
UintR transid2);
- void initScanrec(Signal* signal,
+ void initScanrec(ScanRecordPtr, const class ScanTabReq*,
const UintR scanParallel,
const UintR noOprecPerFrag);
void initScanfragrec(Signal* signal);
void releaseScanResources(ScanRecordPtr);
- void seizeScanrec(Signal* signal);
- void sendScanFragReq(Signal* signal);
- void sendScanTabConf(Signal* signal);
- void close_scan_req(Signal*, ScanRecordPtr);
+ ScanRecordPtr seizeScanrec(Signal* signal);
+ void sendScanFragReq(Signal* signal, ScanRecord*, ScanFragRec*);
+ void sendScanTabConf(Signal* signal, ScanRecord*);
+ void close_scan_req(Signal*, ScanRecordPtr, bool received_req);
void close_scan_req_send_conf(Signal*, ScanRecordPtr);
void checkGcp(Signal* signal);
@@ -1557,11 +1560,11 @@ private:
void systemErrorLab(Signal* signal);
void sendSignalErrorRefuseLab(Signal* signal);
void scanTabRefLab(Signal* signal, Uint32 errCode);
- void diFcountReqLab(Signal* signal);
+ void diFcountReqLab(Signal* signal, ScanRecordPtr);
void signalErrorRefuseLab(Signal* signal);
void abort080Lab(Signal* signal);
void packKeyData000Lab(Signal* signal, BlockReference TBRef);
- void abortScanLab(Signal* signal, Uint32 errCode);
+ void abortScanLab(Signal* signal, ScanRecordPtr, Uint32 errCode);
void sendAbortedAfterTimeout(Signal* signal, int Tcheck);
void abort010Lab(Signal* signal);
void abort015Lab(Signal* signal);
@@ -1589,7 +1592,7 @@ private:
void attrinfo020Lab(Signal* signal);
void scanReleaseResourcesLab(Signal* signal);
void scanCompletedLab(Signal* signal);
- void scanFragError(Signal* signal, Uint32 errorCode);
+ void scanError(Signal* signal, ScanRecordPtr, Uint32 errorCode);
void diverify010Lab(Signal* signal);
void intstartphase2x010Lab(Signal* signal);
void intstartphase3x010Lab(Signal* signal);
@@ -1699,7 +1702,6 @@ private:
ApiConnectRecordPtr timeOutptr;
ScanRecord *scanRecord;
- ScanRecordPtr scanptr;
UintR cscanrecFileSize;
UnsafeArrayPool c_scan_frag_pool;
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index edb51ea3c89..04506bc62eb 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -76,6 +76,39 @@
#define INTERNAL_TRIGGER_TCKEYREQ_JBA 0
+#ifdef VM_TRACE
+NdbOut &
+operator<<(NdbOut& out, Dbtc::ConnectionState state){
+ out << (int)state;
+ return out;
+}
+NdbOut &
+operator<<(NdbOut& out, Dbtc::OperationState state){
+ out << (int)state;
+ return out;
+}
+NdbOut &
+operator<<(NdbOut& out, Dbtc::AbortState state){
+ out << (int)state;
+ return out;
+}
+NdbOut &
+operator<<(NdbOut& out, Dbtc::ReturnSignal state){
+ out << (int)state;
+ return out;
+}
+NdbOut &
+operator<<(NdbOut& out, Dbtc::ScanRecord::ScanState state){
+ out << (int)state;
+ return out;
+}
+NdbOut &
+operator<<(NdbOut& out, Dbtc::ScanFragRec::ScanFragState state){
+ out << (int)state;
+ return out;
+}
+#endif
+
void
Dbtc::updateBuddyTimer(ApiConnectRecordPtr apiPtr)
{
@@ -915,7 +948,7 @@ Dbtc::handleFailedApiNode(Signal* signal,
ScanRecordPtr scanPtr;
scanPtr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanPtr, cscanrecFileSize, scanRecord);
- close_scan_req(signal, scanPtr);
+ close_scan_req(signal, scanPtr, true);
TloopCount += 64;
break;
@@ -1095,138 +1128,6 @@ void Dbtc::handleApiFailState(Signal* signal, UintR TapiConnectptr)
}//if
}//Dbtc::handleApiFailState()
-/**
- * Dbtc::handleScanStop
- * This function is called when an entire scan should be stopped
- * Check state of the scan and take appropriate action.
- * The parameter TapiFailedNode indicates if the scan is stopped
- * because an API node has failed or if it has been stopped because
- * the scan has timed out.
- *
- */
-void Dbtc::handleScanStop(Signal* signal, UintR TapiFailedNode)
-{
-#if JONAS_NOT_DONE
- arrGuard(TapiFailedNode, MAX_NODES);
-
- scanptr.i = apiConnectptr.p->apiScanRec;
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
-
- // If api has failed we must release all resources
- bool apiNodeHasFailed = (TapiFailedNode != 0);
-
- DEBUG("handleScanStop: scanState = "<< scanptr.p->scanState);
-
- switch (scanptr.p->scanState) {
- case ScanRecord::WAIT_SCAN_TAB_INFO:
- case ScanRecord::WAIT_AI:
- jam();
- /**
- * The scan process is still in the definition phase.
- * We will release the resources and then release the connection
- * to the failed API.
- */
- releaseScanResources(scanptr);
- if (apiNodeHasFailed) {
- jam();
- releaseApiCon(signal, apiConnectptr.i);
- }//if
- break;
-
- case ScanRecord::WAIT_FRAGMENT_COUNT:
- jam();
- if (!apiNodeHasFailed) {
- jam();
- /**
- * Time-out waiting for a local signal can only happen
- * if we have a serious problem.
- */
- systemErrorLab(signal);
- }//if
- capiConnectClosing[TapiFailedNode]++;
- apiConnectptr.p->apiFailState = ZTRUE;
- scanptr.p->apiIsClosed = true;
- break;
-
- case ScanRecord::CLOSING_SCAN:
- jam();
- /**
- * With CLOSING_SCAN it is enough to set the
- * fail state such that the connection is released at the end of the
- * closing process. The close process is already ongoing.
- * Set apiIsClosed to true to indicate that resources should be released
- * at the end of the close process.
- **/
-
- if (apiNodeHasFailed) {
- jam();
- capiConnectClosing[TapiFailedNode]++;
- apiConnectptr.p->apiFailState = ZTRUE;
- scanptr.p->apiIsClosed = true;
- }//if
- if (apiConnectptr.p->apiFailState == ZTRUE) {
- jam();
- handleApiFailState(signal, apiConnectptr.i);
- return;
- }//if
- break;
-
- case ScanRecord::SCAN_NEXT_ORDERED:
- /**
- * In the SCAN_NEXT_ORDERED state we will wait for the next natural place
- * to receive some action from the API and instead of waiting for the
- * API here we will start the abort process.
-
- * After the abort process is completed we will release the connection.
- */
- if (apiNodeHasFailed) {
- jam();
- capiConnectClosing[TapiFailedNode]++;
- apiConnectptr.p->apiFailState = ZTRUE;
- }//if
- // Release resources and send a response to API
- scanptr.p->apiIsClosed = true;
- scanCompletedLab(signal);
- break;
-
- case ScanRecord::DELIVERED:
- case ScanRecord::QUEUED_DELIVERED:
- /**
- * A response has been sent to the api but it has not responded
- */
-
- if (apiNodeHasFailed) {
- jam();
- capiConnectClosing[TapiFailedNode]++;
- apiConnectptr.p->apiFailState = ZTRUE;
- scanptr.p->apiIsClosed = true;
- } else {
- jam();
- /*
- In this case we have received a time-out caused by the application
- waiting too long to continue the scan. We will check the application
- time-out instead of the deadlock detetection time-out. If the
- application time-out hasn't fired we will simply ignore the condition.
- */
- if ((ctcTimer - getApiConTimer(apiConnectptr.i)) <= c_appl_timeout_value) {
- jam();
- return;
- }//if
- // Dont' release, wait until api responds or fails
- scanptr.p->apiIsClosed = false;
- }
- scanCompletedLab(signal);
- break;
-
- default:
- jam();
- systemErrorLab(signal);
- break;
-
- }//switch
-#endif
-}//Dbtc::handleScanStop()
-
/****************************************************************************
* T C S E I Z E R E Q
* THE APPLICATION SENDS A REQUEST TO SEIZE A CONNECT RECORD TO CARRY OUT A
@@ -1409,7 +1310,7 @@ void Dbtc::printState(Signal* signal, int place)
<< " counter = " << apiConnectptr.p->counter
<< " lqhkeyconfrec = " << apiConnectptr.p->lqhkeyconfrec
<< " lqhkeyreqrec = " << apiConnectptr.p->lqhkeyreqrec << endl;
- ndbout << "abortState = " << (int)apiConnectptr.p->abortState
+ ndbout << "abortState = " << apiConnectptr.p->abortState
<< " apiScanRec = " << apiConnectptr.p->apiScanRec
<< " returncode = " << apiConnectptr.p->returncode << endl;
ndbout << "tckeyrec = " << apiConnectptr.p->tckeyrec
@@ -6155,11 +6056,14 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
tcConnectptr.i = apiConnectptr.p->firstTcConnect;
sendAbortedAfterTimeout(signal, 0);
break;
- case CS_START_SCAN:
+ case CS_START_SCAN:{
jam();
- apiConnectptr.p->returncode = ZSCANTIME_OUT_ERROR;
- handleScanStop(signal, 0);
+ ScanRecordPtr scanPtr;
+ scanPtr.i = apiConnectptr.p->apiScanRec;
+ ptrCheckGuard(scanPtr, cscanrecFileSize, scanRecord);
+ scanError(signal, scanPtr, ZSCANTIME_OUT_ERROR);
break;
+ }
case CS_WAIT_ABORT_CONF:
jam();
tcConnectptr.i = apiConnectptr.p->currentTcConnect;
@@ -6529,14 +6433,15 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
c_scan_frag_pool.getPtr(scanFragptr);
switch (scanFragptr.p->scanFragState){
case ScanFragRec::LQH_ACTIVE:
+ //case ScanFragRec::LQH_ACTIVE_CLOSE:
break;
-
default:
DEBUG("execSCAN_HBREP: scanFragState="<scanFragState);
systemErrorLab(signal);
break;
}
+ ScanRecordPtr scanptr;
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -6567,6 +6472,7 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
updateBuddyTimer(apiConnectptr);
scanFragptr.p->startFragTimer(ctcTimer);
} else {
+ ndbassert(false);
DEBUG("SCAN_HBREP when scanFragTimer was turned off");
}
}//execSCAN_HBREP()
@@ -6575,34 +6481,56 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
/* Timeout has occured on a fragment which means a scan has timed out. */
/* If this is true we have an error in LQH/ACC. */
/*--------------------------------------------------------------------------*/
+static int kalle = 0;
void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
{
- scanFragptr.i = TscanConPtr;
- c_scan_frag_pool.getPtr(scanFragptr);
- DEBUG("timeOutFoundFragLab: scanFragState = "<scanFragState);
+ ScanFragRecPtr ptr;
+ c_scan_frag_pool.getPtr(ptr, TscanConPtr);
+ DEBUG(TscanConPtr << " timeOutFoundFragLab: scanFragState = "<< ptr.p->scanFragState);
/*-------------------------------------------------------------------------*/
// The scan fragment has expired its timeout. Check its state to decide
// what to do.
/*-------------------------------------------------------------------------*/
- switch (scanFragptr.p->scanFragState) {
-
+ switch (ptr.p->scanFragState) {
case ScanFragRec::WAIT_GET_PRIMCONF:
jam();
- // Crash the system if we do not return from DIGETPRIMREQ in time.
- systemErrorLab(signal);
+ ndbrequire(false);
break;
-
- case ScanFragRec::LQH_ACTIVE:
+ case ScanFragRec::LQH_ACTIVE:{
jam();
+
/**
* The LQH expired it's timeout, try to close it
*/
- scanFragError(signal, ZSCAN_FRAG_LQH_ERROR);
- DEBUG(" LQH_ACTIVE - closing the fragment scan in node "
- << refToNode(scanFragptr.p->lqhBlockref));
- break;
+ Uint32 nodeId = refToNode(ptr.p->lqhBlockref);
+ Uint32 connectCount = getNodeInfo(nodeId).m_connectCount;
+ ScanRecordPtr scanptr;
+ scanptr.i = ptr.p->scanRec;
+ ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
+
+ if(connectCount != ptr.p->m_connectCount){
+ jam();
+ /**
+ * The node has died
+ */
+ ndbout_c("Node %d has died", nodeId);
+ ptr.p->scanFragState = ScanFragRec::COMPLETED;
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(ptr);
+ comp.add(ptr);
+ ptr.p->stopFragTimer();
+ } else {
+ kalle++;
+ if(kalle > 5)
+ ndbassert(scanptr.p->scanState != ScanRecord::CLOSING_SCAN);
+ }
+ scanError(signal, scanptr, ZSCAN_FRAG_LQH_ERROR);
+ break;
+ }
case ScanFragRec::DELIVERED:
jam();
case ScanFragRec::IDLE:
@@ -6863,14 +6791,38 @@ void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
Uint32 scanPtrI,
Uint32 failedNodeId){
+ ScanRecordPtr scanptr;
for (scanptr.i = scanPtrI; scanptr.i < cscanrecFileSize; scanptr.i++) {
jam();
ptrAss(scanptr, scanRecord);
if (scanptr.p->scanState != ScanRecord::IDLE){
- checkScanFragList(signal, failedNodeId,
- scanptr.p, scanptr.p->m_running_scan_frags);
- }
+ jam();
+ ScanFragRecPtr ptr;
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+ bool found = false;
+ for(run.first(ptr); !ptr.isNull(); ){
+ jam();
+ ScanFragRecPtr curr = ptr;
+ run.next(ptr);
+ if (curr.p->scanFragState == ScanFragRec::LQH_ACTIVE &&
+ refToNode(curr.p->lqhBlockref) == failedNodeId){
+ jam();
+
+ run.remove(curr);
+ comp.add(curr);
+ curr.p->scanFragState = ScanFragRec::COMPLETED;
+ curr.p->stopFragTimer();
+ found = true;
+ }
+ }
+ if(found){
+ jam();
+ scanError(signal, scanptr, ZSCAN_LQH_ERROR);
+ }
+ }
+
// Send CONTINUEB to continue later
signal->theData[0] = TcContinueB::ZCHECK_SCAN_ACTIVE_FAILED_LQH;
signal->theData[1] = scanptr.i + 1; // Check next scanptr
@@ -6886,29 +6838,7 @@ Dbtc::checkScanFragList(Signal* signal,
ScanRecord * scanP,
ScanFragList::Head & head){
- ScanFragRecPtr ptr;
- ScanFragList list(c_scan_frag_pool, head);
-
- for(list.first(ptr); !ptr.isNull(); list.next(ptr)){
- if (refToNode(ptr.p->lqhBlockref) == failedNodeId){
- switch (ptr.p->scanFragState){
- case ScanFragRec::LQH_ACTIVE:
- jam();
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize,
- apiConnectRecord);
-
- DEBUG("checkScanActiveInFailedLqh: scanFragError");
- scanFragError(signal, ZSCAN_LQH_ERROR);
-
- break;
- default:
- /* empty */
- jam();
- break;
- }
- }
- }
+ DEBUG("checkScanActiveInFailedLqh: scanFragError");
}
void Dbtc::execTAKE_OVERTCCONF(Signal* signal)
@@ -8421,6 +8351,7 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
Uint32 noOprecPerFrag = ScanTabReq::getScanBatch(reqinfo);
Uint32 scanParallel = scanConcurrency;
Uint32 errCode;
+ ScanRecordPtr scanptr;
if(noOprecPerFrag == 0){
jam();
@@ -8445,12 +8376,13 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
return;
}//if
ptrAss(apiConnectptr, apiConnectRecord);
+ ApiConnectRecord * transP = apiConnectptr.p;
- if (apiConnectptr.p->apiConnectstate != CS_CONNECTED) {
+ if (transP->apiConnectstate != CS_CONNECTED) {
jam();
// could be left over from TCKEYREQ rollback
- if (apiConnectptr.p->apiConnectstate == CS_ABORTING &&
- apiConnectptr.p->abortState == AS_IDLE) {
+ if (transP->apiConnectstate == CS_ABORTING &&
+ transP->abortState == AS_IDLE) {
jam();
} else {
jam();
@@ -8515,15 +8447,26 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
}
seizeTcConnect(signal);
- seizeCacheRecord(signal);
- seizeScanrec(signal);
- initScanrec(signal, scanParallel, noOprecPerFrag);
tcConnectptr.p->apiConnect = apiConnectptr.i;
- initScanApirec(signal, buddyPtr, transid1, transid2);
+
+ seizeCacheRecord(signal);
+ scanptr = seizeScanrec(signal);
+
+ ndbrequire(transP->apiScanRec == RNIL);
+ ndbrequire(scanptr.p->scanApiRec == RNIL);
+
+ initScanrec(scanptr, scanTabReq, scanParallel, noOprecPerFrag);
+
+ //initScanApirec(signal, buddyPtr, transid1, transid2);
+ transP->apiScanRec = scanptr.i;
+ transP->returncode = 0;
+ transP->transid[0] = transid1;
+ transP->transid[1] = transid2;
+ transP->buddyPtr = buddyPtr;
// The scan is started
- apiConnectptr.p->apiConnectstate = CS_START_SCAN;
- apiConnectptr.p->currSavePointId = currSavePointId;
+ transP->apiConnectstate = CS_START_SCAN;
+ transP->currSavePointId = currSavePointId;
/**********************************************************
* We start the timer on scanRec to be able to discover a
@@ -8546,12 +8489,14 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
SCAN_TAB_error:
jam();
+ ndbrequire(false);
ScanTabRef * ref = (ScanTabRef*)&signal->theData[0];
- ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
+ ref->apiConnectPtr = transP->ndbapiConnect;
ref->transId1 = transid1;
ref->transId2 = transid2;
ref->errorCode = errCode;
- sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABREF,
+ ref->closeNeeded = 0;
+ sendSignal(transP->ndbapiBlockref, GSN_SCAN_TABREF,
signal, ScanTabRef::SignalLength, JBB);
return;
@@ -8561,20 +8506,13 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
void Dbtc::initScanApirec(Signal* signal,
Uint32 buddyPtr, UintR transid1, UintR transid2)
{
- ApiConnectRecord * apiPtr = apiConnectptr.p;
- apiPtr->apiScanRec = scanptr.i;
- apiPtr->returncode = 0;
- apiPtr->transid[0] = transid1;
- apiPtr->transid[1] = transid2;
- apiPtr->buddyPtr = buddyPtr;
-
}//Dbtc::initScanApirec()
-void Dbtc::initScanrec(Signal* signal,
+void Dbtc::initScanrec(ScanRecordPtr scanptr,
+ const ScanTabReq * scanTabReq,
UintR scanParallel,
UintR noOprecPerFrag)
{
- const ScanTabReq * const scanTabReq = (ScanTabReq *)&signal->theData[0];
const UintR reqinfo = scanTabReq->requestInfo;
ndbrequire(scanParallel < 16);
@@ -8613,6 +8551,7 @@ void Dbtc::scanTabRefLab(Signal* signal, Uint32 errCode)
ref->transId1 = apiConnectptr.p->transid[0];
ref->transId2 = apiConnectptr.p->transid[1];
ref->errorCode = errCode;
+ ref->closeNeeded = 0;
sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABREF,
signal, ScanTabRef::SignalLength, JBB);
}//Dbtc::scanTabRefLab()
@@ -8623,6 +8562,7 @@ void Dbtc::scanTabRefLab(Signal* signal, Uint32 errCode)
/*---------------------------------------------------------------------------*/
void Dbtc::scanAttrinfoLab(Signal* signal, UintR Tlen)
{
+ ScanRecordPtr scanptr;
scanptr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
tcConnectptr.i = scanptr.p->scanTcrec;
@@ -8652,7 +8592,7 @@ void Dbtc::scanAttrinfoLab(Signal* signal, UintR Tlen)
* THIS SCAN. WE ARE READY TO START THE ACTUAL
* EXECUTION OF THE SCAN QUERY
**************************************************/
- diFcountReqLab(signal);
+ diFcountReqLab(signal, scanptr);
return;
}//if
}//if
@@ -8660,21 +8600,21 @@ void Dbtc::scanAttrinfoLab(Signal* signal, UintR Tlen)
scanAttrinfo_attrbuf_error:
jam();
- abortScanLab(signal, ZGET_ATTRBUF_ERROR);
+ abortScanLab(signal, scanptr, ZGET_ATTRBUF_ERROR);
return;
scanAttrinfo_attrbuf2_error:
jam();
- abortScanLab(signal, ZGET_ATTRBUF_ERROR);
+ abortScanLab(signal, scanptr, ZGET_ATTRBUF_ERROR);
return;
scanAttrinfo_len_error:
jam();
- abortScanLab(signal, ZLENGTH_ERROR);
+ abortScanLab(signal, scanptr, ZLENGTH_ERROR);
return;
}//Dbtc::scanAttrinfoLab()
-void Dbtc::diFcountReqLab(Signal* signal)
+void Dbtc::diFcountReqLab(Signal* signal, ScanRecordPtr scanptr)
{
/**
* Check so that the table is not being dropped
@@ -8685,7 +8625,8 @@ void Dbtc::diFcountReqLab(Signal* signal)
if (tabPtr.p->checkTable(scanptr.p->scanSchemaVersion)){
;
} else {
- abortScanLab(signal, tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion));
+ abortScanLab(signal, scanptr,
+ tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion));
return;
}
@@ -8717,6 +8658,7 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
apiConnectptr.i = tcConnectptr.p->apiConnect;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
+ ScanRecordPtr scanptr;
scanptr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT);
@@ -8728,7 +8670,7 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
}//if
if (tfragCount == 0) {
jam();
- abortScanLab(signal, ZNO_FRAGMENT_ERROR);
+ abortScanLab(signal, scanptr, ZNO_FRAGMENT_ERROR);
return;
}//if
@@ -8741,19 +8683,22 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
if (tabPtr.p->checkTable(scanptr.p->scanSchemaVersion)){
;
} else {
- abortScanLab(signal, tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion));
+ abortScanLab(signal, scanptr,
+ tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion));
return;
}
if(scanptr.p->scanParallel > tfragCount){
jam();
- abortScanLab(signal, ZTOO_HIGH_CONCURRENCY_ERROR);
+ abortScanLab(signal, scanptr, ZTOO_HIGH_CONCURRENCY_ERROR);
return;
}
scanptr.p->scanParallel = tfragCount;
scanptr.p->scanNoFrag = tfragCount;
scanptr.p->scanNextFragId = 0;
+ scanptr.p->scanState = ScanRecord::RUNNING;
+
setApiConTimer(apiConnectptr.i, 0, __LINE__);
updateBuddyTimer(apiConnectptr);
@@ -8768,6 +8713,7 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
scanptr.p->scanTableref, scanptr.p->scanNextFragId);
#endif
+ ptr.p->lqhBlockref = 0;
ptr.p->startFragTimer(ctcTimer);
ptr.p->scanFragId = scanptr.p->scanNextFragId++;
ptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF;
@@ -8792,6 +8738,7 @@ void Dbtc::execDI_FCOUNTREF(Signal* signal)
const Uint32 errCode = signal->theData[1];
apiConnectptr.i = tcConnectptr.p->apiConnect;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
+ ScanRecordPtr scanptr;
scanptr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT);
@@ -8801,10 +8748,10 @@ void Dbtc::execDI_FCOUNTREF(Signal* signal)
handleApiFailState(signal, apiConnectptr.i);
return;
}//if
- abortScanLab(signal, errCode);
+ abortScanLab(signal, scanptr, errCode);
}//Dbtc::execDI_FCOUNTREF()
-void Dbtc::abortScanLab(Signal* signal, Uint32 errCode)
+void Dbtc::abortScanLab(Signal* signal, ScanRecordPtr scanptr, Uint32 errCode)
{
scanTabRefLab(signal, errCode);
releaseScanResources(scanptr);
@@ -8835,6 +8782,7 @@ void Dbtc::releaseScanResources(ScanRecordPtr scanPtr)
scanPtr.p->nextScan = cfirstfreeScanrec;
scanPtr.p->scanState = ScanRecord::IDLE;
scanPtr.p->scanTcrec = RNIL;
+ scanPtr.p->scanApiRec = RNIL;
cfirstfreeScanrec = scanPtr.i;
apiConnectptr.p->apiScanRec = RNIL;
@@ -8862,7 +8810,8 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF);
scanFragptr.p->stopFragTimer();
-
+
+ ScanRecordPtr scanptr;
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -8876,7 +8825,12 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
Uint32 schemaVersion = scanptr.p->scanSchemaVersion;
if(tabPtr.p->checkTable(schemaVersion) == false){
jam();
- scanFragError(signal, tabPtr.p->getErrorCode(schemaVersion));
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(scanFragptr);
+ comp.add(scanFragptr);
+ scanError(signal, scanptr, tabPtr.p->getErrorCode(schemaVersion));
return;
}
}
@@ -8908,7 +8862,7 @@ void Dbtc::execDIGETPRIMCONF(Signal* signal)
Uint32 ref = calcLqhBlockRef(tnodeid);
scanFragptr.p->lqhBlockref = ref;
scanFragptr.p->m_connectCount = getNodeInfo(tnodeid).m_connectCount;
- sendScanFragReq(signal);
+ sendScanFragReq(signal, scanptr.p, scanFragptr.p);
attrbufptr.i = cachePtr.p->firstAttrbuf;
while (attrbufptr.i != RNIL) {
jam();
@@ -8943,7 +8897,18 @@ void Dbtc::execDIGETPRIMREF(Signal* signal)
const Uint32 errCode = signal->theData[2];
c_scan_frag_pool.getPtr(scanFragptr);
ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF);
- scanFragError(signal, errCode);
+
+ ScanRecordPtr scanptr;
+ scanptr.i = scanFragptr.p->scanRec;
+ ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
+
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(scanFragptr);
+ comp.add(scanFragptr);
+
+ scanError(signal, scanptr, errCode);
}//Dbtc::execDIGETPRIMREF()
/**
@@ -8962,6 +8927,7 @@ void Dbtc::execSCAN_FRAGREF(Signal* signal)
scanFragptr.i = ref->senderData;
c_scan_frag_pool.getPtr(scanFragptr);
+ ScanRecordPtr scanptr;
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -8981,42 +8947,64 @@ void Dbtc::execSCAN_FRAGREF(Signal* signal)
* stop fragment timer and call scanFragError to start
* close of the other fragment scans
*/
- scanFragError(signal, errCode);
+ ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::LQH_ACTIVE);
+ {
+ scanFragptr.p->scanFragState = ScanFragRec::COMPLETED;
+ ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
+ ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
+
+ run.remove(scanFragptr);
+ comp.add(scanFragptr);
+ scanFragptr.p->stopFragTimer();
+ }
+ scanError(signal, scanptr, errCode);
}//Dbtc::execSCAN_FRAGREF()
/**
- * Dbtc::scanFragError
+ * Dbtc::scanError
*
* Called when an error occurs during
- * a scan of a fragment.
- * NOTE that one scan may consist of several fragment scans.
- *
*/
-void Dbtc::scanFragError(Signal* signal, Uint32 errorCode)
+void Dbtc::scanError(Signal* signal, ScanRecordPtr scanptr, Uint32 errorCode)
{
jam();
- scanptr.i = scanFragptr.p->scanRec;
- ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
- DEBUG("scanFragError, errorCode = "<< errorCode
- << ", scanState = " << scanptr.p->scanState);
+ ScanRecord* scanP = scanptr.p;
+
+ DEBUG("scanError, errorCode = "<< errorCode <<
+ ", scanState = " << scanptr.p->scanState);
- scanFragptr.p->stopFragTimer();
-#if JONAS_NOT_DONE
-
- apiConnectptr.i = scanptr.p->scanApiRec;
- ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
-
- // If close of the scan is not already started
- if (scanptr.p->scanState != ScanRecord::CLOSING_SCAN) {
+ if(scanP->scanState == ScanRecord::CLOSING_SCAN){
jam();
- apiConnectptr.p->returncode = errorCode;
-
- scanCompletedLab(signal);
+ close_scan_req_send_conf(signal, scanptr);
return;
- }//if
-#endif
-}//Dbtc::scanFragError()
+ }
+ ndbrequire(scanP->scanState == ScanRecord::RUNNING);
+
+ apiConnectptr.i = scanP->scanApiRec;
+ ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
+ ndbrequire(apiConnectptr.p->apiScanRec == scanptr.i);
+
+ /**
+ * Close scan wo/ having received an order to do so
+ */
+ close_scan_req(signal, scanptr, false);
+
+ const bool apiFail = (apiConnectptr.p->apiFailState == ZTRUE);
+ if(apiFail){
+ jam();
+ return;
+ }
+
+ ScanTabRef * ref = (ScanTabRef*)&signal->theData[0];
+ ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
+ ref->transId1 = apiConnectptr.p->transid[0];
+ ref->transId2 = apiConnectptr.p->transid[1];
+ ref->errorCode = errorCode;
+ ref->closeNeeded = 1;
+ sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABREF,
+ signal, ScanTabRef::SignalLength, JBB);
+}//Dbtc::scanError()
/************************************************************
* execSCAN_FRAGCONF
@@ -9034,6 +9022,7 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
scanFragptr.i = conf->senderData;
c_scan_frag_pool.getPtr(scanFragptr);
+ ScanRecordPtr scanptr;
scanptr.i = scanFragptr.p->scanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
@@ -9051,32 +9040,34 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::LQH_ACTIVE);
const Uint32 status = conf->fragmentCompleted;
- scanFragptr.p->stopFragTimer();
-
+
+ DEBUG(apiConnectptr.i << " " << scanFragptr.i <<
+ " execSCAN_FRAGCONF() status: " << status
+ << " ops: " << noCompletedOps << " from: " << refToNode(signal->getSendersBlockRef()));
+
if(scanptr.p->scanState == ScanRecord::CLOSING_SCAN){
+ jam();
if(status == ZFALSE){
/**
- * Dont deliver to api, but instead close in LQH
- * Dont need to mess with queues
+ * We have started closing = we sent a close -> ignore this
*/
- ndbout_c("running -> running(close)");
-
- jam();
- ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
- nextReq->senderData = scanFragptr.i;
- nextReq->closeFlag = ZTRUE;
- nextReq->transId1 = apiConnectptr.p->transid[0];
- nextReq->transId2 = apiConnectptr.p->transid[1];
- sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
- ScanFragNextReq::SignalLength, JBB);
+ DEBUG(apiConnectptr.i << " " << scanFragptr.i <<
+ " Received SCANFRAG_CONF wo/ close when in "
+ " CLOSING_SCAN:" << status << " " << noCompletedOps);
return;
} else {
jam();
+ DEBUG(apiConnectptr.i << " " << scanFragptr.i
+ << " Received SCANFRAG_CONF w/ close when in "
+ " CLOSING_SCAN:" << status << " " << noCompletedOps);
+
ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
run.remove(scanFragptr);
comp.add(scanFragptr);
+ scanFragptr.p->stopFragTimer();
+ scanFragptr.p->scanFragState = ScanFragRec::COMPLETED;
}
close_scan_req_send_conf(signal, scanptr);
return;
@@ -9126,7 +9117,7 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
if(scanptr.p->m_queued_count > /** Min */ 0){
jam();
- sendScanTabConf(signal);
+ sendScanTabConf(signal, scanptr.p);
}
}//Dbtc::execSCAN_FRAGCONF()
@@ -9164,6 +9155,7 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
ref->transId1 = transid1;
ref->transId2 = transid2;
ref->errorCode = ZSTATE_ERROR;
+ ref->closeNeeded = 0;
sendSignal(signal->senderBlockRef(), GSN_SCAN_TABREF,
signal, ScanTabRef::SignalLength, JBB);
DEBUG("Wrong transid");
@@ -9188,6 +9180,7 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
}
DEBUG("scanTabRefLab: ZSTATE_ERROR");
DEBUG(" apiConnectstate="<apiConnectstate);
+ ndbrequire(false); //B2 indication of strange things going on
scanTabRefLab(signal, ZSTATE_ERROR);
return;
}//if
@@ -9197,6 +9190,7 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
********************************************************/
// Stop the timer that is used to check for timeout in the API
setApiConTimer(apiConnectptr.i, 0, __LINE__);
+ ScanRecordPtr scanptr;
scanptr.i = apiConnectptr.p->apiScanRec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
ScanRecord* scanP = scanptr.p;
@@ -9209,10 +9203,21 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
* APPLICATION IS CLOSING THE SCAN.
**********************************************************************/
ndbrequire(len == 0);
- close_scan_req(signal, scanptr);
+ close_scan_req(signal, scanptr, true);
return;
}//if
+ if (scanptr.p->scanState == ScanRecord::CLOSING_SCAN){
+ jam();
+ /**
+ * The scan is closing (typically due to error)
+ * but the API hasn't understood it yet
+ *
+ * Wait for API close request
+ */
+ return;
+ }
+
// Copy op ptrs so I dont overwrite them when sending...
memcpy(signal->getDataPtrSend()+25, signal->getDataPtr()+4, 4 * len);
@@ -9243,26 +9248,25 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
}//Dbtc::execSCAN_NEXTREQ()
void
-Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr){
+Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr, bool req_received){
#ifdef VM_TRACE
ndbout_c("%d close_scan_req", apiConnectptr.i);
#endif
ScanRecord* scanP = scanPtr.p;
scanPtr.p->scanState = ScanRecord::CLOSING_SCAN;
+ scanPtr.p->m_close_scan_req = req_received;
/**
- * Queue : Action
- * ========== : =================
- * completed : -
- * running : -
- * delivered : close -> LQH
- * queued w/ : close -> LQH
- * queued wo/ : move to completed
+ * Queue : Action
+ * ============= : =================
+ * completed : -
+ * running : close -> LQH
+ * delivered w/ : close -> LQH
+ * delivered wo/ : move to completed
+ * queued w/ : close -> LQH
+ * queued wo/ : move to completed
*/
- /**
- * All delivered should to be closed
- */
ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0];
nextReq->closeFlag = ZTRUE;
nextReq->transId1 = apiConnectptr.p->transid[0];
@@ -9273,6 +9277,28 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr){
ScanFragList running(c_scan_frag_pool, scanP->m_running_scan_frags);
ScanFragList completed(c_scan_frag_pool, scanP->m_completed_scan_frags);
ScanFragList delivered(c_scan_frag_pool, scanP->m_delivered_scan_frags);
+ ScanFragList queued(c_scan_frag_pool, scanP->m_queued_scan_frags);
+
+ // Close running
+ for(running.first(ptr); !ptr.isNull(); ){
+ ScanFragRecPtr curr = ptr; // Remove while iterating...
+ running.next(ptr);
+
+ if(curr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF){
+ jam();
+ continue;
+ }
+ ndbrequire(curr.p->scanFragState == ScanFragRec::LQH_ACTIVE);
+
+ curr.p->startFragTimer(ctcTimer);
+ curr.p->scanFragState = ScanFragRec::LQH_ACTIVE;
+ nextReq->senderData = curr.i;
+ sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
+ ScanFragNextReq::SignalLength, JBB);
+ ndbout_c("%d running -> closing", curr.i);
+ }
+
+ // Close delivered
for(delivered.first(ptr); !ptr.isNull(); ){
jam();
ScanFragRecPtr curr = ptr; // Remove while iterating...
@@ -9290,20 +9316,19 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr){
sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- ndbout_c("delivered -> running");
+ ndbout_c("%d delivered -> closing (%d)", curr.i, curr.p->m_ops);
} else {
jam();
completed.add(curr);
curr.p->scanFragState = ScanFragRec::COMPLETED;
curr.p->stopFragTimer();
- ndbout_c("delivered -> completed");
+ ndbout_c("%d delivered -> completed", curr.i);
}
}//for
/**
* All queued with data should be closed
*/
- ScanFragList queued(c_scan_frag_pool, scanP->m_queued_scan_frags);
for(queued.first(ptr); !ptr.isNull(); ){
jam();
ndbrequire(ptr.p->scanFragState == ScanFragRec::QUEUED_FOR_DELIVERY);
@@ -9322,32 +9347,59 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr){
sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- ndbout_c("queued -> running");
+ ndbout_c("%d queued -> closing", curr.i);
} else {
jam();
completed.add(curr);
curr.p->scanFragState = ScanFragRec::COMPLETED;
curr.p->stopFragTimer();
- ndbout_c("queued -> completed");
+ ndbout_c("%d queued -> completed", curr.i);
}
}
}
- close_scan_req_send_conf(signal, scanptr);
+ close_scan_req_send_conf(signal, scanPtr);
}
void
Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
jam();
+
ndbrequire(scanPtr.p->m_queued_scan_frags.isEmpty());
ndbrequire(scanPtr.p->m_delivered_scan_frags.isEmpty());
+ //ndbrequire(scanPtr.p->m_running_scan_frags.isEmpty());
+
+#if 1
+ {
+ ScanFragList comp(c_scan_frag_pool, scanPtr.p->m_completed_scan_frags);
+ ScanFragRecPtr ptr;
+ for(comp.first(ptr); !ptr.isNull(); comp.next(ptr)){
+ ndbrequire(ptr.p->scanFragTimer == 0);
+ ndbrequire(ptr.p->scanFragState == ScanFragRec::COMPLETED);
+ }
+ }
+#endif
+
if(!scanPtr.p->m_running_scan_frags.isEmpty()){
jam();
+
+ ndbout_c("%d close_scan_req_send_conf: not ready", apiConnectptr.i);
return;
}
-
+
const bool apiFail = (apiConnectptr.p->apiFailState == ZTRUE);
+ if(!scanPtr.p->m_close_scan_req){
+ jam();
+ /**
+ * The API hasn't order closing yet
+ */
+ ndbout_c("%d close_scan_req_send_conf: api not ready", apiConnectptr.i);
+ return;
+ }
+
+ ndbout_c("%d close_scan_req_send_conf: ready", apiConnectptr.i);
+
if(!apiFail){
jam();
Uint32 ref = apiConnectptr.p->ndbapiBlockref;
@@ -9370,53 +9422,58 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
}
}
-void Dbtc::seizeScanrec(Signal* signal) {
+Dbtc::ScanRecordPtr
+Dbtc::seizeScanrec(Signal* signal) {
+ ScanRecordPtr scanptr;
scanptr.i = cfirstfreeScanrec;
ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
cfirstfreeScanrec = scanptr.p->nextScan;
scanptr.p->nextScan = RNIL;
ndbrequire(scanptr.p->scanState == ScanRecord::IDLE);
+ return scanptr;
}//Dbtc::seizeScanrec()
-void Dbtc::sendScanFragReq(Signal* signal) {
+void Dbtc::sendScanFragReq(Signal* signal,
+ ScanRecord* scanP,
+ ScanFragRec* scanFragP){
Uint32 requestInfo = 0;
- ScanFragReq::setConcurrency(requestInfo, scanFragptr.p->scanFragConcurrency);
- ScanFragReq::setLockMode(requestInfo, scanptr.p->scanLockMode);
- ScanFragReq::setHoldLockFlag(requestInfo, scanptr.p->scanLockHold);
- if(scanptr.p->scanLockMode == 1){ // Not read -> keyinfo
+ ScanFragReq::setConcurrency(requestInfo, scanFragP->scanFragConcurrency);
+ ScanFragReq::setLockMode(requestInfo, scanP->scanLockMode);
+ ScanFragReq::setHoldLockFlag(requestInfo, scanP->scanLockHold);
+ if(scanP->scanLockMode == 1){ // Not read -> keyinfo
jam();
ScanFragReq::setKeyinfoFlag(requestInfo, 1);
}
- ScanFragReq::setReadCommittedFlag(requestInfo, scanptr.p->readCommitted);
- ScanFragReq::setRangeScanFlag(requestInfo, scanptr.p->rangeScan);
- ScanFragReq::setAttrLen(requestInfo, scanptr.p->scanAiLength);
+ ScanFragReq::setReadCommittedFlag(requestInfo, scanP->readCommitted);
+ ScanFragReq::setRangeScanFlag(requestInfo, scanP->rangeScan);
+ ScanFragReq::setAttrLen(requestInfo, scanP->scanAiLength);
ScanFragReq::setScanPrio(requestInfo, 1);
- apiConnectptr.i = scanptr.p->scanApiRec;
+ apiConnectptr.i = scanP->scanApiRec;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
ScanFragReq * const req = (ScanFragReq *)&signal->theData[0];
req->senderData = scanFragptr.i;
req->resultRef = apiConnectptr.p->ndbapiBlockref;
req->requestInfo = requestInfo;
req->savePointId = apiConnectptr.p->currSavePointId;
- req->tableId = scanptr.p->scanTableref;
- req->fragmentNo = scanFragptr.p->scanFragId;
- req->schemaVersion = scanptr.p->scanSchemaVersion;
+ req->tableId = scanP->scanTableref;
+ req->fragmentNo = scanFragP->scanFragId;
+ req->schemaVersion = scanP->scanSchemaVersion;
req->transId1 = apiConnectptr.p->transid[0];
req->transId2 = apiConnectptr.p->transid[1];
for(int i = 0; i<16; i++){
- req->clientOpPtr[i] = scanFragptr.p->m_apiPtr;
+ req->clientOpPtr[i] = scanFragP->m_apiPtr;
}
- sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_FRAGREQ, signal, 25, JBB);
+ sendSignal(scanFragP->lqhBlockref, GSN_SCAN_FRAGREQ, signal, 25, JBB);
updateBuddyTimer(apiConnectptr);
- scanFragptr.p->startFragTimer(ctcTimer);
+ scanFragP->startFragTimer(ctcTimer);
}//Dbtc::sendScanFragReq()
-void Dbtc::sendScanTabConf(Signal* signal) {
+void Dbtc::sendScanTabConf(Signal* signal, ScanRecord * scanP) {
jam();
Uint32* ops = signal->getDataPtrSend()+4;
- Uint32 op_count = scanptr.p->m_queued_count;
+ Uint32 op_count = scanP->m_queued_count;
if(4 + 3 * op_count > 25){
jam();
ops += 21;
@@ -9428,7 +9485,6 @@ void Dbtc::sendScanTabConf(Signal* signal) {
conf->transId1 = apiConnectptr.p->transid[0];
conf->transId2 = apiConnectptr.p->transid[1];
ScanFragRecPtr ptr;
- ScanRecord* scanP = scanptr.p;
ScanFragList queued(c_scan_frag_pool, scanP->m_queued_scan_frags);
ScanFragList completed(c_scan_frag_pool, scanP->m_completed_scan_frags);
ScanFragList delivered(c_scan_frag_pool, scanP->m_delivered_scan_frags);
@@ -9466,7 +9522,7 @@ void Dbtc::sendScanTabConf(Signal* signal) {
sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABCONF, signal,
ScanTabConf::SignalLength + 3 * op_count, JBB);
}
- scanptr.p->m_queued_count = 0;
+ scanP->m_queued_count = 0;
}//Dbtc::sendScanTabConf()
@@ -9715,12 +9771,14 @@ void Dbtc::initialiseRecordsLab(Signal* signal, UintR Tdata0,
/* ========================================================================= */
void Dbtc::initialiseScanrec(Signal* signal)
{
+ ScanRecordPtr scanptr;
ndbrequire(cscanrecFileSize > 0);
for (scanptr.i = 0; scanptr.i < cscanrecFileSize; scanptr.i++) {
jam();
ptrAss(scanptr, scanRecord);
new (scanptr.p) ScanRecord();
scanptr.p->scanState = ScanRecord::IDLE;
+ scanptr.p->scanApiRec = RNIL;
scanptr.p->nextScan = scanptr.i + 1;
}//for
scanptr.i = cscanrecFileSize - 1;
@@ -11496,7 +11554,8 @@ void Dbtc::readIndexTable(Signal* signal,
Uint32 transId1 = indexOp->tcIndxReq->transId1;
Uint32 transId2 = indexOp->tcIndxReq->transId2;
- const Uint8 opType = TcKeyReq::getOperationType(tcKeyRequestInfo);
+ const Operation_t opType =
+ (Operation_t)TcKeyReq::getOperationType(tcKeyRequestInfo);
// Find index table
if ((indexData = c_theIndexes.getPtr(indexOp->tcIndxReq->indexId)) == NULL) {
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
index cd5057d8a62..f7d55d0acc9 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
@@ -54,6 +54,9 @@ void Dbtup::execSEND_PACKED(Signal* signal)
void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
Uint32 Tlen)
{
+ if(Tlen == 3)
+ return;
+
Uint32 hostId = refToNode(aRef);
Uint32 Theader = ((refToBlock(aRef) << 16)+(Tlen-3));
diff --git a/ndb/src/ndbapi/NdbConnectionScan.cpp b/ndb/src/ndbapi/NdbConnectionScan.cpp
index ea45f2b5a00..d405dedc09f 100644
--- a/ndb/src/ndbapi/NdbConnectionScan.cpp
+++ b/ndb/src/ndbapi/NdbConnectionScan.cpp
@@ -61,7 +61,14 @@ NdbConnection::receiveSCAN_TABREF(NdbApiSignal* aSignal){
const ScanTabRef * ref = CAST_CONSTPTR(ScanTabRef, aSignal->getDataPtr());
if(checkState_TransId(&ref->transId1)){
- theScanningOp->execCLOSE_SCAN_REP(ref->errorCode);
+ theScanningOp->theError.code = ref->errorCode;
+ if(!ref->closeNeeded){
+ theScanningOp->execCLOSE_SCAN_REP();
+ return 0;
+ }
+ assert(theScanningOp->m_sent_receivers_count);
+ theScanningOp->m_sent_receivers_count--;
+ theScanningOp->m_conf_receivers_count++;
return 0;
}
return -1;
@@ -88,11 +95,10 @@ NdbConnection::receiveSCAN_TABCONF(NdbApiSignal* aSignal,
if(checkState_TransId(&conf->transId1)){
if (conf->requestInfo == ScanTabConf::EndOfData) {
- theScanningOp->execCLOSE_SCAN_REP(0);
+ theScanningOp->execCLOSE_SCAN_REP();
return 0;
}
- int noComp = -1;
for(Uint32 i = 0; ireceiver_delivered(tOp);
} else if(info == ScanTabConf::EndOfData){
- noComp++;
theScanningOp->receiver_completed(tOp);
}
}
}
- return noComp;
+ return 0;
}
return -1;
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 7cbf35ab4fd..2f0bd82044c 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -124,7 +124,7 @@ NdbScanOperation::init(NdbTableImpl* tab, NdbConnection* myConnection)
theTotalBoundAI_Len = 0;
theBoundATTRINFO = NULL;
-
+
return 0;
}
@@ -135,6 +135,8 @@ NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
m_ordered = 0;
Uint32 fragCount = m_currentTable->m_fragmentCount;
+ ndbout_c("batch: %d parallell: %d fragCount: %d",
+ batch, parallell, fragCount);
if(batch + parallell == 0){ // Max speed
batch = 16;
@@ -153,6 +155,9 @@ NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
parallell = fragCount;
else if(parallell == 0)
parallell = fragCount;
+
+ ndbout_c("batch: %d parallell: %d fragCount: %d",
+ batch, parallell, fragCount);
assert(parallell > 0);
@@ -486,6 +491,11 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
last = m_api_receivers_count;
do {
+ if(theError.code){
+ setErrorCode(theError.code);
+ return -1;
+ }
+
Uint32 cnt = m_conf_receivers_count;
Uint32 sent = m_sent_receivers_count;
@@ -502,12 +512,17 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
*/
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
+ ndbout_c("%d : api: %d conf: %d sent: %d",
+ __LINE__,
+ m_api_receivers_count,
+ m_conf_receivers_count,
+ m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
continue;
} else {
idx = last;
- retVal = -1; //return_code;
+ retVal = -2; //return_code;
}
} else if(retVal == 2){
/**
@@ -516,6 +531,11 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
if(send_next_scan(0, true) == 0){ // Close scan
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
+ ndbout_c("%d : api: %d conf: %d sent: %d",
+ __LINE__,
+ m_api_receivers_count,
+ m_conf_receivers_count,
+ m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
return 1;
@@ -633,6 +653,12 @@ NdbScanOperation::doSend(int ProcessorId)
void NdbScanOperation::closeScan()
{
+ ndbout_c("closeScan %d : api: %d conf: %d sent: %d",
+ __LINE__,
+ m_api_receivers_count,
+ m_conf_receivers_count,
+ m_sent_receivers_count);
+
do {
TransporterFacade* tp = TransporterFacade::instance();
Guard guard(tp->theMutexPtr);
@@ -651,6 +677,11 @@ void NdbScanOperation::closeScan()
while(m_sent_receivers_count){
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
+ ndbout_c("%d : api: %d conf: %d sent: %d",
+ __LINE__,
+ m_api_receivers_count,
+ m_conf_receivers_count,
+ m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
switch(return_code){
case 0:
@@ -679,6 +710,11 @@ void NdbScanOperation::closeScan()
do {
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
+ ndbout_c("%d : api: %d conf: %d sent: %d",
+ __LINE__,
+ m_api_receivers_count,
+ m_conf_receivers_count,
+ m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
switch(return_code){
case 0:
@@ -701,22 +737,7 @@ void NdbScanOperation::closeScan()
}
void
-NdbScanOperation::execCLOSE_SCAN_REP(Uint32 errCode){
- /**
- * We will receive no further signals from this scan
- */
- if(!errCode){
- /**
- * Normal termination
- */
- theNdbCon->theCommitStatus = NdbConnection::Committed;
- theNdbCon->theCompletionStatus = NdbConnection::CompletedSuccess;
- } else {
- /**
- * Something is fishy
- */
- abort();
- }
+NdbScanOperation::execCLOSE_SCAN_REP(){
m_api_receivers_count = 0;
m_conf_receivers_count = 0;
m_sent_receivers_count = 0;
@@ -1206,7 +1227,7 @@ NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
Uint32 nodeId = theNdbCon->theDBnode;
if(seq == tp->getNodeSequence(nodeId) && !send_next_scan_ordered(u_idx)){
Uint32 tmp = m_sent_receivers_count;
- while(m_sent_receivers_count > 0){
+ while(m_sent_receivers_count > 0 && !theError.code){
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
@@ -1223,12 +1244,16 @@ NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
memcpy(arr, m_conf_receivers, u_last * sizeof(char*));
if(DEBUG_NEXT_RESULT) ndbout_c("sent: %d recv: %d", tmp, u_last);
+ if(theError.code){
+ setErrorCode(theError.code);
+ return -1;
+ }
}
} else {
return 2;
}
}
-
+
if(DEBUG_NEXT_RESULT) ndbout_c("u=[%d %d] s=[%d %d]",
u_idx, u_last,
s_idx, s_last);
@@ -1279,9 +1304,12 @@ NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
Guard guard(tp->theMutexPtr);
Uint32 seq = theNdbCon->theNodeSequence;
Uint32 nodeId = theNdbCon->theDBnode;
- if(seq == tp->getNodeSequence(nodeId) && send_next_scan(0, true) == 0){
+ if(seq == tp->getNodeSequence(nodeId) &&
+ send_next_scan(0, true) == 0 &&
+ theError.code == 0){
return 1;
}
+ setErrorCode(theError.code);
return -1;
}
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index f7d537dafa5..92723431860 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -705,23 +705,25 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
+
+ tCon = void2con(tFirstDataPtr);
+
+ assert(tFirstDataPtr != 0 &&
+ void2con(tFirstDataPtr)->checkMagicNumber() == 0);
- if (tWaitState == WAIT_SCAN){
- tCon = void2con(tFirstDataPtr);
- if (tCon->checkMagicNumber() == 0){
- tReturnCode = tCon->receiveSCAN_TABREF(aSignal);
- if (tReturnCode != -1){
- theWaiter.m_state = NO_WAIT;
- }
- break;
+ if (tCon->checkMagicNumber() == 0){
+ tReturnCode = tCon->receiveSCAN_TABREF(aSignal);
+ if (tReturnCode != -1){
+ theWaiter.m_state = NO_WAIT;
}
+ break;
}
goto InvalidSignal;
- }
+ }
case GSN_SCAN_TABINFO:
- {
- goto InvalidSignal;
- }
+ {
+ goto InvalidSignal;
+ }
case GSN_KEYINFO20: {
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
From a5e0f5f6ebf0fed3bf6fd24952e7c0f9f2cb47f6 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Tue, 1 Jun 2004 16:54:40 +0200
Subject: [PATCH 005/579] Fix scan error bug (last known :-))
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 41 +-------
ndb/src/ndbapi/NdbConnectionScan.cpp | 1 -
ndb/src/ndbapi/NdbScanOperation.cpp | 118 +++++++-----------------
3 files changed, 36 insertions(+), 124 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index 04506bc62eb..a4907a00b85 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -6433,7 +6433,6 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
c_scan_frag_pool.getPtr(scanFragptr);
switch (scanFragptr.p->scanFragState){
case ScanFragRec::LQH_ACTIVE:
- //case ScanFragRec::LQH_ACTIVE_CLOSE:
break;
default:
DEBUG("execSCAN_HBREP: scanFragState="<scanFragState);
@@ -6514,7 +6513,6 @@ void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
/**
* The node has died
*/
- ndbout_c("Node %d has died", nodeId);
ptr.p->scanFragState = ScanFragRec::COMPLETED;
ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
@@ -8358,10 +8356,6 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
scanParallel = (scanConcurrency + 15) / 16;
noOprecPerFrag = (scanConcurrency >= 16 ? 16 : scanConcurrency & 15);
}
-#ifdef VM_TRACE
- ndbout_c("noOprecPerFrag=%d", noOprecPerFrag);
- ndbout_c("scanParallel=%d", scanParallel);
-#endif
jamEntry();
apiConnectptr.i = scanTabReq->apiConnectPtr;
@@ -8708,11 +8702,6 @@ void Dbtc::execDI_FCOUNTCONF(Signal* signal)
for (list.first(ptr); !ptr.isNull(); list.next(ptr)){
jam();
-#ifdef VM_TRACE
- ndbout_c("DIGETPRIMREQ(%d, %d)",
- scanptr.p->scanTableref, scanptr.p->scanNextFragId);
-#endif
-
ptr.p->lqhBlockref = 0;
ptr.p->startFragTimer(ctcTimer);
ptr.p->scanFragId = scanptr.p->scanNextFragId++;
@@ -8759,9 +8748,6 @@ void Dbtc::abortScanLab(Signal* signal, ScanRecordPtr scanptr, Uint32 errCode)
void Dbtc::releaseScanResources(ScanRecordPtr scanPtr)
{
-#ifdef VM_TRACE
- ndbout_c("releaseScanResources: %d", scanPtr.i);
-#endif
if (apiConnectptr.p->cachePtr != RNIL) {
cachePtr.i = apiConnectptr.p->cachePtr;
ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord);
@@ -9041,26 +9027,15 @@ void Dbtc::execSCAN_FRAGCONF(Signal* signal)
const Uint32 status = conf->fragmentCompleted;
- DEBUG(apiConnectptr.i << " " << scanFragptr.i <<
- " execSCAN_FRAGCONF() status: " << status
- << " ops: " << noCompletedOps << " from: " << refToNode(signal->getSendersBlockRef()));
-
if(scanptr.p->scanState == ScanRecord::CLOSING_SCAN){
jam();
if(status == ZFALSE){
/**
* We have started closing = we sent a close -> ignore this
*/
- DEBUG(apiConnectptr.i << " " << scanFragptr.i <<
- " Received SCANFRAG_CONF wo/ close when in "
- " CLOSING_SCAN:" << status << " " << noCompletedOps);
return;
} else {
jam();
- DEBUG(apiConnectptr.i << " " << scanFragptr.i
- << " Received SCANFRAG_CONF w/ close when in "
- " CLOSING_SCAN:" << status << " " << noCompletedOps);
-
ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
@@ -9249,9 +9224,6 @@ void Dbtc::execSCAN_NEXTREQ(Signal* signal)
void
Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr, bool req_received){
-#ifdef VM_TRACE
- ndbout_c("%d close_scan_req", apiConnectptr.i);
-#endif
ScanRecord* scanP = scanPtr.p;
scanPtr.p->scanState = ScanRecord::CLOSING_SCAN;
scanPtr.p->m_close_scan_req = req_received;
@@ -9295,7 +9267,6 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr, bool req_received){
nextReq->senderData = curr.i;
sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- ndbout_c("%d running -> closing", curr.i);
}
// Close delivered
@@ -9316,13 +9287,11 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr, bool req_received){
sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
- ndbout_c("%d delivered -> closing (%d)", curr.i, curr.p->m_ops);
} else {
jam();
completed.add(curr);
curr.p->scanFragState = ScanFragRec::COMPLETED;
curr.p->stopFragTimer();
- ndbout_c("%d delivered -> completed", curr.i);
}
}//for
@@ -9346,14 +9315,11 @@ Dbtc::close_scan_req(Signal* signal, ScanRecordPtr scanPtr, bool req_received){
nextReq->senderData = curr.i;
sendSignal(curr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal,
ScanFragNextReq::SignalLength, JBB);
-
- ndbout_c("%d queued -> closing", curr.i);
} else {
jam();
completed.add(curr);
curr.p->scanFragState = ScanFragRec::COMPLETED;
curr.p->stopFragTimer();
- ndbout_c("%d queued -> completed", curr.i);
}
}
}
@@ -9369,7 +9335,7 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
ndbrequire(scanPtr.p->m_delivered_scan_frags.isEmpty());
//ndbrequire(scanPtr.p->m_running_scan_frags.isEmpty());
-#if 1
+#if 0
{
ScanFragList comp(c_scan_frag_pool, scanPtr.p->m_completed_scan_frags);
ScanFragRecPtr ptr;
@@ -9382,8 +9348,6 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
if(!scanPtr.p->m_running_scan_frags.isEmpty()){
jam();
-
- ndbout_c("%d close_scan_req_send_conf: not ready", apiConnectptr.i);
return;
}
@@ -9394,12 +9358,9 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
/**
* The API hasn't order closing yet
*/
- ndbout_c("%d close_scan_req_send_conf: api not ready", apiConnectptr.i);
return;
}
- ndbout_c("%d close_scan_req_send_conf: ready", apiConnectptr.i);
-
if(!apiFail){
jam();
Uint32 ref = apiConnectptr.p->ndbapiBlockref;
diff --git a/ndb/src/ndbapi/NdbConnectionScan.cpp b/ndb/src/ndbapi/NdbConnectionScan.cpp
index d405dedc09f..43b7d8eaccb 100644
--- a/ndb/src/ndbapi/NdbConnectionScan.cpp
+++ b/ndb/src/ndbapi/NdbConnectionScan.cpp
@@ -67,7 +67,6 @@ NdbConnection::receiveSCAN_TABREF(NdbApiSignal* aSignal){
return 0;
}
assert(theScanningOp->m_sent_receivers_count);
- theScanningOp->m_sent_receivers_count--;
theScanningOp->m_conf_receivers_count++;
return 0;
}
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 2f0bd82044c..86ee0748127 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -135,8 +135,6 @@ NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
m_ordered = 0;
Uint32 fragCount = m_currentTable->m_fragmentCount;
- ndbout_c("batch: %d parallell: %d fragCount: %d",
- batch, parallell, fragCount);
if(batch + parallell == 0){ // Max speed
batch = 16;
@@ -155,9 +153,6 @@ NdbResultSet* NdbScanOperation::readTuples(NdbScanOperation::LockMode lm,
parallell = fragCount;
else if(parallell == 0)
parallell = fragCount;
-
- ndbout_c("batch: %d parallell: %d fragCount: %d",
- batch, parallell, fragCount);
assert(parallell > 0);
@@ -300,20 +295,22 @@ NdbScanOperation::fix_receivers(Uint32 parallell, bool keyInfo){
*/
void
NdbScanOperation::receiver_delivered(NdbReceiver* tRec){
- Uint32 idx = tRec->m_list_index;
- Uint32 last = m_sent_receivers_count - 1;
- if(idx != last){
- NdbReceiver * move = m_sent_receivers[last];
- m_sent_receivers[idx] = move;
- move->m_list_index = idx;
+ if(theError.code == 0){
+ Uint32 idx = tRec->m_list_index;
+ Uint32 last = m_sent_receivers_count - 1;
+ if(idx != last){
+ NdbReceiver * move = m_sent_receivers[last];
+ m_sent_receivers[idx] = move;
+ move->m_list_index = idx;
+ }
+ m_sent_receivers_count = last;
+
+ last = m_conf_receivers_count;
+ m_conf_receivers[last] = tRec;
+ m_conf_receivers_count = last + 1;
+ tRec->m_list_index = last;
+ tRec->m_current_row = 0;
}
- m_sent_receivers_count = last;
-
- last = m_conf_receivers_count;
- m_conf_receivers[last] = tRec;
- m_conf_receivers_count = last + 1;
- tRec->m_list_index = last;
- tRec->m_current_row = 0;
}
/**
@@ -321,14 +318,16 @@ NdbScanOperation::receiver_delivered(NdbReceiver* tRec){
*/
void
NdbScanOperation::receiver_completed(NdbReceiver* tRec){
- Uint32 idx = tRec->m_list_index;
- Uint32 last = m_sent_receivers_count - 1;
- if(idx != last){
- NdbReceiver * move = m_sent_receivers[last];
- m_sent_receivers[idx] = move;
- move->m_list_index = idx;
+ if(theError.code == 0){
+ Uint32 idx = tRec->m_list_index;
+ Uint32 last = m_sent_receivers_count - 1;
+ if(idx != last){
+ NdbReceiver * move = m_sent_receivers[last];
+ m_sent_receivers[idx] = move;
+ move->m_list_index = idx;
+ }
+ m_sent_receivers_count = last;
}
- m_sent_receivers_count = last;
}
/*****************************************************************************
@@ -512,11 +511,6 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
*/
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
- ndbout_c("%d : api: %d conf: %d sent: %d",
- __LINE__,
- m_api_receivers_count,
- m_conf_receivers_count,
- m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
continue;
@@ -531,11 +525,6 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
if(send_next_scan(0, true) == 0){ // Close scan
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
- ndbout_c("%d : api: %d conf: %d sent: %d",
- __LINE__,
- m_api_receivers_count,
- m_conf_receivers_count,
- m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
return 1;
@@ -653,12 +642,8 @@ NdbScanOperation::doSend(int ProcessorId)
void NdbScanOperation::closeScan()
{
- ndbout_c("closeScan %d : api: %d conf: %d sent: %d",
- __LINE__,
- m_api_receivers_count,
- m_conf_receivers_count,
- m_sent_receivers_count);
-
+ int self = pthread_self() ;
+
do {
TransporterFacade* tp = TransporterFacade::instance();
Guard guard(tp->theMutexPtr);
@@ -671,17 +656,17 @@ void NdbScanOperation::closeScan()
break;
}
+ if(m_api_receivers_count+m_conf_receivers_count){
+ // Send close scan
+ send_next_scan(0, true); // Close scan
+ }
+
/**
- * Wait for all running scans...
+ * wait for close scan conf
*/
- while(m_sent_receivers_count){
+ while(m_sent_receivers_count+m_api_receivers_count+m_conf_receivers_count){
theNdb->theWaiter.m_node = nodeId;
theNdb->theWaiter.m_state = WAIT_SCAN;
- ndbout_c("%d : api: %d conf: %d sent: %d",
- __LINE__,
- m_api_receivers_count,
- m_conf_receivers_count,
- m_sent_receivers_count);
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
switch(return_code){
case 0:
@@ -689,46 +674,13 @@ void NdbScanOperation::closeScan()
case -1:
setErrorCode(4008);
case -2:
- m_sent_receivers_count = 0;
m_api_receivers_count = 0;
m_conf_receivers_count = 0;
+ m_sent_receivers_count = 0;
}
}
-
- if(seq != tp->getNodeSequence(nodeId)){
- theNdbCon->theReleaseOnClose = true;
- break;
- }
-
- if(m_api_receivers_count+m_conf_receivers_count){
- // Send close scan
- send_next_scan(0, true); // Close scan
-
- /**
- * wait for close scan conf
- */
- do {
- theNdb->theWaiter.m_node = nodeId;
- theNdb->theWaiter.m_state = WAIT_SCAN;
- ndbout_c("%d : api: %d conf: %d sent: %d",
- __LINE__,
- m_api_receivers_count,
- m_conf_receivers_count,
- m_sent_receivers_count);
- int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
- switch(return_code){
- case 0:
- break;
- case -1:
- setErrorCode(4008);
- case -2:
- m_api_receivers_count = 0;
- m_conf_receivers_count = 0;
- }
- } while(m_api_receivers_count+m_conf_receivers_count);
- }
} while(0);
-
+
theNdbCon->theScanningOp = 0;
theNdb->closeTransaction(theNdbCon);
From d99c91b63c8805613f6c02f80a688247d2f5ea29 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Fri, 11 Jun 2004 13:49:22 +0200
Subject: [PATCH 006/579] Fix handler w.r.t scan
---
ndb/include/ndbapi/NdbApi.hpp | 2 --
ndb/src/ndbapi/NdbRecAttr.cpp | 1 -
ndb/tools/select_count.cpp | 27 +++++++++++++--------------
sql/ha_ndbcluster.cc | 30 +++++++++++++++---------------
sql/ha_ndbcluster.h | 4 +++-
5 files changed, 31 insertions(+), 33 deletions(-)
diff --git a/ndb/include/ndbapi/NdbApi.hpp b/ndb/include/ndbapi/NdbApi.hpp
index 5f55c8951ba..4f721940332 100644
--- a/ndb/include/ndbapi/NdbApi.hpp
+++ b/ndb/include/ndbapi/NdbApi.hpp
@@ -25,8 +25,6 @@
#include "NdbIndexOperation.hpp"
#include "NdbIndexScanOperation.hpp"
#include "NdbScanFilter.hpp"
-#include "NdbSchemaCon.hpp"
-#include "NdbSchemaOp.hpp"
#include "NdbRecAttr.hpp"
#include "NdbResultSet.hpp"
#include "NdbDictionary.hpp"
diff --git a/ndb/src/ndbapi/NdbRecAttr.cpp b/ndb/src/ndbapi/NdbRecAttr.cpp
index ec10fc1d769..16ac98218ee 100644
--- a/ndb/src/ndbapi/NdbRecAttr.cpp
+++ b/ndb/src/ndbapi/NdbRecAttr.cpp
@@ -220,5 +220,4 @@ NdbOut& operator<<(NdbOut& ndbout, const NdbRecAttr &r)
}
return ndbout;
->>>>>>>
}
diff --git a/ndb/tools/select_count.cpp b/ndb/tools/select_count.cpp
index cae91feb378..2c43af20e64 100644
--- a/ndb/tools/select_count.cpp
+++ b/ndb/tools/select_count.cpp
@@ -30,8 +30,7 @@ static int
select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
int parallelism,
int* count_rows,
- UtilTransactions::ScanLock lock,
- NdbConnection* pBuddyTrans=0);
+ UtilTransactions::ScanLock lock);
int main(int argc, const char** argv){
const char* _dbname = "TEST_DB";
@@ -95,14 +94,13 @@ int
select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
int parallelism,
int* count_rows,
- UtilTransactions::ScanLock lock,
- NdbConnection* pBuddyTrans){
+ UtilTransactions::ScanLock lock){
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbConnection *pTrans;
- NdbOperation *pOp;
+ NdbScanOperation *pOp;
while (true){
@@ -112,7 +110,7 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
return NDBT_FAILED;
}
- pTrans = pNdb->hupp(pBuddyTrans);
+ pTrans = pNdb->startTransaction();
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
@@ -124,26 +122,27 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
ERR(err);
return NDBT_FAILED;
}
- pOp = pTrans->getNdbOperation(pTab->getName());
+ pOp = pTrans->getNdbScanOperation(pTab->getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
+ NdbResultSet * rs;
switch(lock){
case UtilTransactions::SL_ReadHold:
- check = pOp->openScanReadHoldLock(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism);
break;
case UtilTransactions::SL_Exclusive:
- check = pOp->openScanExclusive(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallelism);
break;
case UtilTransactions::SL_Read:
default:
- check = pOp->openScanRead(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Dirty, 0, parallelism);
}
- if( check == -1 ) {
+ if( rs == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
@@ -156,7 +155,7 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
return NDBT_FAILED;
}
- check = pTrans->executeScan();
+ check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
@@ -165,11 +164,11 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
int eof;
int rows = 0;
- eof = pTrans->nextScanResult();
+ eof = rs->nextResult();
while(eof == 0){
rows++;
- eof = pTrans->nextScanResult();
+ eof = rs->nextResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index c76534943b8..e3a63eacd22 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -462,10 +462,10 @@ void ha_ndbcluster::release_metadata()
DBUG_VOID_RETURN;
}
-NdbCursorOperation::LockMode get_ndb_lock_type(enum thr_lock_type type)
+NdbScanOperation::LockMode get_ndb_lock_type(enum thr_lock_type type)
{
return (type == TL_WRITE_ALLOW_WRITE) ?
- NdbCursorOperation::LM_Exclusive : NdbCursorOperation::LM_Read;
+ NdbScanOperation::LM_Exclusive : NdbScanOperation::LM_Read;
}
static const ulong index_type_flags[]=
@@ -795,7 +795,7 @@ inline int ha_ndbcluster::next_result(byte *buf)
Set bounds for a ordered index scan, use key_range
*/
-int ha_ndbcluster::set_bounds(NdbOperation *op,
+int ha_ndbcluster::set_bounds(NdbIndexScanOperation *op,
const key_range *key,
int bound)
{
@@ -843,7 +843,7 @@ int ha_ndbcluster::set_bounds(NdbOperation *op,
so if this bound was not EQ, bail out and make
a best effort attempt
*/
- if (bound != NdbOperation::BoundEQ)
+ if (bound != NdbIndexScanOperation::BoundEQ)
break;
}
@@ -861,7 +861,7 @@ int ha_ndbcluster::ordered_index_scan(const key_range *start_key,
{
NdbConnection *trans= m_active_trans;
NdbResultSet *cursor;
- NdbScanOperation *op;
+ NdbIndexScanOperation *op;
const char *index_name;
DBUG_ENTER("ordered_index_scan");
@@ -869,19 +869,19 @@ int ha_ndbcluster::ordered_index_scan(const key_range *start_key,
DBUG_PRINT("enter", ("Starting new ordered scan on %s", m_tabname));
index_name= get_index_name(active_index);
- if (!(op= trans->getNdbScanOperation(index_name, m_tabname)))
+ if (!(op= trans->getNdbIndexScanOperation(index_name, m_tabname)))
ERR_RETURN(trans->getNdbError());
- if (!(cursor= op->readTuples(parallelism, get_ndb_lock_type(m_lock.type))))
+ if (!(cursor= op->readTuples(get_ndb_lock_type(m_lock.type), 0,parallelism)))
ERR_RETURN(trans->getNdbError());
m_active_cursor= cursor;
if (start_key &&
set_bounds(op, start_key,
(start_key->flag == HA_READ_KEY_EXACT) ?
- NdbOperation::BoundEQ :
+ NdbIndexScanOperation::BoundEQ :
(start_key->flag == HA_READ_AFTER_KEY) ?
- NdbOperation::BoundLT :
- NdbOperation::BoundLE))
+ NdbIndexScanOperation::BoundLT :
+ NdbIndexScanOperation::BoundLE))
DBUG_RETURN(1);
if (end_key)
@@ -892,8 +892,8 @@ int ha_ndbcluster::ordered_index_scan(const key_range *start_key,
}
else if (set_bounds(op, end_key,
(end_key->flag == HA_READ_AFTER_KEY) ?
- NdbOperation::BoundGE :
- NdbOperation::BoundGT))
+ NdbIndexScanOperation::BoundGE :
+ NdbIndexScanOperation::BoundGT))
DBUG_RETURN(1);
}
DBUG_RETURN(define_read_attrs(buf, op));
@@ -931,10 +931,10 @@ int ha_ndbcluster::filtered_scan(const byte *key, uint key_len,
if (!(op= trans->getNdbScanOperation(m_tabname)))
ERR_RETURN(trans->getNdbError());
- if (!(cursor= op->readTuples(parallelism, get_ndb_lock_type(m_lock.type))))
+ if (!(cursor= op->readTuples(get_ndb_lock_type(m_lock.type), 0,parallelism)))
ERR_RETURN(trans->getNdbError());
m_active_cursor= cursor;
-
+
{
// Start scan filter
NdbScanFilter sf(op);
@@ -1000,7 +1000,7 @@ int ha_ndbcluster::full_table_scan(byte *buf)
if (!(op=trans->getNdbScanOperation(m_tabname)))
ERR_RETURN(trans->getNdbError());
- if (!(cursor= op->readTuples(parallelism, get_ndb_lock_type(m_lock.type))))
+ if (!(cursor= op->readTuples(get_ndb_lock_type(m_lock.type), 0,parallelism)))
ERR_RETURN(trans->getNdbError());
m_active_cursor= cursor;
DBUG_RETURN(define_read_attrs(buf, op));
diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h
index df296648272..9c01f839b1f 100644
--- a/sql/ha_ndbcluster.h
+++ b/sql/ha_ndbcluster.h
@@ -33,6 +33,8 @@ class NdbOperation; // Forward declaration
class NdbConnection; // Forward declaration
class NdbRecAttr; // Forward declaration
class NdbResultSet; // Forward declaration
+class NdbScanOperation;
+class NdbIndexScanOperation;
typedef enum ndb_index_type {
UNDEFINED_INDEX = 0,
@@ -182,7 +184,7 @@ class ha_ndbcluster: public handler
int set_primary_key(NdbOperation *op, const byte *key);
int set_primary_key(NdbOperation *op);
int set_primary_key_from_old_data(NdbOperation *op, const byte *old_data);
- int set_bounds(NdbOperation *ndb_op, const key_range *key,
+ int set_bounds(NdbIndexScanOperation *ndb_op, const key_range *key,
int bound);
int key_cmp(uint keynr, const byte * old_row, const byte * new_row);
void print_results();
From 14d00843507ba271d871cf1c096e2ad22678b113 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Mon, 14 Jun 2004 17:49:46 +0200
Subject: [PATCH 007/579] wl1671 - bug fix for node failure during scan
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index a4907a00b85..fd0dd1624ea 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -6793,13 +6793,13 @@ void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
for (scanptr.i = scanPtrI; scanptr.i < cscanrecFileSize; scanptr.i++) {
jam();
ptrAss(scanptr, scanRecord);
+ bool found = false;
if (scanptr.p->scanState != ScanRecord::IDLE){
jam();
ScanFragRecPtr ptr;
ScanFragList run(c_scan_frag_pool, scanptr.p->m_running_scan_frags);
ScanFragList comp(c_scan_frag_pool, scanptr.p->m_completed_scan_frags);
-
- bool found = false;
+
for(run.first(ptr); !ptr.isNull(); ){
jam();
ScanFragRecPtr curr = ptr;
@@ -6815,12 +6815,12 @@ void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
found = true;
}
}
- if(found){
- jam();
- scanError(signal, scanptr, ZSCAN_LQH_ERROR);
- }
}
-
+ if(found){
+ jam();
+ scanError(signal, scanptr, ZSCAN_LQH_ERROR);
+ }
+
// Send CONTINUEB to continue later
signal->theData[0] = TcContinueB::ZCHECK_SCAN_ACTIVE_FAILED_LQH;
signal->theData[1] = scanptr.i + 1; // Check next scanptr
From c9e34f190560f9b68dc4279291fa048851554f4d Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 16 Jun 2004 13:27:35 +0200
Subject: [PATCH 008/579] wl1671 - bug fixes
---
ndb/include/ndbapi/NdbConnection.hpp | 18 +++++++++----
ndb/src/kernel/blocks/dblqh/DblqhMain.cpp | 32 ++++++++++++++++++++++-
ndb/src/ndbapi/NdbConnection.cpp | 18 ++++++++++++-
ndb/src/ndbapi/Ndbif.cpp | 4 +--
ndb/test/src/HugoTransactions.cpp | 2 +-
ndb/test/src/UtilTransactions.cpp | 4 +--
ndb/tools/delete_all.cpp | 2 +-
7 files changed, 67 insertions(+), 13 deletions(-)
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp
index bf5a4f6f0e5..42e011419dd 100644
--- a/ndb/include/ndbapi/NdbConnection.hpp
+++ b/ndb/include/ndbapi/NdbConnection.hpp
@@ -309,6 +309,16 @@ public:
*/
void close();
+ /**
+ * Restart transaction
+ *
+ * Once a transaction has been completed successfully
+ * it can be started again wo/ calling closeTransaction/startTransaction
+ *
+ * Note this method also releases completed operations
+ */
+ int restart();
+
/** @} *********************************************************************/
/**
@@ -417,16 +427,14 @@ public:
*/
const NdbOperation * getNextCompletedOperation(const NdbOperation * op)const;
+ /** @} *********************************************************************/
+
+private:
/**
* Release completed operations
*/
void releaseCompletedOperations();
-
- /** @} *********************************************************************/
-
-private:
-
typedef Uint64 TimeMillis_t;
/**************************************************************************
* These methods are service methods to other classes in the NDBAPI. *
diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index 2a744ea746a..4f21b66b4d0 100644
--- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -64,6 +64,8 @@
#define DEBUG(x)
#endif
+//#define MARKER_TRACE 1
+
const Uint32 NR_ScanNo = 0;
void Dblqh::execACC_COM_BLOCK(Signal* signal)
@@ -2404,6 +2406,9 @@ Dblqh::execREMOVE_MARKER_ORD(Signal* signal)
CommitAckMarkerPtr removedPtr;
m_commitAckMarkerHash.release(removedPtr, key);
ndbrequire(removedPtr.i != RNIL);
+#ifdef MARKER_TRACE
+ ndbout_c("Rem marker[%.8x %.8x]", key.transid1, key.transid2);
+#endif
}
@@ -3198,6 +3203,9 @@ void Dblqh::execLQHKEYREQ(Signal* signal)
CommitAckMarkerPtr tmp;
#ifdef VM_TRACE
+#ifdef MARKER_TRACE
+ ndbout_c("Add marker[%.8x %.8x]", markerPtr.p->transid1, markerPtr.p->transid2);
+#endif
ndbrequire(!m_commitAckMarkerHash.find(tmp, * markerPtr.p));
#endif
m_commitAckMarkerHash.add(markerPtr);
@@ -5668,7 +5676,23 @@ void Dblqh::execABORT(Signal* signal)
}//if
regTcPtr->abortState = TcConnectionrec::ABORT_FROM_TC;
regTcPtr->activeCreat = ZFALSE;
+
+ const Uint32 commitAckMarker = regTcPtr->commitAckMarker;
+ if(commitAckMarker != RNIL){
+ jam();
+#ifdef MARKER_TRACE
+ {
+ CommitAckMarkerPtr tmp;
+ m_commitAckMarkerHash.getPtr(tmp, commitAckMarker);
+ ndbout_c("Ab2 marker[%.8x %.8x]", tmp.p->transid1, tmp.p->transid2);
+ }
+#endif
+ m_commitAckMarkerHash.release(commitAckMarker);
+ regTcPtr->commitAckMarker = RNIL;
+ }
+
abortStateHandlerLab(signal);
+
return;
}//Dblqh::execABORT()
@@ -6026,7 +6050,13 @@ void Dblqh::abortCommonLab(Signal* signal)
* There is no NR ongoing and we have a marker
*/
jam();
-
+#ifdef MARKER_TRACE
+ {
+ CommitAckMarkerPtr tmp;
+ m_commitAckMarkerHash.getPtr(tmp, commitAckMarker);
+ ndbout_c("Abo marker[%.8x %.8x]", tmp.p->transid1, tmp.p->transid2);
+ }
+#endif
m_commitAckMarkerHash.release(commitAckMarker);
regTcPtr->commitAckMarker = RNIL;
}
diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index 5aaf14302a6..68979d92559 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -193,6 +193,23 @@ NdbConnection::setErrorCode(int anErrorCode)
theError.code = anErrorCode;
}//NdbConnection::setErrorCode()
+int
+NdbConnection::restart(){
+ if(theCompletionStatus == CompletedSuccess){
+ releaseCompletedOperations();
+ Uint64 tTransid = theNdb->theFirstTransId;
+ theTransactionId = tTransid;
+ if((Uint32)tTransid == ((Uint32)~0)){
+ theNdb->theFirstTransId = (tTransid >> 32) << 32;
+ } else {
+ theNdb->theFirstTransId = tTransid + 1;
+ }
+ theCompletionStatus = NotCompleted;
+ return 0;
+ }
+ return -1;
+}
+
/*****************************************************************************
void handleExecuteCompletion(void);
@@ -1307,7 +1324,6 @@ from other transactions.
if (tCommitFlag == 1) {
theCommitStatus = Committed;
theGlobalCheckpointId = tGCI;
- theTransactionId++;
} else if ((tNoComp >= tNoSent) &&
(theLastExecOpInList->theCommitIndicator == 1)){
/**********************************************************************/
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index 92723431860..ea2c5be4f7f 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -1308,8 +1308,8 @@ void
NdbConnection::sendTC_COMMIT_ACK(NdbApiSignal * aSignal,
Uint32 transId1, Uint32 transId2,
Uint32 aTCRef){
-#if 0
- ndbout_c("Sending TC_COMMIT_ACK(0x%x, 0x%x) to -> %d",
+#ifdef MARKER_TRACE
+ ndbout_c("Sending TC_COMMIT_ACK(0x%.8x, 0x%.8x) to -> %d",
transId1,
transId2,
refToNode(aTCRef));
diff --git a/ndb/test/src/HugoTransactions.cpp b/ndb/test/src/HugoTransactions.cpp
index 7c26baa3ec2..d374f52a76a 100644
--- a/ndb/test/src/HugoTransactions.cpp
+++ b/ndb/test/src/HugoTransactions.cpp
@@ -654,7 +654,7 @@ HugoTransactions::scanUpdateRecords3(Ndb* pNdb,
if(check != -1){
check = pTrans->execute(Commit);
- pTrans->releaseCompletedOperations();
+ pTrans->restart();
}
const NdbError err = pTrans->getNdbError();
diff --git a/ndb/test/src/UtilTransactions.cpp b/ndb/test/src/UtilTransactions.cpp
index 8963e580bca..a5a61cd0a34 100644
--- a/ndb/test/src/UtilTransactions.cpp
+++ b/ndb/test/src/UtilTransactions.cpp
@@ -412,7 +412,7 @@ UtilTransactions::clearTable3(Ndb* pNdb,
if(check != -1){
check = pTrans->execute(Commit);
- pTrans->releaseCompletedOperations();
+ pTrans->restart();
}
err = pTrans->getNdbError();
@@ -536,7 +536,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
} while((eof = rs->nextResult(false)) == 0);
check = pTrans->execute(Commit);
- pTrans->releaseCompletedOperations();
+ pTrans->restart();
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
ERR(err);
diff --git a/ndb/tools/delete_all.cpp b/ndb/tools/delete_all.cpp
index dabd9a0e8fa..5110947c6a2 100644
--- a/ndb/tools/delete_all.cpp
+++ b/ndb/tools/delete_all.cpp
@@ -143,7 +143,7 @@ int clear_table(Ndb* pNdb, const NdbDictionary::Table* pTab, int parallelism)
if(check != -1){
check = pTrans->execute(Commit);
- pTrans->releaseCompletedOperations();
+ pTrans->restart();
}
err = pTrans->getNdbError();
From 2b9172a3454be979a72e69cfb2de18ab43346eb1 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 16 Jun 2004 13:45:04 +0200
Subject: [PATCH 009/579] wl1671 - Removed debug code
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 5 -----
1 file changed, 5 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index fd0dd1624ea..e822dfd8c51 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -6480,7 +6480,6 @@ void Dbtc::execSCAN_HBREP(Signal* signal)
/* Timeout has occured on a fragment which means a scan has timed out. */
/* If this is true we have an error in LQH/ACC. */
/*--------------------------------------------------------------------------*/
-static int kalle = 0;
void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
{
ScanFragRecPtr ptr;
@@ -6520,10 +6519,6 @@ void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
run.remove(ptr);
comp.add(ptr);
ptr.p->stopFragTimer();
- } else {
- kalle++;
- if(kalle > 5)
- ndbassert(scanptr.p->scanState != ScanRecord::CLOSING_SCAN);
}
scanError(signal, scanptr, ZSCAN_FRAG_LQH_ERROR);
From fcc8d9346f10c8abb5936a58bf7f4eb4d73094bd Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 16 Jun 2004 16:02:45 +0200
Subject: [PATCH 010/579] wl1671 - bug fix, null with scans
---
ndb/src/ndbapi/NdbReceiver.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/ndb/src/ndbapi/NdbReceiver.cpp b/ndb/src/ndbapi/NdbReceiver.cpp
index 7a538de3d7c..b05e84f3e42 100644
--- a/ndb/src/ndbapi/NdbReceiver.cpp
+++ b/ndb/src/ndbapi/NdbReceiver.cpp
@@ -146,7 +146,7 @@ NdbReceiver::copyout(NdbReceiver & dstRec){
while(dst){
Uint32 len = ((src->theAttrSize * src->theArraySize)+3)/4;
- dst->receive_data((Uint32*)src->aRef(), len);
+ dst->receive_data((Uint32*)src->aRef(), src->isNULL() ? 0 : len);
src = src->next();
dst = dst->next();
}
From 534b492aecba4a4e069545f23867459775df0c89 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Thu, 17 Jun 2004 23:42:17 +0200
Subject: [PATCH 011/579] Merge blobs
---
ndb/include/ndbapi/NdbBlob.hpp | 1 +
ndb/include/ndbapi/NdbOperation.hpp | 8 ++--
ndb/include/ndbapi/NdbScanOperation.hpp | 12 +++---
ndb/src/ndbapi/NdbBlob.cpp | 21 ++++++-----
ndb/src/ndbapi/NdbReceiver.cpp | 6 ++-
ndb/src/ndbapi/NdbResultSet.cpp | 14 ++++++-
ndb/src/ndbapi/NdbScanOperation.cpp | 50 ++++++++++++++++++++++++-
ndb/test/ndbapi/testBlobs.cpp | 27 ++++++-------
ndb/test/ndbapi/testDataBuffers.cpp | 2 +-
9 files changed, 101 insertions(+), 40 deletions(-)
diff --git a/ndb/include/ndbapi/NdbBlob.hpp b/ndb/include/ndbapi/NdbBlob.hpp
index 9398f77c474..16df56e230b 100644
--- a/ndb/include/ndbapi/NdbBlob.hpp
+++ b/ndb/include/ndbapi/NdbBlob.hpp
@@ -187,6 +187,7 @@ private:
friend class NdbOperation;
friend class NdbScanOperation;
friend class NdbDictionaryImpl;
+ friend class NdbResultSet; // atNextResult
// state
State theState;
void setState(State newState);
diff --git a/ndb/include/ndbapi/NdbOperation.hpp b/ndb/include/ndbapi/NdbOperation.hpp
index 0d51d3e8d43..6185225f6d1 100644
--- a/ndb/include/ndbapi/NdbOperation.hpp
+++ b/ndb/include/ndbapi/NdbOperation.hpp
@@ -763,10 +763,8 @@ protected:
* These are support methods only used locally in this class.
******************************************************************************/
- virtual int equal_impl(const NdbColumnImpl* anAttrObject,
- const char* aValue,
- Uint32 len);
- NdbRecAttr* getValue_impl(const NdbColumnImpl* anAttrObject, char* aValue = 0);
+ virtual int equal_impl(const NdbColumnImpl*,const char* aValue, Uint32 len);
+ virtual NdbRecAttr* getValue_impl(const NdbColumnImpl*, char* aValue = 0);
int setValue(const NdbColumnImpl* anAttrObject, const char* aValue, Uint32 len);
NdbBlob* getBlobHandle(NdbConnection* aCon, const NdbColumnImpl* anAttrObject);
int incValue(const NdbColumnImpl* anAttrObject, Uint32 aValue);
@@ -809,7 +807,7 @@ protected:
// get table or index key from prepared signals
int getKeyFromTCREQ(Uint32* data, unsigned size);
- int getKeyFromKEYINFO20(Uint32* data, unsigned size);
+
/******************************************************************************
* These are the private variables that are defined in the operation objects.
*****************************************************************************/
diff --git a/ndb/include/ndbapi/NdbScanOperation.hpp b/ndb/include/ndbapi/NdbScanOperation.hpp
index 94c9d09cbc2..4490b2d6f1a 100644
--- a/ndb/include/ndbapi/NdbScanOperation.hpp
+++ b/ndb/include/ndbapi/NdbScanOperation.hpp
@@ -42,7 +42,7 @@ class NdbScanOperation : public NdbOperation {
friend class NdbConnection;
friend class NdbResultSet;
friend class NdbOperation;
-
+ friend class NdbBlob;
public:
/**
* Type of cursor
@@ -92,13 +92,12 @@ public:
return readTuples(LM_Exclusive, 0, parallell);
}
-protected:
- CursorType m_cursor_type;
-
NdbBlob* getBlobHandle(const char* anAttrName);
NdbBlob* getBlobHandle(Uint32 anAttrId);
-private:
+protected:
+ CursorType m_cursor_type;
+
NdbScanOperation(Ndb* aNdb);
~NdbScanOperation();
@@ -154,8 +153,9 @@ private:
void receiver_completed(NdbReceiver*);
void execCLOSE_SCAN_REP();
+ int getKeyFromKEYINFO20(Uint32* data, unsigned size);
NdbOperation* takeOverScanOp(OperationType opType, NdbConnection*);
-
+
Uint32 m_ordered;
};
diff --git a/ndb/src/ndbapi/NdbBlob.cpp b/ndb/src/ndbapi/NdbBlob.cpp
index 8e067f770e8..638012b6a00 100644
--- a/ndb/src/ndbapi/NdbBlob.cpp
+++ b/ndb/src/ndbapi/NdbBlob.cpp
@@ -14,13 +14,14 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
-#include "Ndb.hpp"
-#include "NdbDictionaryImpl.hpp"
-#include "NdbConnection.hpp"
-#include "NdbOperation.hpp"
-#include "NdbIndexOperation.hpp"
-#include "NdbRecAttr.hpp"
-#include "NdbBlob.hpp"
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
#ifdef NDB_BLOB_DEBUG
#define DBG(x) \
@@ -301,7 +302,7 @@ NdbBlob::getTableKeyValue(NdbOperation* anOp)
assert(c != NULL);
if (c->m_pk) {
unsigned len = c->m_attrSize * c->m_arraySize;
- if (anOp->getValue(c, (char*)&data[pos]) == NULL) {
+ if (anOp->getValue_impl(c, (char*)&data[pos]) == NULL) {
setErrorCode(anOp);
return -1;
}
@@ -382,7 +383,7 @@ int
NdbBlob::getHeadInlineValue(NdbOperation* anOp)
{
DBG("getHeadInlineValue");
- theHeadInlineRecAttr = anOp->getValue(theColumn, theHeadInlineBuf.data);
+ theHeadInlineRecAttr = anOp->getValue_impl(theColumn, theHeadInlineBuf.data);
if (theHeadInlineRecAttr == NULL) {
setErrorCode(anOp);
return -1;
@@ -1250,7 +1251,7 @@ NdbBlob::atNextResult()
// get primary key
{ Uint32* data = (Uint32*)theKeyBuf.data;
unsigned size = theTable->m_sizeOfKeysInWords;
- if (theNdbOp->getKeyFromKEYINFO20(data, size) == -1) {
+ if (((NdbScanOperation*)theNdbOp)->getKeyFromKEYINFO20(data, size) == -1) {
setErrorCode(ErrUsage);
return -1;
}
diff --git a/ndb/src/ndbapi/NdbReceiver.cpp b/ndb/src/ndbapi/NdbReceiver.cpp
index b05e84f3e42..0c85f76dfc3 100644
--- a/ndb/src/ndbapi/NdbReceiver.cpp
+++ b/ndb/src/ndbapi/NdbReceiver.cpp
@@ -100,9 +100,11 @@ NdbReceiver::do_get_value(NdbReceiver * org, Uint32 rows, Uint32 key_size){
key.m_attrSize = 4;
key.m_nullable = true; // So that receive works w.r.t KEYINFO20
}
-
+ m_key_info = key_size;
+
for(Uint32 i = 0; i 0);
// Put key-recAttr fir on each row
if(key_size && !getValue(&key, (char*)0)){
@@ -112,7 +114,7 @@ NdbReceiver::do_get_value(NdbReceiver * org, Uint32 rows, Uint32 key_size){
NdbRecAttr* tRecAttr = org->theFirstRecAttr;
while(tRecAttr != 0){
- if(getValue(&NdbColumnImpl::getImpl(*tRecAttr->m_column), (char*)0))
+ if(getValue(&NdbColumnImpl::getImpl(*tRecAttr->m_column), (char*)0) != 0)
tRecAttr = tRecAttr->next();
else
break;
diff --git a/ndb/src/ndbapi/NdbResultSet.cpp b/ndb/src/ndbapi/NdbResultSet.cpp
index d15c58ba972..2c5d4a43c4c 100644
--- a/ndb/src/ndbapi/NdbResultSet.cpp
+++ b/ndb/src/ndbapi/NdbResultSet.cpp
@@ -29,6 +29,7 @@
#include
#include
#include
+#include
NdbResultSet::NdbResultSet(NdbScanOperation *owner)
: m_operation(owner)
@@ -45,7 +46,18 @@ void NdbResultSet::init()
int NdbResultSet::nextResult(bool fetchAllowed)
{
- return m_operation->nextResult(fetchAllowed);
+ int res;
+ if ((res = m_operation->nextResult(fetchAllowed)) == 0) {
+ // handle blobs
+ NdbBlob* tBlob = m_operation->theBlobList;
+ while (tBlob != 0) {
+ if (tBlob->atNextResult() == -1)
+ return -1;
+ tBlob = tBlob->theNext;
+ }
+ return 0;
+ }
+ return res;
}
void NdbResultSet::close()
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 86ee0748127..0911d7ab496 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -644,7 +644,7 @@ void NdbScanOperation::closeScan()
{
int self = pthread_self() ;
- do {
+ if(m_transConnection) do {
TransporterFacade* tp = TransporterFacade::instance();
Guard guard(tp->theMutexPtr);
@@ -874,6 +874,26 @@ NdbScanOperation::doSendScan(int aProcessorId)
* in separate threads and thus increasing the parallelism during
* the scan process.
*****************************************************************************/
+int
+NdbScanOperation::getKeyFromKEYINFO20(Uint32* data, unsigned size)
+{
+ Uint32 idx = m_current_api_receiver;
+ Uint32 last = m_api_receivers_count;
+
+ Uint32 row;
+ NdbReceiver * tRec;
+ NdbRecAttr * tRecAttr;
+ if(idx < last && (tRec = m_api_receivers[idx])
+ && ((row = tRec->m_current_row) <= tRec->m_defined_rows)
+ && (tRecAttr = tRec->m_rows[row-1])){
+
+ const Uint32 * src = (Uint32*)tRecAttr->aRef();
+ memcpy(data, src, 4*size);
+ return 0;
+ }
+ return -1;
+}
+
NdbOperation*
NdbScanOperation::takeOverScanOp(OperationType opType, NdbConnection* pTrans){
@@ -940,13 +960,39 @@ NdbScanOperation::takeOverScanOp(OperationType opType, NdbConnection* pTrans){
tSignal->setSignal(GSN_KEYINFO);
KeyInfo * keyInfo = CAST_PTR(KeyInfo, tSignal->getDataPtrSend());
memcpy(keyInfo->keyData, src, 4 * left);
+ }
+ }
+ // create blob handles automatically
+ if (opType == DeleteRequest && m_currentTable->m_noOfBlobs != 0) {
+ for (unsigned i = 0; i < m_currentTable->m_columns.size(); i++) {
+ NdbColumnImpl* c = m_currentTable->m_columns[i];
+ assert(c != 0);
+ if (c->getBlobType()) {
+ if (newOp->getBlobHandle(pTrans, c) == NULL)
+ return NULL;
+ }
}
}
+
return newOp;
}
return 0;
}
+NdbBlob*
+NdbScanOperation::getBlobHandle(const char* anAttrName)
+{
+ return NdbOperation::getBlobHandle(m_transConnection,
+ m_currentTable->getColumn(anAttrName));
+}
+
+NdbBlob*
+NdbScanOperation::getBlobHandle(Uint32 anAttrId)
+{
+ return NdbOperation::getBlobHandle(m_transConnection,
+ m_currentTable->getColumn(anAttrId));
+}
+
NdbIndexScanOperation::NdbIndexScanOperation(Ndb* aNdb)
: NdbScanOperation(aNdb)
{
@@ -980,7 +1026,7 @@ NdbIndexScanOperation::getValue_impl(const NdbColumnImpl* attrInfo,
if(!attrInfo->getPrimaryKey() || !m_ordered){
return NdbScanOperation::getValue_impl(attrInfo, aValue);
}
-
+
Uint32 id = attrInfo->m_attrId;
Uint32 marker = theTupleKeyDefined[id][0];
diff --git a/ndb/test/ndbapi/testBlobs.cpp b/ndb/test/ndbapi/testBlobs.cpp
index 001ec83630a..b880266f8de 100644
--- a/ndb/test/ndbapi/testBlobs.cpp
+++ b/ndb/test/ndbapi/testBlobs.cpp
@@ -584,13 +584,14 @@ verifyBlobTable(const Bcol& b, const Bval& v, Uint32 pk1, bool exists)
NdbRecAttr* ra_pk;
NdbRecAttr* ra_part;
NdbRecAttr* ra_data;
+ NdbResultSet* rs;
CHK((g_con = g_ndb->startTransaction()) != 0);
- CHK((g_opr = g_con->getNdbOperation(b.m_btname)) != 0);
- CHK(g_opr->openScanRead() == 0);
- CHK((ra_pk = g_opr->getValue("PK")) != 0);
- CHK((ra_part = g_opr->getValue("PART")) != 0);
- CHK((ra_data = g_opr->getValue("DATA")) != 0);
- CHK(g_con->executeScan() == 0);
+ CHK((g_ops = g_con->getNdbScanOperation(b.m_btname)) != 0);
+ CHK((rs = g_ops->readTuples()) != 0);
+ CHK((ra_pk = g_ops->getValue("PK")) != 0);
+ CHK((ra_part = g_ops->getValue("PART")) != 0);
+ CHK((ra_data = g_ops->getValue("DATA")) != 0);
+ CHK(g_con->execute(NoCommit) == 0);
unsigned partcount;
if (! exists || v.m_len <= b.m_inline)
partcount = 0;
@@ -600,7 +601,7 @@ verifyBlobTable(const Bcol& b, const Bval& v, Uint32 pk1, bool exists)
memset(seen, 0, partcount);
while (1) {
int ret;
- CHK((ret = g_con->nextScanResult()) == 0 || ret == 1);
+ CHK((ret = rs->nextResult()) == 0 || ret == 1);
if (ret == 1)
break;
if (pk1 != ra_pk->u_32_value())
@@ -620,7 +621,7 @@ verifyBlobTable(const Bcol& b, const Bval& v, Uint32 pk1, bool exists)
for (unsigned i = 0; i < partcount; i++)
CHK(seen[i] == 1);
g_ndb->closeTransaction(g_con);
- g_opr = 0;
+ g_ops = 0;
g_con = 0;
return 0;
}
@@ -829,9 +830,9 @@ readScan(bool rw, bool idx)
if (! idx) {
CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_tname)) != 0);
} else {
- CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
+ CHK((g_ops = g_con->getNdbIndexScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
}
- CHK((rs = g_ops->readTuples(240, NdbScanOperation::LM_Exclusive)) != 0);
+ CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Exclusive)) != 0);
CHK(g_ops->getValue("PK1", (char*)&tup.m_pk1) != 0);
if (g_opt.m_pk2len != 0)
CHK(g_ops->getValue("PK2", tup.m_pk2) != 0);
@@ -921,9 +922,9 @@ deleteScan(bool idx)
if (! idx) {
CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_tname)) != 0);
} else {
- CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
+ CHK((g_ops = g_con->getNdbIndexScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
}
- CHK((rs = g_ops->readTuples(240, NdbScanOperation::LM_Exclusive)) != 0);
+ CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Exclusive)) != 0);
CHK(g_ops->getValue("PK1", (char*)&tup.m_pk1) != 0);
if (g_opt.m_pk2len != 0)
CHK(g_ops->getValue("PK2", tup.m_pk2) != 0);
@@ -1131,7 +1132,7 @@ NDB_COMMAND(testOdbcDriver, "testBlobs", "testBlobs", "testBlobs", 65535)
if (strcmp(arg, "-dbgall") == 0) {
g_opt.m_dbg = true;
g_opt.m_dbgall = true;
- putenv("NDB_BLOB_DEBUG=1");
+ putenv(strdup("NDB_BLOB_DEBUG=1"));
continue;
}
if (strcmp(arg, "-full") == 0) {
diff --git a/ndb/test/ndbapi/testDataBuffers.cpp b/ndb/test/ndbapi/testDataBuffers.cpp
index ea13ec1b069..2e29dbb0d7b 100644
--- a/ndb/test/ndbapi/testDataBuffers.cpp
+++ b/ndb/test/ndbapi/testDataBuffers.cpp
@@ -440,7 +440,7 @@ testcase(int flag)
int newkey = 0;
if ((con = ndb->startTransaction()) == 0)
return ndberror("startTransaction key=%d", key);
- if ((sop = con->getNdbScanOperation(tab)) == 0)
+ if ((op = sop = con->getNdbScanOperation(tab)) == 0)
return ndberror("getNdbOperation key=%d", key);
if ((rs = sop->readTuples(1)) == 0)
return ndberror("openScanRead key=%d", key);
From 9619ce2bda27bd4200e7de62dd1040b6631f0c9c Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Thu, 17 Jun 2004 23:56:39 +0200
Subject: [PATCH 012/579] Reset null indicator
---
ndb/src/ndbapi/NdbRecAttr.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/ndb/src/ndbapi/NdbRecAttr.cpp b/ndb/src/ndbapi/NdbRecAttr.cpp
index 16ac98218ee..99a7c368af7 100644
--- a/ndb/src/ndbapi/NdbRecAttr.cpp
+++ b/ndb/src/ndbapi/NdbRecAttr.cpp
@@ -134,6 +134,7 @@ bool
NdbRecAttr::receive_data(const Uint32 * data, Uint32 sz){
const Uint32 n = (theAttrSize * theArraySize + 3) >> 2;
if(n == sz){
+ theNULLind = 0;
if(!copyoutRequired())
memcpy(theRef, data, 4 * sz);
else
From b6a16107fdb6f92d303053b1a704997bf7a756fa Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Fri, 18 Jun 2004 23:20:58 +0200
Subject: [PATCH 013/579] wl1873 impl + test prg
---
ndb/include/ndbapi/NdbResultSet.hpp | 5 ++
ndb/include/ndbapi/NdbScanOperation.hpp | 2 +
ndb/src/ndbapi/NdbResultSet.cpp | 5 ++
ndb/src/ndbapi/NdbScanOperation.cpp | 94 ++++++++++++++++++++++++-
ndb/test/ndbapi/testScan.cpp | 93 ++++++++++++++++++++++++
5 files changed, 197 insertions(+), 2 deletions(-)
diff --git a/ndb/include/ndbapi/NdbResultSet.hpp b/ndb/include/ndbapi/NdbResultSet.hpp
index 7cf18a6685d..483e08179c0 100644
--- a/ndb/include/ndbapi/NdbResultSet.hpp
+++ b/ndb/include/ndbapi/NdbResultSet.hpp
@@ -96,6 +96,11 @@ public:
*/
void close();
+ /**
+ * Restart
+ */
+ int restart();
+
/**
* Transfer scan operation to an updating transaction. Use this function
* when a scan has found a record that you want to update.
diff --git a/ndb/include/ndbapi/NdbScanOperation.hpp b/ndb/include/ndbapi/NdbScanOperation.hpp
index a329505ef1b..c81624e3769 100644
--- a/ndb/include/ndbapi/NdbScanOperation.hpp
+++ b/ndb/include/ndbapi/NdbScanOperation.hpp
@@ -151,6 +151,8 @@ protected:
NdbOperation* takeOverScanOp(OperationType opType, NdbConnection*);
Uint32 m_ordered;
+
+ int restart();
};
inline
diff --git a/ndb/src/ndbapi/NdbResultSet.cpp b/ndb/src/ndbapi/NdbResultSet.cpp
index d15c58ba972..489b94e91eb 100644
--- a/ndb/src/ndbapi/NdbResultSet.cpp
+++ b/ndb/src/ndbapi/NdbResultSet.cpp
@@ -77,3 +77,8 @@ NdbResultSet::deleteTuple(NdbConnection * takeOverTrans){
return -1;
return 0;
}
+
+int
+NdbResultSet::restart(){
+ return m_operation->restart();
+}
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 86ee0748127..312ad196379 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -448,6 +448,8 @@ NdbScanOperation::executeCursor(int nodeId){
return -1;
}
+#define DEBUG_NEXT_RESULT 0
+
int NdbScanOperation::nextResult(bool fetchAllowed)
{
if(m_ordered)
@@ -460,6 +462,11 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
Uint32 idx = m_current_api_receiver;
Uint32 last = m_api_receivers_count;
+ if(DEBUG_NEXT_RESULT)
+ ndbout_c("nextResult(%d) idx=%d last=%d",
+ fetchAllowed,
+ idx, last);
+
/**
* Check next buckets
*/
@@ -1147,8 +1154,6 @@ NdbIndexScanOperation::compare(Uint32 skip, Uint32 cols,
return 0;
}
-#define DEBUG_NEXT_RESULT 0
-
int
NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
@@ -1299,3 +1304,88 @@ NdbIndexScanOperation::send_next_scan_ordered(Uint32 idx){
tSignal.setLength(4+1);
return tp->sendSignal(&tSignal, nodeId);
}
+
+int
+NdbScanOperation::restart(){
+ TransporterFacade* tp = TransporterFacade::instance();
+ Guard guard(tp->theMutexPtr);
+
+ Uint32 seq = theNdbCon->theNodeSequence;
+ Uint32 nodeId = theNdbCon->theDBnode;
+
+ if(seq != tp->getNodeSequence(nodeId)){
+ theNdbCon->theReleaseOnClose = true;
+ return -1;
+ }
+
+ while(m_sent_receivers_count){
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ switch(return_code){
+ case 0:
+ break;
+ case -1:
+ setErrorCode(4008);
+ case -2:
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ m_sent_receivers_count = 0;
+ return -1;
+ }
+ }
+
+ if(m_api_receivers_count+m_conf_receivers_count){
+ // Send close scan
+ if(send_next_scan(0, true) == -1) // Close scan
+ return -1;
+ }
+
+ /**
+ * wait for close scan conf
+ */
+ while(m_sent_receivers_count+m_api_receivers_count+m_conf_receivers_count){
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ switch(return_code){
+ case 0:
+ break;
+ case -1:
+ setErrorCode(4008);
+ case -2:
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ m_sent_receivers_count = 0;
+ return -1;
+ }
+ }
+
+ /**
+ * Reset receivers
+ */
+ const Uint32 parallell = theParallelism;
+
+ for(Uint32 i = 0; im_list_index = i;
+ m_prepared_receivers[i] = m_receivers[i]->getId();
+ m_sent_receivers[i] = m_receivers[i];
+ m_conf_receivers[i] = 0;
+ m_api_receivers[i] = 0;
+ m_receivers[i]->prepareSend();
+ }
+
+ m_api_receivers_count = 0;
+ m_current_api_receiver = 0;
+ m_sent_receivers_count = parallell;
+ m_conf_receivers_count = 0;
+
+ if(m_ordered){
+ m_current_api_receiver = parallell;
+ }
+
+ if (doSendScan(nodeId) == -1)
+ return -1;
+
+ return 0;
+}
diff --git a/ndb/test/ndbapi/testScan.cpp b/ndb/test/ndbapi/testScan.cpp
index bc3be0b7dc9..ccddd4b59ce 100644
--- a/ndb/test/ndbapi/testScan.cpp
+++ b/ndb/test/ndbapi/testScan.cpp
@@ -970,6 +970,93 @@ int runCheckInactivityBeforeClose(NDBT_Context* ctx, NDBT_Step* step){
}
+int runScanRestart(NDBT_Context* ctx, NDBT_Step* step){
+ int loops = ctx->getNumLoops();
+ int records = ctx->getNumRecords();
+ Ndb * pNdb = GETNDB(step);
+ const NdbDictionary::Table* pTab = ctx->getTab();
+
+ HugoCalculator calc(* pTab);
+ NDBT_ResultRow tmpRow(* pTab);
+
+ int i = 0;
+ while (iisTestStopped()) {
+ g_info << i++ << ": ";
+ const int record = (rand() % records);
+ g_info << " row=" << record;
+
+ NdbConnection* pCon = pNdb->startTransaction();
+ NdbScanOperation* pOp = pCon->getNdbScanOperation(pTab->getName());
+ if (pOp == NULL) {
+ ERR(pCon->getNdbError());
+ return NDBT_FAILED;
+ }
+
+ NdbResultSet* rs = pOp->readTuples();
+ if( rs == 0 ) {
+ ERR(pCon->getNdbError());
+ return NDBT_FAILED;
+ }
+
+ int check = pOp->interpret_exit_ok();
+ if( check == -1 ) {
+ ERR(pCon->getNdbError());
+ return NDBT_FAILED;
+ }
+
+ // Define attributes to read
+ for(int a = 0; agetNoOfColumns(); a++){
+ if((tmpRow.attributeStore(a) =
+ pOp->getValue(pTab->getColumn(a)->getName())) == 0) {
+ ERR(pCon->getNdbError());
+ return NDBT_FAILED;
+ }
+ }
+
+ check = pCon->execute(NoCommit);
+ if( check == -1 ) {
+ ERR(pCon->getNdbError());
+ return NDBT_FAILED;
+ }
+
+ int res;
+ int row = 0;
+ while(row < record && (res = rs->nextResult()) == 0) {
+ if(calc.verifyRowValues(&tmpRow) != 0){
+ abort();
+ return NDBT_FAILED;
+ }
+ row++;
+ }
+ if(row != record){
+ ERR(pCon->getNdbError());
+ abort();
+ return NDBT_FAILED;
+ }
+ g_info << " restarting" << endl;
+ if((res = rs->restart()) != 0){
+ ERR(pCon->getNdbError());
+ abort();
+ return NDBT_FAILED;
+ }
+
+ row = 0;
+ while((res = rs->nextResult()) == 0) {
+ if(calc.verifyRowValues(&tmpRow) != 0){
+ abort();
+ return NDBT_FAILED;
+ }
+ row++;
+ }
+ if(res != 1 || row != records){
+ ERR(pCon->getNdbError());
+ abort();
+ return NDBT_FAILED;
+ }
+ pCon->close();
+ }
+ return NDBT_OK;
+}
NDBT_TESTSUITE(testScan);
@@ -1393,6 +1480,12 @@ TESTCASE("ScanReadWhileNodeIsDown",
STEP(runStopAndStartNode);
FINALIZER(runClearTable);
}
+TESTCASE("ScanRestart",
+ "Verify restart functionallity"){
+ INITIALIZER(runLoadTable);
+ STEP(runScanRestart);
+ FINALIZER(runClearTable);
+}
NDBT_TESTSUITE_END(testScan);
int main(int argc, const char** argv){
From 6b4d60e668cd15183165f98ed7cd089b43b65c95 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Mon, 21 Jun 2004 21:59:27 +0200
Subject: [PATCH 014/579] BUG#4230 - fixed
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 36 +++++--
ndb/test/ndbapi/testTimeout.cpp | 135 ++++++++++++++++++++++++
2 files changed, 164 insertions(+), 7 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index f259cd8e391..4a9a0617b90 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -1686,6 +1686,20 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
return;
}
+ case 59:{
+ jam();
+ const TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0];
+ const Uint32 t1 = tcKeyReq->transId1;
+ const Uint32 t2 = tcKeyReq->transId2;
+ signal->theData[0] = apiConnectptr.p->ndbapiConnect;
+ signal->theData[1] = t1;
+ signal->theData[2] = t2;
+ signal->theData[3] = ZABORTINPROGRESS;
+ sendSignal(apiConnectptr.p->ndbapiBlockref,
+ GSN_TCROLLBACKREP, signal, 4, JBB);
+ return;
+ }
+
default:
jam();
systemErrorLab(signal);
@@ -2363,6 +2377,8 @@ void Dbtc::execTCKEYREQ(Signal* signal)
apiConnectptr.p = regApiPtr;
Uint32 TstartFlag = tcKeyReq->getStartFlag(Treqinfo);
+ Uint32 TexecFlag = TcKeyReq::getExecuteFlag(Treqinfo);
+
bool isIndexOp = regApiPtr->isIndexOp;
bool isIndexOpReturn = regApiPtr->indexOpReturn;
regApiPtr->isIndexOp = false; // Reset marker
@@ -2416,14 +2432,17 @@ void Dbtc::execTCKEYREQ(Signal* signal)
//--------------------------------------------------------------------
jam();
initApiConnectRec(signal, regApiPtr);
- } else {
+ } else if(TexecFlag) {
+ TCKEY_abort(signal, 59);
+ return;
+ } else {
//--------------------------------------------------------------------
// The current transaction was aborted successfully.
// We will not do anything before we receive an operation
// with a start indicator. We will ignore this signal.
//--------------------------------------------------------------------
- jam();
- // DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, ==AS_IDLE");
+ jam();
+ DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, ==AS_IDLE");
return;
}//if
} else {
@@ -2438,11 +2457,14 @@ void Dbtc::execTCKEYREQ(Signal* signal)
//--------------------------------------------------------------------
TCKEY_abort(signal, 2);
return;
- }//if
+ } else if(TexecFlag) {
+ TCKEY_abort(signal, 59);
+ return;
+ }
//----------------------------------------------------------------------
// Ignore signals without start indicator set when aborting transaction.
//----------------------------------------------------------------------
- // DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, !=AS_IDLE");
+ DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, !=AS_IDLE");
return;
}//if
break;
@@ -2532,7 +2554,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
regTcPtr->triggeringOperation = TsenderData;
}
- if (TcKeyReq::getExecuteFlag(Treqinfo)){
+ if (TexecFlag){
Uint32 currSPId = regApiPtr->currSavePointId;
regApiPtr->currSavePointId = ++currSPId;
}
@@ -2553,7 +2575,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
Uint8 TDistrGroupFlag = tcKeyReq->getDistributionGroupFlag(Treqinfo);
Uint8 TDistrGroupTypeFlag = tcKeyReq->getDistributionGroupTypeFlag(Treqinfo);
Uint8 TDistrKeyFlag = tcKeyReq->getDistributionKeyFlag(Treqinfo);
- Uint8 TexecuteFlag = tcKeyReq->getExecuteFlag(Treqinfo);
+ Uint8 TexecuteFlag = TexecFlag;
//RONM_TEST Disable simple reads temporarily
regCachePtr->opSimple = 0;
diff --git a/ndb/test/ndbapi/testTimeout.cpp b/ndb/test/ndbapi/testTimeout.cpp
index 8a7866880b3..ba6b53df9a9 100644
--- a/ndb/test/ndbapi/testTimeout.cpp
+++ b/ndb/test/ndbapi/testTimeout.cpp
@@ -95,6 +95,131 @@ int runTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
return result;
}
+int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
+ int result = NDBT_OK;
+ int loops = ctx->getNumLoops();
+ NdbConfig conf(GETNDB(step)->getNodeId()+1);
+ unsigned int nodeId = conf.getMasterNodeId();
+ int stepNo = step->getStepNo();
+ int mul1 = ctx->getProperty("Op1", (Uint32)0);
+ int mul2 = ctx->getProperty("Op2", (Uint32)0);
+ int records = ctx->getNumRecords();
+
+ Uint32 timeoutVal;
+ if (!conf.getProperty(nodeId,
+ NODE_TYPE_DB,
+ CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
+ &timeoutVal)){
+ return NDBT_FAILED;
+ }
+
+ int minSleep = (int)(timeoutVal * 1.5);
+ int maxSleep = timeoutVal * 2;
+
+ HugoOperations hugoOps(*ctx->getTab());
+ Ndb* pNdb = GETNDB(step);
+
+ for (int l = 0; l < loops && !ctx->isTestStopped(); l++){
+
+ int op1 = 0 + (l + stepNo) * mul1;
+ int op2 = 0 + (l + stepNo) * mul2;
+
+ op1 = (op1 % 5);
+ op2 = (op2 % 5);
+
+ ndbout << stepNo << ": TransactionInactiveTimeout="<
Date: Mon, 21 Jun 2004 22:37:05 +0200
Subject: [PATCH 015/579] Fix testBasicAsynch Fix debug require in TC
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 1 -
ndb/test/src/HugoAsynchTransactions.cpp | 2 +-
2 files changed, 1 insertion(+), 2 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index 4a9a0617b90..4f1e6cdd74c 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -8508,7 +8508,6 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
SCAN_TAB_error:
jam();
- ndbrequire(false);
ScanTabRef * ref = (ScanTabRef*)&signal->theData[0];
ref->apiConnectPtr = transP->ndbapiConnect;
ref->transId1 = transid1;
diff --git a/ndb/test/src/HugoAsynchTransactions.cpp b/ndb/test/src/HugoAsynchTransactions.cpp
index 2af22b5f48d..5bedf26aa62 100644
--- a/ndb/test/src/HugoAsynchTransactions.cpp
+++ b/ndb/test/src/HugoAsynchTransactions.cpp
@@ -476,7 +476,7 @@ HugoAsynchTransactions::executeAsynchOperation(Ndb* pNdb,
case NO_INSERT:
case NO_UPDATE:
case NO_DELETE:
- abort();
+ break;
}
// Close all transactions
From 46455f57848313415e908e0062738b308e117d20 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Mon, 21 Jun 2004 22:44:14 +0200
Subject: [PATCH 016/579] Fix testDict -n InvalidTables
---
ndb/test/src/NDBT_Tables.cpp | 24 ++++++++++++++++++++----
1 file changed, 20 insertions(+), 4 deletions(-)
diff --git a/ndb/test/src/NDBT_Tables.cpp b/ndb/test/src/NDBT_Tables.cpp
index 8fd2d4042fd..ce8fe68d8a4 100644
--- a/ndb/test/src/NDBT_Tables.cpp
+++ b/ndb/test/src/NDBT_Tables.cpp
@@ -430,7 +430,7 @@ NDBT_Table F2("F2", sizeof(F2Attribs)/sizeof(NDBT_Attribute), F2Attribs);
/* F3
*
- * Error: Too many primary keys defined, 16 is max?
+ * Error: Too many primary keys defined, 32 is max
*/
static
const
@@ -452,10 +452,26 @@ NDBT_Attribute F3Attribs[] = {
NDBT_Attribute("KOL15", NdbDictionary::Column::Unsigned, 1, true),
NDBT_Attribute("KOL16", NdbDictionary::Column::Unsigned, 1, true),
NDBT_Attribute("KOL17", NdbDictionary::Column::Unsigned, 1, true),
- NDBT_Attribute("KOL20", NdbDictionary::Column::Unsigned),
- NDBT_Attribute("KOL30", NdbDictionary::Column::Unsigned),
+ NDBT_Attribute("KOL18", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL19", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL20", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL21", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL22", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL23", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL24", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL25", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL26", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL27", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL28", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL29", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL30", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL31", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL32", NdbDictionary::Column::Unsigned, 1, true),
+ NDBT_Attribute("KOL33", NdbDictionary::Column::Unsigned, 1, true),
NDBT_Attribute("KOL40", NdbDictionary::Column::Unsigned),
- NDBT_Attribute("KOL50", NdbDictionary::Column::Unsigned)
+ NDBT_Attribute("KOL50", NdbDictionary::Column::Unsigned),
+ NDBT_Attribute("KOL60", NdbDictionary::Column::Unsigned),
+ NDBT_Attribute("KOL70", NdbDictionary::Column::Unsigned)
};
static
From da8ab00d124e5156735178ab3ab684f7c18d6644 Mon Sep 17 00:00:00 2001
From: "mskold@mysql.com" <>
Date: Tue, 22 Jun 2004 09:54:00 +0200
Subject: [PATCH 017/579] Added static print error function to be used by
handler in ndbcluster_commit and ndbcluster_rollback
---
sql/ha_ndbcluster.cc | 21 +++++++++++++++++++++
sql/ha_ndbcluster.h | 1 +
2 files changed, 22 insertions(+)
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index c76534943b8..cfa71a0a886 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -63,6 +63,9 @@ typedef NdbDictionary::Dictionary NDBDICT;
bool ndbcluster_inited= false;
+TABLE *g_tab_dummy;
+static ha_ndbcluster* g_ha_error= NULL;
+
static Ndb* g_ndb= NULL;
// Handler synchronization
@@ -2689,6 +2692,15 @@ int ha_ndbcluster::open(const char *name, int mode, uint test_if_locked)
DBUG_PRINT("enter", ("name: %s mode: %d test_if_locked: %d",
name, mode, test_if_locked));
+ // Create error handler needed for error msg handling in static
+ // handler functions (ha_commit_trans and ha_rollback_trans)
+ if (!g_ha_error)
+ {
+ g_tab_dummy = new TABLE();
+ g_tab_dummy->table_name = NULL;
+ g_ha_error= new ha_ndbcluster(g_tab_dummy);
+ }
+
// Setup ref_length to make room for the whole
// primary key to be written in the ref variable
@@ -2928,6 +2940,11 @@ bool ndbcluster_init()
bool ndbcluster_end()
{
DBUG_ENTER("ndbcluster_end");
+ if (g_ha_error)
+ {
+ delete g_tab_dummy;
+ delete g_ha_error;
+ }
delete g_ndb;
g_ndb= NULL;
if (!ndbcluster_inited)
@@ -2941,6 +2958,10 @@ bool ndbcluster_end()
DBUG_RETURN(0);
}
+void ndbcluster_print_error(int error)
+{
+ g_ha_error->print_error(error, MYF(0));
+}
/*
Set m_tabname from full pathname to table file
diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h
index df296648272..bd22abdf264 100644
--- a/sql/ha_ndbcluster.h
+++ b/sql/ha_ndbcluster.h
@@ -227,6 +227,7 @@ int ndbcluster_discover(const char* dbname, const char* name,
const void** frmblob, uint* frmlen);
int ndbcluster_drop_database(const char* path);
+void ndbcluster_print_error(int error);
From 8488322906ccc5a795af643da38e732262ed90fc Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Tue, 22 Jun 2004 11:47:58 +0200
Subject: [PATCH 018/579] wl1671 - bug fix
---
.../common/debugger/signaldata/ScanTab.cpp | 43 +++++++++++++------
ndb/src/ndbapi/NdbScanOperation.cpp | 4 +-
2 files changed, 33 insertions(+), 14 deletions(-)
diff --git a/ndb/src/common/debugger/signaldata/ScanTab.cpp b/ndb/src/common/debugger/signaldata/ScanTab.cpp
index b0383d6d6df..eabb53d1a49 100644
--- a/ndb/src/common/debugger/signaldata/ScanTab.cpp
+++ b/ndb/src/common/debugger/signaldata/ScanTab.cpp
@@ -74,17 +74,28 @@ printSCANTABCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 recei
fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n",
sig->transId1, sig->transId2);
- fprintf(output, " requestInfo: H\'%.8x(EndOfData: %d)\n",
- requestInfo, (requestInfo & ScanTabConf::EndOfData != 0));
-#if 0
- fprintf(output, " Operation(s):\n");
- for(int i = 0; i<16; i++){
- fprintf(output, " [%.2u]ix=%d l=%.2d,",
- i, sig->getIdx(sig->operLenAndIdx[i]), sig->getLen(sig->operLenAndIdx[i]));
- if (((i+1) % 4) == 0)
- fprintf(output, "\n");
+ fprintf(output, " requestInfo: Eod: %d OpCount: %d\n",
+ (requestInfo & ScanTabConf::EndOfData == ScanTabConf::EndOfData),
+ (requestInfo & (~ScanTabConf::EndOfData)));
+ size_t op_count= requestInfo & (~ScanTabConf::EndOfData);
+ if(op_count){
+ fprintf(output, " Operation(s) [api tc rows len]:\n");
+ ScanTabConf::OpData * op = (ScanTabConf::OpData*)
+ (theData + ScanTabConf::SignalLength);
+ for(int i = 0; iinfo != ScanTabConf::EndOfData)
+ fprintf(output, " [0x%x 0x%x %d %d]",
+ op->apiPtrI, op->tcPtrI,
+ ScanTabConf::getRows(op->info),
+ ScanTabConf::getLength(op->info));
+ else
+ fprintf(output, " [0x%x 0x%x eod]",
+ op->apiPtrI, op->tcPtrI);
+
+ op++;
+ }
+ fprintf(output, "\n");
}
-#endif
return false;
}
@@ -146,13 +157,21 @@ printSCANNEXTREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 recei
if(receiverBlockNo == DBTC){
const ScanNextReq * const sig = (ScanNextReq *) theData;
- fprintf(output, " aipConnectPtr: H\'%.8x\n",
+ fprintf(output, " apiConnectPtr: H\'%.8x\n",
sig->apiConnectPtr);
- fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n",
+ fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x) ",
sig->transId1, sig->transId2);
fprintf(output, " Stop this scan: %u\n", sig->stopScan);
+
+ const Uint32 * ops = theData + ScanNextReq::SignalLength;
+ if(len > ScanNextReq::SignalLength){
+ fprintf(output, " tcFragPtr(s): ");
+ for(size_t i = ScanNextReq::SignalLength; itheDBnode;
TransporterFacade* tp = TransporterFacade::instance();
Guard guard(tp->theMutexPtr);
From e6391b9493dfc24d84950689e62287f6062df7f1 Mon Sep 17 00:00:00 2001
From: "mskold@mysql.com" <>
Date: Tue, 22 Jun 2004 14:24:51 +0200
Subject: [PATCH 019/579] Added static print error function to be used by
handler in ndbcluster_commit and ndbcluster_rollback
---
sql/ha_ndbcluster.cc | 26 +++++++++++++++++---------
sql/handler.cc | 4 ++--
2 files changed, 19 insertions(+), 11 deletions(-)
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index d8fb742e54d..8bf2948563f 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -63,8 +63,10 @@ typedef NdbDictionary::Dictionary NDBDICT;
bool ndbcluster_inited= false;
+// Error handler for printing out ndbcluster error messages
TABLE *g_tab_dummy;
static ha_ndbcluster* g_ha_error= NULL;
+static bool g_error_handler = FALSE;
static Ndb* g_ndb= NULL;
@@ -2657,6 +2659,17 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg):
m_unique_index_name[i]= NULL;
}
+ // Create error handler needed for error msg handling in static
+ // handler functions (ha_commit_trans and ha_rollback_trans)
+ if (!g_error_handler)
+ {
+ DBUG_PRINT("info", ("Setting up error printing handler object"));
+ g_tab_dummy = new TABLE();
+ g_tab_dummy->table_name = NULL;
+ g_error_handler = TRUE;
+ g_ha_error= new ha_ndbcluster(g_tab_dummy);
+ }
+
DBUG_VOID_RETURN;
}
@@ -2692,15 +2705,6 @@ int ha_ndbcluster::open(const char *name, int mode, uint test_if_locked)
DBUG_PRINT("enter", ("name: %s mode: %d test_if_locked: %d",
name, mode, test_if_locked));
- // Create error handler needed for error msg handling in static
- // handler functions (ha_commit_trans and ha_rollback_trans)
- if (!g_ha_error)
- {
- g_tab_dummy = new TABLE();
- g_tab_dummy->table_name = NULL;
- g_ha_error= new ha_ndbcluster(g_tab_dummy);
- }
-
// Setup ref_length to make room for the whole
// primary key to be written in the ref variable
@@ -2942,8 +2946,12 @@ bool ndbcluster_end()
DBUG_ENTER("ndbcluster_end");
if (g_ha_error)
{
+ DBUG_PRINT("info", ("deallocating error printing handler object"));
delete g_tab_dummy;
+ g_tab_dummy= NULL;
delete g_ha_error;
+ g_ha_error= NULL;
+ g_ha_error = FALSE;
}
delete g_ndb;
g_ndb= NULL;
diff --git a/sql/handler.cc b/sql/handler.cc
index 717b2ee0ce8..c729b80d0ce 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -478,7 +478,7 @@ int ha_commit_trans(THD *thd, THD_TRANS* trans)
{
if ((error=ndbcluster_commit(thd,trans->ndb_tid)))
{
- my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
+ ndbcluster_print_error(error);
error=1;
}
if (trans == &thd->transaction.all)
@@ -544,7 +544,7 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans)
{
if ((error=ndbcluster_rollback(thd, trans->ndb_tid)))
{
- my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
+ ndbcluster_print_error(error);
error=1;
}
trans->ndb_tid = 0;
From 4915b228e1f2c6e6dc44d4cc62daa0868170d7da Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Tue, 22 Jun 2004 17:53:09 +0200
Subject: [PATCH 020/579] wl1671 - bug fixes for negative tests
---
ndb/src/ndbapi/NdbScanOperation.cpp | 11 ++-
ndb/test/ndbapi/ScanFunctions.hpp | 103 ++++++++++++++--------------
ndb/test/ndbapi/testScan.cpp | 19 +----
3 files changed, 60 insertions(+), 73 deletions(-)
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index 298fb300b47..efc167cbc5e 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -448,6 +448,8 @@ NdbScanOperation::executeCursor(int nodeId){
return -1;
}
+#define DEBUG_NEXT_RESULT 0
+
int NdbScanOperation::nextResult(bool fetchAllowed)
{
if(m_ordered)
@@ -459,6 +461,9 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
int retVal = 2;
Uint32 idx = m_current_api_receiver;
Uint32 last = m_api_receivers_count;
+
+ if(DEBUG_NEXT_RESULT)
+ ndbout_c("nextResult(%d) idx=%d last=%d", fetchAllowed, idx, last);
/**
* Check next buckets
@@ -497,6 +502,9 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
Uint32 cnt = m_conf_receivers_count;
Uint32 sent = m_sent_receivers_count;
+
+ if(DEBUG_NEXT_RESULT)
+ ndbout_c("idx=%d last=%d cnt=%d sent=%d", idx, last, cnt, sent);
if(cnt > 0){
/**
@@ -527,6 +535,7 @@ int NdbScanOperation::nextResult(bool fetchAllowed)
theNdb->theWaiter.m_state = WAIT_SCAN;
int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
if (return_code == 0 && seq == tp->getNodeSequence(nodeId)) {
+ theError.code = -1; // make sure user gets error if he tries again
return 1;
}
retVal = -1; //return_code;
@@ -1193,8 +1202,6 @@ NdbIndexScanOperation::compare(Uint32 skip, Uint32 cols,
return 0;
}
-#define DEBUG_NEXT_RESULT 0
-
int
NdbIndexScanOperation::next_result_ordered(bool fetchAllowed){
diff --git a/ndb/test/ndbapi/ScanFunctions.hpp b/ndb/test/ndbapi/ScanFunctions.hpp
index e0a88ab9e94..2ff4b751c33 100644
--- a/ndb/test/ndbapi/ScanFunctions.hpp
+++ b/ndb/test/ndbapi/ScanFunctions.hpp
@@ -79,9 +79,9 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
const int retryMax = 100;
int sleepTime = 10;
int check;
- NdbConnection *pTrans;
- NdbScanOperation *pOp;
- NdbResultSet *rs;
+ NdbConnection *pTrans = 0;
+ NdbScanOperation *pOp = 0;
+ NdbResultSet *rs = 0;
while (true){
if (retryAttempt >= retryMax){
@@ -104,78 +104,75 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
}
// Execute the scan without defining a scan operation
- if(action != ExecuteScanWithOutOpenScan){
-
- pOp = pTrans->getNdbScanOperation(tab.getName());
- if (pOp == NULL) {
+ pOp = pTrans->getNdbScanOperation(tab.getName());
+ if (pOp == NULL) {
+ ERR(pTrans->getNdbError());
+ pNdb->closeTransaction(pTrans);
+ return NDBT_FAILED;
+ }
+
+
+ rs = pOp->readTuples(exclusive ?
+ NdbScanOperation::LM_Exclusive :
+ NdbScanOperation::LM_Read);
+
+ if( rs == 0 ) {
+ ERR(pTrans->getNdbError());
+ pNdb->closeTransaction(pTrans);
+ return NDBT_FAILED;
+ }
+
+
+ if (action == OnlyOpenScanOnce){
+ // Call openScan one more time when it's already defined
+ NdbResultSet* rs2 = pOp->readTuples(NdbScanOperation::LM_Read);
+ if( rs2 == 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
-
- rs = pOp->readTuples(exclusive ?
- NdbScanOperation::LM_Exclusive :
- NdbScanOperation::LM_Read);
-
- if( rs == 0 ) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
-
-
- if (action == OnlyOpenScanOnce){
- // Call openScan one more time when it's already defined
- NdbResultSet* rs2 = pOp->readTuples(NdbScanOperation::LM_Read);
- if( rs2 == 0 ) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
-
- if (action==EqualAfterOpenScan){
- check = pOp->equal(tab.getColumn(0)->getName(), 10);
- if( check == -1 ) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
-
- check = pOp->interpret_exit_ok();
+ }
+
+ if (action==EqualAfterOpenScan){
+ check = pOp->equal(tab.getColumn(0)->getName(), 10);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
- }
-
- for(int a = 0; agetValue(tab.getColumn(a)->getName()) == NULL) {
- ERR(pTrans->getNdbError());
- pNdb->closeTransaction(pTrans);
- return NDBT_FAILED;
- }
- }
+ }
}
+
+ check = pOp->interpret_exit_ok();
+ if( check == -1 ) {
+ ERR(pTrans->getNdbError());
+ pNdb->closeTransaction(pTrans);
+ return NDBT_FAILED;
+ }
+
+ for(int a = 0; agetValue(tab.getColumn(a)->getName()) == NULL) {
+ ERR(pTrans->getNdbError());
+ pNdb->closeTransaction(pTrans);
+ return NDBT_FAILED;
+ }
+ }
+
check = pTrans->execute(NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
-
-
+
int abortCount = records / 10;
bool abortTrans = (action==CloseWithoutStop);
int eof;
int rows = 0;
eof = rs->nextResult();
-
+
while(eof == 0){
rows++;
-
+
if (abortCount == rows && abortTrans == true){
g_info << "Scan is aborted after "<getTab();
- int records = ctx->getNumRecords();
- int numFailed = 0;
- ScanFunctions scanF(*pTab);
- if (scanF.scanReadFunctions(GETNDB(step),
- records,
- 1,
- ScanFunctions::ExecuteScanWithOutOpenScan,
- false) == 0){
- numFailed++;
- }
-
- if(numFailed > 0)
- return NDBT_FAILED;
- else
- return NDBT_OK;
+ return NDBT_OK;
}
-
-
int runOnlyOneOpBeforeOpenScan(NDBT_Context* ctx, NDBT_Step* step){
const NdbDictionary::Table* pTab = ctx->getTab();
int records = ctx->getNumRecords();
From efa105bca71e265b294c25444c71ac8fab4a8364 Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.bredbandsbolaget.se" <>
Date: Wed, 23 Jun 2004 00:48:07 +0000
Subject: [PATCH 021/579] WL 1748
---
.../kernel/signaldata/ApiRegSignalData.hpp | 4 +-
ndb/include/mgmapi/mgmapi.h | 5 +
ndb/include/mgmapi/mgmapi_config_parameters.h | 2 +
ndb/include/mgmcommon/ConfigRetriever.hpp | 4 +-
ndb/include/portlib/NdbTCP.h | 2 +-
.../transporter/TransporterRegistry.hpp | 82 +++-
ndb/include/util/SocketAuthenticator.hpp | 39 ++
ndb/include/util/SocketClient.hpp | 38 ++
ndb/src/common/mgmcommon/ConfigInfo.cpp | 43 +-
ndb/src/common/mgmcommon/ConfigRetriever.cpp | 24 +-
ndb/src/common/mgmcommon/LocalConfig.cpp | 6 +
.../common/transporter/TCP_Transporter.cpp | 250 ++--------
.../common/transporter/TCP_Transporter.hpp | 83 +---
ndb/src/common/transporter/Transporter.cpp | 191 ++++----
ndb/src/common/transporter/Transporter.hpp | 105 ++---
.../transporter/TransporterRegistry.cpp | 439 +++++++++++-------
ndb/src/common/util/Makefile.am | 3 +-
ndb/src/common/util/SocketAuthenticator.cpp | 63 +++
ndb/src/common/util/SocketClient.cpp | 90 ++++
ndb/src/common/util/SocketServer.cpp | 2 +-
ndb/src/kernel/Makefile.am | 2 +-
ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp | 77 +--
ndb/src/kernel/blocks/qmgr/QmgrMain.cpp | 6 +-
ndb/src/kernel/{Main.cpp => main.cpp} | 18 +-
ndb/src/kernel/vm/ThreadConfig.cpp | 2 +-
ndb/src/mgmapi/mgmapi.cpp | 83 ++--
ndb/src/mgmsrv/MgmtSrvr.cpp | 137 +++++-
ndb/src/mgmsrv/MgmtSrvr.hpp | 8 +
ndb/src/mgmsrv/Services.cpp | 85 +++-
ndb/src/mgmsrv/Services.hpp | 1 +
ndb/src/mgmsrv/main.cpp | 140 +-----
ndb/src/ndbapi/ClusterMgr.cpp | 6 +
ndb/src/ndbapi/ClusterMgr.hpp | 1 +
ndb/src/ndbapi/TransporterFacade.cpp | 26 +-
ndb/src/ndbapi/TransporterFacade.hpp | 1 -
35 files changed, 1195 insertions(+), 873 deletions(-)
create mode 100644 ndb/include/util/SocketAuthenticator.hpp
create mode 100644 ndb/include/util/SocketClient.hpp
create mode 100644 ndb/src/common/util/SocketAuthenticator.cpp
create mode 100644 ndb/src/common/util/SocketClient.cpp
rename ndb/src/kernel/{Main.cpp => main.cpp} (94%)
diff --git a/ndb/include/kernel/signaldata/ApiRegSignalData.hpp b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
index 84dca8fb260..9ce99d3e45c 100644
--- a/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
+++ b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
@@ -80,13 +80,15 @@ class ApiRegConf {
friend class ClusterMgr;
public:
- STATIC_CONST( SignalLength = 3 + NodeState::DataLength );
+ STATIC_CONST( SignalLength = 3 + NodeState::DataLength +
+ NdbNodeBitmask::Size );
private:
Uint32 qmgrRef;
Uint32 version; // Version of NDB node
Uint32 apiHeartbeatFrequency;
NodeState nodeState;
+ Bitmask::Data connected_nodes;
};
#endif
diff --git a/ndb/include/mgmapi/mgmapi.h b/ndb/include/mgmapi/mgmapi.h
index 7b2f728bda8..45a421855b0 100644
--- a/ndb/include/mgmapi/mgmapi.h
+++ b/ndb/include/mgmapi/mgmapi.h
@@ -666,6 +666,11 @@ extern "C" {
*/
struct ndb_mgm_configuration * ndb_mgm_get_configuration(NdbMgmHandle handle,
unsigned version);
+
+ int ndb_mgm_alloc_nodeid(NdbMgmHandle handle,
+ unsigned version,
+ unsigned *pnodeid,
+ int nodetype);
/**
* Config iterator
*/
diff --git a/ndb/include/mgmapi/mgmapi_config_parameters.h b/ndb/include/mgmapi/mgmapi_config_parameters.h
index d3bb44c1523..22b9f8f31dd 100644
--- a/ndb/include/mgmapi/mgmapi_config_parameters.h
+++ b/ndb/include/mgmapi/mgmapi_config_parameters.h
@@ -76,6 +76,8 @@
#define CFG_DB_DISCLESS 148
+#define CFG_DB_SERVER_PORT 149
+
#define CFG_NODE_ARBIT_RANK 200
#define CFG_NODE_ARBIT_DELAY 201
diff --git a/ndb/include/mgmcommon/ConfigRetriever.hpp b/ndb/include/mgmcommon/ConfigRetriever.hpp
index 50d333b54dd..c1de751b797 100644
--- a/ndb/include/mgmcommon/ConfigRetriever.hpp
+++ b/ndb/include/mgmcommon/ConfigRetriever.hpp
@@ -77,7 +77,7 @@ public:
* Get config using socket
*/
struct ndb_mgm_configuration * getConfig(const char * mgmhost, short port,
- int versionId);
+ int versionId, int nodetype);
/**
* Get config from file
*/
@@ -98,7 +98,7 @@ private:
char * m_connectString;
char * m_defaultConnectString;
-
+
/**
* Verify config
*/
diff --git a/ndb/include/portlib/NdbTCP.h b/ndb/include/portlib/NdbTCP.h
index 42c34855c39..4dc8435eef1 100644
--- a/ndb/include/portlib/NdbTCP.h
+++ b/ndb/include/portlib/NdbTCP.h
@@ -64,7 +64,7 @@ typedef int socklen_t;
#define NDB_NONBLOCK O_NONBLOCK
#define NDB_SOCKET_TYPE int
#define NDB_INVALID_SOCKET -1
-#define NDB_CLOSE_SOCKET(x) close(x)
+#define NDB_CLOSE_SOCKET(x) ::close(x)
#define InetErrno errno
diff --git a/ndb/include/transporter/TransporterRegistry.hpp b/ndb/include/transporter/TransporterRegistry.hpp
index 6c979777f18..7a750b81478 100644
--- a/ndb/include/transporter/TransporterRegistry.hpp
+++ b/ndb/include/transporter/TransporterRegistry.hpp
@@ -29,20 +29,10 @@
#define TransporterRegistry_H
#include "TransporterDefinitions.hpp"
+#include
#include
-// A transporter is always in a PerformState.
-// PerformIO is used initially and as long as any of the events
-// PerformConnect, ...
-enum PerformState {
- PerformNothing = 4, // Does nothing
- PerformIO = 0, // Is connected
- PerformConnect = 1, // Is trying to connect
- PerformDisconnect = 2, // Trying to disconnect
- RemoveTransporter = 3 // Will be removed
-};
-
// A transporter is always in an IOState.
// NoHalt is used initially and as long as it is no restrictions on
// sending or receiving.
@@ -60,18 +50,45 @@ enum TransporterType {
tt_OSE_TRANSPORTER = 4
};
+static const char *performStateString[] =
+ { "is connected",
+ "is trying to connect",
+ "does nothing",
+ "is trying to disconnect" };
+
class Transporter;
class TCP_Transporter;
class SCI_Transporter;
class SHM_Transporter;
class OSE_Transporter;
+class TransporterRegistry;
+class SocketAuthenticator;
+
+class TransporterService : public SocketServer::Service {
+ SocketAuthenticator * m_auth;
+ TransporterRegistry * m_transporter_registry;
+public:
+ TransporterService(SocketAuthenticator *auth= 0)
+ {
+ m_auth= auth;
+ m_transporter_registry= 0;
+ }
+ void setTransporterRegistry(TransporterRegistry *t)
+ {
+ m_transporter_registry= t;
+ }
+ SocketServer::Session * newSession(NDB_SOCKET_TYPE socket);
+};
+
/**
* @class TransporterRegistry
* @brief ...
*/
class TransporterRegistry {
friend class OSE_Receiver;
+ friend class Transporter;
+ friend class TransporterService;
public:
/**
* Constructor
@@ -98,6 +115,12 @@ public:
*/
~TransporterRegistry();
+ bool start_service(SocketServer& server);
+ bool start_clients();
+ bool stop_clients();
+ void start_clients_thread();
+ void update_connections();
+
/**
* Start/Stop receiving
*/
@@ -110,16 +133,26 @@ public:
void startSending();
void stopSending();
+ // A transporter is always in a PerformState.
+ // PerformIO is used initially and as long as any of the events
+ // PerformConnect, ...
+ enum PerformState {
+ CONNECTED = 0,
+ CONNECTING = 1,
+ DISCONNECTED = 2,
+ DISCONNECTING = 3
+ };
+ const char *getPerformStateString(NodeId nodeId) const
+ { return performStateString[(unsigned)performStates[nodeId]]; };
+
/**
* Get and set methods for PerformState
*/
- PerformState performState(NodeId nodeId);
- void setPerformState(NodeId nodeId, PerformState state);
-
- /**
- * Set perform state for all transporters
- */
- void setPerformState(PerformState state);
+ void do_connect(NodeId node_id);
+ void do_disconnect(NodeId node_id);
+ bool is_connected(NodeId node_id) { return performStates[node_id] == CONNECTED; };
+ void report_connect(NodeId node_id);
+ void report_disconnect(NodeId node_id, int errnum);
/**
* Get and set methods for IOState
@@ -174,8 +207,6 @@ public:
void performReceive();
void performSend();
- void checkConnections();
-
/**
* Force sending if more than or equal to sendLimit
* number have asked for send. Returns 0 if not sending
@@ -192,6 +223,12 @@ protected:
private:
void * callbackObj;
+ TransporterService *m_transporter_service;
+ unsigned short m_service_port;
+ char *m_interface_name;
+ struct NdbThread *m_start_clients_thread;
+ bool m_run_start_clients_thread;
+
int sendCounter;
NodeId localNodeId;
bool nodeIdSpecified;
@@ -202,11 +239,6 @@ private:
int nSHMTransporters;
int nOSETransporters;
- int m_ccCount;
- int m_ccIndex;
- int m_ccStep;
- int m_nTransportersPerformConnect;
- bool m_ccReady;
/**
* Arrays holding all transporters in the order they are created
*/
diff --git a/ndb/include/util/SocketAuthenticator.hpp b/ndb/include/util/SocketAuthenticator.hpp
new file mode 100644
index 00000000000..b42c7beb70f
--- /dev/null
+++ b/ndb/include/util/SocketAuthenticator.hpp
@@ -0,0 +1,39 @@
+/* Copyright (C) 2003 MySQL AB
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#ifndef SOCKET_AUTHENTICATOR_HPP
+#define SOCKET_AUTHENTICATOR_HPP
+
+class SocketAuthenticator
+{
+public:
+ virtual ~SocketAuthenticator() {};
+ virtual bool client_authenticate(int sockfd) = 0;
+ virtual bool server_authenticate(int sockfd) = 0;
+};
+
+class SocketAuthSimple : public SocketAuthenticator
+{
+ const char *m_passwd;
+ char *m_buf;
+public:
+ SocketAuthSimple(const char *passwd);
+ virtual ~SocketAuthSimple();
+ virtual bool client_authenticate(int sockfd);
+ virtual bool server_authenticate(int sockfd);
+};
+
+#endif // SOCKET_AUTHENTICATOR_HPP
diff --git a/ndb/include/util/SocketClient.hpp b/ndb/include/util/SocketClient.hpp
new file mode 100644
index 00000000000..de9a081464a
--- /dev/null
+++ b/ndb/include/util/SocketClient.hpp
@@ -0,0 +1,38 @@
+/* Copyright (C) 2003 MySQL AB
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#ifndef SOCKET_CLIENT_HPP
+#define SOCKET_CLIENT_HPP
+
+#include
+class SocketAuthenticator;
+
+class SocketClient
+{
+ NDB_SOCKET_TYPE m_sockfd;
+ struct sockaddr_in m_servaddr;
+ unsigned short m_port;
+ char *m_server_name;
+ SocketAuthenticator *m_auth;
+public:
+ SocketClient(const char *server_name, unsigned short port, SocketAuthenticator *sa = 0);
+ ~SocketClient();
+ bool init();
+ NDB_SOCKET_TYPE connect();
+ bool close();
+};
+
+#endif // SOCKET_ClIENT_HPP
diff --git a/ndb/src/common/mgmcommon/ConfigInfo.cpp b/ndb/src/common/mgmcommon/ConfigInfo.cpp
index c2b5fdabf01..a1bd5f39d82 100644
--- a/ndb/src/common/mgmcommon/ConfigInfo.cpp
+++ b/ndb/src/common/mgmcommon/ConfigInfo.cpp
@@ -146,13 +146,17 @@ const int ConfigInfo::m_NoOfRules = sizeof(m_SectionRules)/sizeof(SectionRule);
/****************************************************************************
* Config Rules declarations
****************************************************************************/
-bool addNodeConnections(Vector§ions,
- struct InitConfigFileParser::Context &ctx,
- const char * ruleData);
+bool add_node_connections(Vector§ions,
+ struct InitConfigFileParser::Context &ctx,
+ const char * rule_data);
+bool add_db_ports(Vector§ions,
+ struct InitConfigFileParser::Context &ctx,
+ const char * rule_data);
const ConfigInfo::ConfigRule
ConfigInfo::m_ConfigRules[] = {
- { addNodeConnections, 0 },
+ { add_node_connections, 0 },
+ { add_db_ports, 0 },
{ 0, 0 }
};
@@ -376,6 +380,18 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
1,
(MAX_NODES - 1) },
+ {
+ CFG_DB_SERVER_PORT,
+ "ServerPort",
+ "DB",
+ "Port used to setup transporter",
+ ConfigInfo::USED,
+ false,
+ ConfigInfo::INT,
+ 2202,
+ 0,
+ 0x7FFFFFFF },
+
{
CFG_DB_NO_REPLICAS,
"NoOfReplicas",
@@ -1231,7 +1247,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
ConfigInfo::USED,
false,
ConfigInfo::STRING,
- MANDATORY,
+ 0,
0,
0x7FFFFFFF },
@@ -1330,7 +1346,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
ConfigInfo::USED,
false,
ConfigInfo::STRING,
- MANDATORY,
+ 0,
0,
0x7FFFFFFF },
@@ -2510,10 +2526,14 @@ fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data){
const char * compId;
if(!ctx.m_currentSection->get("ExecuteOnComputer", &compId)){
+ require(ctx.m_currentSection->put("HostName", ""));
+ return true;
+#if 0
ctx.reportError("Parameter \"ExecuteOnComputer\" missing from section "
"[%s] starting at line: %d",
ctx.fname, ctx.m_sectionLineno);
return false;
+#endif
}
const Properties * computer;
@@ -3158,9 +3178,9 @@ saveInConfigValues(InitConfigFileParser::Context & ctx, const char * data){
}
bool
-addNodeConnections(Vector§ions,
+add_node_connections(Vector§ions,
struct InitConfigFileParser::Context &ctx,
- const char * ruleData)
+ const char * rule_data)
{
Properties * props= ctx.m_config;
Properties p_connections;
@@ -3241,3 +3261,10 @@ addNodeConnections(Vector§ions,
return true;
}
+bool add_db_ports(Vector§ions,
+ struct InitConfigFileParser::Context &ctx,
+ const char * rule_data)
+{
+ return true;
+}
+
diff --git a/ndb/src/common/mgmcommon/ConfigRetriever.cpp b/ndb/src/common/mgmcommon/ConfigRetriever.cpp
index d2c622593de..c34d9bb01f9 100644
--- a/ndb/src/common/mgmcommon/ConfigRetriever.cpp
+++ b/ndb/src/common/mgmcommon/ConfigRetriever.cpp
@@ -114,7 +114,8 @@ ConfigRetriever::getConfig(int verId, int nodeType) {
struct ndb_mgm_configuration * p = 0;
switch(m->type){
case MgmId_TCP:
- p = getConfig(m->data.tcp.remoteHost, m->data.tcp.port, verId);
+ p = getConfig(m->data.tcp.remoteHost, m->data.tcp.port,
+ verId, nodeType);
break;
case MgmId_File:
p = getConfig(m->data.file.filename, verId);
@@ -155,7 +156,8 @@ ConfigRetriever::getConfig(int verId, int nodeType) {
ndb_mgm_configuration *
ConfigRetriever::getConfig(const char * mgmhost,
short port,
- int versionId){
+ int versionId,
+ int nodetype){
NdbMgmHandle h;
h = ndb_mgm_create_handle();
@@ -175,6 +177,21 @@ ConfigRetriever::getConfig(const char * mgmhost,
ndb_mgm_configuration * conf = ndb_mgm_get_configuration(h, versionId);
if(conf == 0){
setError(CR_ERROR, ndb_mgm_get_latest_error_desc(h));
+ ndb_mgm_destroy_handle(&h);
+ return 0;
+ }
+
+ {
+ unsigned nodeid= getOwnNodeId();
+
+ int res= ndb_mgm_alloc_nodeid(h, versionId, &nodeid, nodetype);
+ if(res != 0) {
+ setError(CR_ERROR, ndb_mgm_get_latest_error_desc(h));
+ ndb_mgm_destroy_handle(&h);
+ return 0;
+ }
+
+ _ownNodeId= nodeid;
}
ndb_mgm_disconnect(h);
@@ -329,6 +346,9 @@ ConfigRetriever::verifyConfig(const struct ndb_mgm_configuration * conf,
}
do {
+ if(strlen(hostname) == 0)
+ break;
+
if(strcasecmp(hostname, localhost) == 0)
break;
diff --git a/ndb/src/common/mgmcommon/LocalConfig.cpp b/ndb/src/common/mgmcommon/LocalConfig.cpp
index 12e685ced34..67e92064e81 100644
--- a/ndb/src/common/mgmcommon/LocalConfig.cpp
+++ b/ndb/src/common/mgmcommon/LocalConfig.cpp
@@ -21,6 +21,7 @@
LocalConfig::LocalConfig(){
ids = 0; size = 0; items = 0;
error_line = 0; error_msg[0] = 0;
+ _ownNodeId= 0;
}
bool
@@ -95,6 +96,11 @@ LocalConfig::init(bool onlyNodeId,
return false;
}
+ //7. Check
+ if(readConnectString("host=localhost:2200", onlyNodeId)){
+ return true;
+ }
+
setError(0, "");
return false;
diff --git a/ndb/src/common/transporter/TCP_Transporter.cpp b/ndb/src/common/transporter/TCP_Transporter.cpp
index 99b6a137797..8833b51e236 100644
--- a/ndb/src/common/transporter/TCP_Transporter.cpp
+++ b/ndb/src/common/transporter/TCP_Transporter.cpp
@@ -63,27 +63,23 @@ ndbstrerror::~ndbstrerror(void)
#define ndbstrerror strerror
#endif
-TCP_Transporter::TCP_Transporter(int sendBufSize, int maxRecvSize,
- int portNo,
- const char *rHostName,
+TCP_Transporter::TCP_Transporter(TransporterRegistry &t_reg,
+ int sendBufSize, int maxRecvSize,
const char *lHostName,
- NodeId rNodeId, NodeId lNodeId,
+ const char *rHostName,
+ int r_port,
+ NodeId lNodeId,
+ NodeId rNodeId,
int byte_order,
bool compr, bool chksm, bool signalId,
Uint32 _reportFreq) :
- Transporter(lNodeId, rNodeId, byte_order, compr, chksm, signalId),
- m_sendBuffer(sendBufSize),
- isServer(lNodeId < rNodeId),
- port(portNo)
+ Transporter(t_reg, lHostName, rHostName, r_port, lNodeId, rNodeId,
+ byte_order, compr, chksm, signalId),
+ m_sendBuffer(sendBufSize)
{
maxReceiveSize = maxRecvSize;
- strncpy(remoteHostName, rHostName, sizeof(remoteHostName));
-
// Initialize member variables
- Ndb_getInAddr(&remoteHostAddress, rHostName);
-
- Ndb_getInAddr(&localHostAddress, lHostName);
theSocket = NDB_INVALID_SOCKET;
sendCount = receiveCount = 0;
@@ -108,6 +104,24 @@ TCP_Transporter::~TCP_Transporter() {
receiveBuffer.destroy();
}
+bool TCP_Transporter::connect_server_impl(NDB_SOCKET_TYPE sockfd)
+{
+ return connect_common(sockfd);
+}
+
+bool TCP_Transporter::connect_client_impl(NDB_SOCKET_TYPE sockfd)
+{
+ return connect_common(sockfd);
+}
+
+bool TCP_Transporter::connect_common(NDB_SOCKET_TYPE sockfd)
+{
+ theSocket = sockfd;
+ setSocketOptions();
+ setSocketNonBlocking(theSocket);
+ return true;
+}
+
bool
TCP_Transporter::initTransporter() {
@@ -316,7 +330,7 @@ TCP_Transporter::doSend() {
sendCount ++;
sendSize += nBytesSent;
if(sendCount == reportFreq){
- reportSendLen(callbackObj,remoteNodeId, sendCount, sendSize);
+ reportSendLen(get_callback_obj(), remoteNodeId, sendCount, sendSize);
sendCount = 0;
sendSize = 0;
}
@@ -331,7 +345,7 @@ TCP_Transporter::doSend() {
#endif
if(DISCONNECT_ERRNO(InetErrno, nBytesSent)){
doDisconnect();
- reportDisconnect(callbackObj, remoteNodeId, InetErrno);
+ report_disconnect(InetErrno);
}
return false;
@@ -361,14 +375,15 @@ TCP_Transporter::doReceive() {
#endif
ndbout_c("receiveBuffer.sizeOfData(%d) > receiveBuffer.sizeOfBuffer(%d)",
receiveBuffer.sizeOfData, receiveBuffer.sizeOfBuffer);
- reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH);
+ report_error(TE_INVALID_MESSAGE_LENGTH);
return 0;
}
receiveCount ++;
receiveSize += nBytesRead;
+
if(receiveCount == reportFreq){
- reportReceiveLen(callbackObj, remoteNodeId, receiveCount, receiveSize);
+ reportReceiveLen(get_callback_obj(), remoteNodeId, receiveCount, receiveSize);
receiveCount = 0;
receiveSize = 0;
}
@@ -384,60 +399,17 @@ TCP_Transporter::doReceive() {
if(DISCONNECT_ERRNO(InetErrno, nBytesRead)){
// The remote node has closed down
doDisconnect();
- reportDisconnect(callbackObj, remoteNodeId,InetErrno);
+ report_disconnect(InetErrno);
}
}
return nBytesRead;
}
-bool
-TCP_Transporter::connectImpl(Uint32 timeOutMillis){
- struct timeval timeout = {0, 0};
- timeout.tv_sec = timeOutMillis / 1000;
- timeout.tv_usec = (timeOutMillis % 1000)*1000;
-
- bool retVal = false;
-
- if(isServer){
- if(theSocket == NDB_INVALID_SOCKET){
- startTCPServer();
- }
- if(theSocket == NDB_INVALID_SOCKET)
- {
- NdbSleep_MilliSleep(timeOutMillis);
- return false;
- }
- retVal = acceptClient(&timeout);
- } else {
- // Is client
- retVal = connectClient(&timeout);
- }
-
- if(!retVal) {
- NdbSleep_MilliSleep(timeOutMillis);
- return false;
- }
-
-#if defined NDB_OSE || defined NDB_SOFTOSE
- if(setsockopt(theSocket, SOL_SOCKET, SO_OSEOWNER,
- &theReceiverPid, sizeof(PROCESS)) != 0){
-
- ndbout << "Failed to transfer ownership of socket" << endl;
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = -1;
- return false;
- }
-#endif
-
- return true;
-}
-
-
void
-TCP_Transporter::disconnectImpl() {
+TCP_Transporter::disconnectImpl() {
if(theSocket != NDB_INVALID_SOCKET){
if(NDB_CLOSE_SOCKET(theSocket) < 0){
- reportError(callbackObj, remoteNodeId, TE_ERROR_CLOSING_SOCKET);
+ report_error(TE_ERROR_CLOSING_SOCKET);
}
}
@@ -447,155 +419,3 @@ TCP_Transporter::disconnectImpl() {
theSocket = NDB_INVALID_SOCKET;
}
-
-bool
-TCP_Transporter::startTCPServer() {
-
- int bindResult, listenResult;
-
- // The server variable is the remote server when we are a client
- // htonl and htons returns the parameter in network byte order
- // INADDR_ANY tells the OS kernel to choose the IP address
- struct sockaddr_in server;
- memset((void*)&server, 0, sizeof(server));
- server.sin_family = AF_INET;
- server.sin_addr.s_addr = localHostAddress.s_addr;
- server.sin_port = htons(port);
-
- if (theSocket != NDB_INVALID_SOCKET) {
- return true; // Server socket is already initialized
- }
-
- // Create the socket
- theSocket = socket(AF_INET, SOCK_STREAM, 0);
- if (theSocket == NDB_INVALID_SOCKET) {
- reportThreadError(remoteNodeId, TE_COULD_NOT_CREATE_SOCKET);
- return false;
- }
-
- // Set the socket reuse addr to true, so we are sure we can bind the
- // socket
- int reuseAddr = 1;
- setsockopt(theSocket, SOL_SOCKET, SO_REUSEADDR,
- (char*)&reuseAddr, sizeof(reuseAddr));
-
- // Set the TCP_NODELAY option so also small packets are sent
- // as soon as possible
- int nodelay = 1;
- setsockopt(theSocket, IPPROTO_TCP, TCP_NODELAY,
- (char*)&nodelay, sizeof(nodelay));
-
- // Bind the socket
- bindResult = bind(theSocket, (struct sockaddr *) &server,
- sizeof(server));
- if (bindResult < 0) {
- reportThreadError(remoteNodeId, TE_COULD_NOT_BIND_SOCKET);
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = NDB_INVALID_SOCKET;
- return false;
- }
-
- // Perform listen.
- listenResult = listen(theSocket, 1);
- if (listenResult == 1) {
- reportThreadError(remoteNodeId, TE_LISTEN_FAILED);
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = NDB_INVALID_SOCKET;
- return false;
- }
-
- return true;
-}
-
-
-bool
-TCP_Transporter::acceptClient (struct timeval * timeout){
-
- struct sockaddr_in clientAddress;
-
- fd_set readset;
- FD_ZERO(&readset);
- FD_SET(theSocket, &readset);
- const int res = select(theSocket + 1, &readset, 0, 0, timeout);
- if(res == 0)
- return false;
-
- if(res < 0){
- reportThreadError(remoteNodeId, TE_ERROR_IN_SELECT_BEFORE_ACCEPT);
- return false;
- }
-
- NDB_SOCKLEN_T clientAddressLen = sizeof(clientAddress);
- const NDB_SOCKET_TYPE clientSocket = accept(theSocket,
- (struct sockaddr*)&clientAddress,
- &clientAddressLen);
- if (clientSocket == NDB_INVALID_SOCKET) {
- reportThreadError(remoteNodeId, TE_ACCEPT_RETURN_ERROR);
- return false;
- }
-
- if (clientAddress.sin_addr.s_addr != remoteHostAddress.s_addr) {
- ndbout_c("Wrong client connecting!");
- ndbout_c("connecting address: %s", inet_ntoa(clientAddress.sin_addr));
- ndbout_c("expecting address: %s", inet_ntoa(remoteHostAddress));
- // The newly connected host is not the remote host
- // we wanted to connect to. Disconnect it.
- // XXX This is not valid. We cannot disconnect it.
- NDB_CLOSE_SOCKET(clientSocket);
- return false;
- } else {
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = clientSocket;
- setSocketOptions();
- setSocketNonBlocking(theSocket);
- return true;
- }
-}
-
-bool
-TCP_Transporter::connectClient (struct timeval * timeout){
-
- // Create the socket
- theSocket = socket(AF_INET, SOCK_STREAM, 0);
- if (theSocket == NDB_INVALID_SOCKET) {
- reportThreadError(remoteNodeId, TE_COULD_NOT_CREATE_SOCKET);
- return false;
- }
-
- struct sockaddr_in server;
- memset((void*)&server, 0, sizeof(server));
- server.sin_family = AF_INET;
- server.sin_addr = remoteHostAddress;
- server.sin_port = htons(port);
-
- struct sockaddr_in client;
- memset((void*)&client, 0, sizeof(client));
- client.sin_family = AF_INET;
- client.sin_addr = localHostAddress;
- client.sin_port = 0; // Any port
-
- // Bind the socket
- const int bindResult = bind(theSocket, (struct sockaddr *) &client,
- sizeof(client));
- if (bindResult < 0) {
- reportThreadError(remoteNodeId, TE_COULD_NOT_BIND_SOCKET);
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = NDB_INVALID_SOCKET;
- return false;
- }
-
- const int connectRes = ::connect(theSocket, (struct sockaddr *) &server,
- sizeof(server));
- if(connectRes == 0){
- setSocketOptions();
- setSocketNonBlocking(theSocket);
- return true;
- }
-
- NDB_CLOSE_SOCKET(theSocket);
- theSocket = NDB_INVALID_SOCKET;
- return false;
-}
-
-
-
diff --git a/ndb/src/common/transporter/TCP_Transporter.hpp b/ndb/src/common/transporter/TCP_Transporter.hpp
index 30b730a5b1c..958cfde03a1 100644
--- a/ndb/src/common/transporter/TCP_Transporter.hpp
+++ b/ndb/src/common/transporter/TCP_Transporter.hpp
@@ -14,24 +14,8 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
-//****************************************************************************
-//
-// AUTHOR
-// Åsa Fransson
-//
-// NAME
-// TCP_Transporter
-//
-// DESCRIPTION
-// A TCP_Transporter instance is created when TCP/IP-communication
-// shall be used (user specified). It handles connect, disconnect,
-// send and receive.
-//
-//
-//
-//***************************************************************************/
-#ifndef TCP_Transporter_H
-#define TCP_Transporter_H
+#ifndef TCP_TRANSPORTER_HPP
+#define TCP_TRANSPORTER_HPP
#include "Transporter.hpp"
#include "SendBuffer.hpp"
@@ -61,11 +45,13 @@ class TCP_Transporter : public Transporter {
friend class TransporterRegistry;
private:
// Initialize member variables
- TCP_Transporter(int sendBufferSize, int maxReceiveSize,
- int port,
- const char *rHostName,
+ TCP_Transporter(TransporterRegistry&,
+ int sendBufferSize, int maxReceiveSize,
const char *lHostName,
- NodeId rHostId, NodeId lHostId,
+ const char *rHostName,
+ int r_port,
+ NodeId lHostId,
+ NodeId rHostId,
int byteorder,
bool compression, bool checksum, bool signalId,
Uint32 reportFreq = 4096);
@@ -121,12 +107,14 @@ protected:
* A client connects to the remote server
* A server accepts any new connections
*/
- bool connectImpl(Uint32 timeOutMillis);
+ virtual bool connect_server_impl(NDB_SOCKET_TYPE sockfd);
+ virtual bool connect_client_impl(NDB_SOCKET_TYPE sockfd);
+ bool connect_common(NDB_SOCKET_TYPE sockfd);
/**
* Disconnects a TCP/IP node. Empty send and receivebuffer.
*/
- void disconnectImpl();
+ virtual void disconnectImpl();
private:
/**
@@ -134,21 +122,11 @@ private:
*/
SendBuffer m_sendBuffer;
- const bool isServer;
- const unsigned int port;
-
// Sending/Receiving socket used by both client and server
NDB_SOCKET_TYPE theSocket;
Uint32 maxReceiveSize;
- /**
- * Remote host name/and address
- */
- char remoteHostName[256];
- struct in_addr remoteHostAddress;
- struct in_addr localHostAddress;
-
/**
* Socket options
*/
@@ -163,43 +141,6 @@ private:
bool sendIsPossible(struct timeval * timeout);
- /**
- * startTCPServer - None blocking
- *
- * create a server socket
- * bind
- * listen
- *
- * Note: Does not call accept
- */
- bool startTCPServer();
-
- /**
- * acceptClient - Blocking
- *
- * Accept a connection
- * checks if "right" client has connected
- * if so
- * close server socket
- * else
- * close newly created socket and goto begin
- */
- bool acceptClient(struct timeval * timeout);
-
- /**
- * Creates a client socket
- *
- * Note does not call connect
- */
- bool createClientSocket();
-
- /**
- * connectClient - Blocking
- *
- * connects to remote host
- */
- bool connectClient(struct timeval * timeout);
-
/**
* Statistics
*/
diff --git a/ndb/src/common/transporter/Transporter.cpp b/ndb/src/common/transporter/Transporter.cpp
index 5ca523d5185..c6f93d2cbea 100644
--- a/ndb/src/common/transporter/Transporter.cpp
+++ b/ndb/src/common/transporter/Transporter.cpp
@@ -15,132 +15,125 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#include
+#include
#include "Transporter.hpp"
#include "TransporterInternalDefinitions.hpp"
#include
+#include
+#include
+#include
-Transporter::Transporter(NodeId lNodeId, NodeId rNodeId,
+Transporter::Transporter(TransporterRegistry &t_reg,
+ const char *lHostName,
+ const char *rHostName,
+ int r_port,
+ NodeId lNodeId,
+ NodeId rNodeId,
int _byteorder,
bool _compression, bool _checksum, bool _signalId)
- : localNodeId(lNodeId), remoteNodeId(rNodeId),
- m_packer(_signalId, _checksum)
+ : m_r_port(r_port), localNodeId(lNodeId), remoteNodeId(rNodeId),
+ isServer(lNodeId < rNodeId),
+ m_packer(_signalId, _checksum),
+ m_transporter_registry(t_reg)
{
+ if (rHostName && strlen(rHostName) > 0){
+ strncpy(remoteHostName, rHostName, sizeof(remoteHostName));
+ Ndb_getInAddr(&remoteHostAddress, rHostName);
+ }
+ else
+ {
+ if (!isServer) {
+ ndbout << "Unable to setup transporter. Node " << rNodeId
+ << " must have hostname. Update configuration." << endl;
+ exit(-1);
+ }
+ remoteHostName[0]= 0;
+ }
+ strncpy(localHostName, lHostName, sizeof(localHostName));
+
+ if (strlen(lHostName) > 0)
+ Ndb_getInAddr(&localHostAddress, lHostName);
+
byteOrder = _byteorder;
compressionUsed = _compression;
checksumUsed = _checksum;
signalIdUsed = _signalId;
- _threadError = TE_NO_ERROR;
+ m_connected = false;
+ m_timeOutMillis = 1000;
- _connecting = false;
- _disconnecting = false;
- _connected = false;
- _timeOutMillis = 1000;
- theThreadPtr = NULL;
- theMutexPtr = NdbMutex_Create();
+ if (isServer)
+ m_socket_client= 0;
+ else
+ {
+ unsigned short tmp_port= 3307+rNodeId;
+ m_socket_client= new SocketClient(remoteHostName, tmp_port,
+ new SocketAuthSimple("ndbd passwd"));
+ }
}
Transporter::~Transporter(){
- NdbMutex_Destroy(theMutexPtr);
-
- if(theThreadPtr != 0){
- void * retVal;
- NdbThread_WaitFor(theThreadPtr, &retVal);
- NdbThread_Destroy(&theThreadPtr);
- }
+ if (m_socket_client)
+ delete m_socket_client;
}
-extern "C"
-void *
-runConnect_C(void * me)
-{
- runConnect(me);
- NdbThread_Exit(0);
- return NULL;
+bool
+Transporter::connect_server(NDB_SOCKET_TYPE sockfd) {
+ if(m_connected)
+ return true; // TODO assert(0);
+
+ bool res = connect_server_impl(sockfd);
+ if(res){
+ m_connected = true;
+ m_errorCount = 0;
+ }
+
+ return res;
}
-void *
-runConnect(void * me){
- Transporter * t = (Transporter *) me;
+bool
+Transporter::connect_client() {
+ if(m_connected)
+ return true;
+
+ NDB_SOCKET_TYPE sockfd = m_socket_client->connect();
+
+ if (sockfd < 0)
+ return false;
- DEBUG("Connect thread to " << t->remoteNodeId << " started");
+ // send info about own id
+ SocketOutputStream s_output(sockfd);
+ s_output.println("%d", localNodeId);
- while(true){
- NdbMutex_Lock(t->theMutexPtr);
- if(t->_disconnecting){
- t->_connecting = false;
- NdbMutex_Unlock(t->theMutexPtr);
- DEBUG("Connect Thread " << t->remoteNodeId << " stop due to disconnect");
- return 0;
- }
- NdbMutex_Unlock(t->theMutexPtr);
-
- bool res = t->connectImpl(t->_timeOutMillis); // 1000 ms
- DEBUG("Waiting for " << t->remoteNodeId << "...");
- if(res){
- t->_connected = true;
- t->_connecting = false;
- t->_errorCount = 0;
- t->_threadError = TE_NO_ERROR;
- DEBUG("Connect Thread " << t->remoteNodeId << " stop due to connect");
- return 0;
- }
+ // get remote id
+ int nodeId;
+ SocketInputStream s_input(sockfd);
+ char buf[256];
+ if (s_input.gets(buf, 256) == 0) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return false;
}
+ if (sscanf(buf, "%d", &nodeId) != 1) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return false;
+ }
+
+ bool res = connect_client_impl(sockfd);
+ if(res){
+ m_connected = true;
+ m_errorCount = 0;
+ }
+ return res;
}
void
-Transporter::doConnect() {
-
- NdbMutex_Lock(theMutexPtr);
- if(_connecting || _disconnecting || _connected){
- NdbMutex_Unlock(theMutexPtr);
- return;
- }
-
- _connecting = true;
+Transporter::doDisconnect() {
- _threadError = TE_NO_ERROR;
+ if(!m_connected)
+ return; //assert(0); TODO will fail
- // Start thread
-
- char buf[16];
- snprintf(buf, sizeof(buf), "ndb_con_%d", remoteNodeId);
-
- if(theThreadPtr != 0){
- void * retVal;
- NdbThread_WaitFor(theThreadPtr, &retVal);
- NdbThread_Destroy(&theThreadPtr);
- }
-
- theThreadPtr = NdbThread_Create(runConnect_C,
- (void**)this,
- 32768,
- buf,
- NDB_THREAD_PRIO_LOW);
-
- NdbSleep_MilliSleep(100); // Let thread start
-
- NdbMutex_Unlock(theMutexPtr);
-}
-
-void
-Transporter::doDisconnect() {
-
- NdbMutex_Lock(theMutexPtr);
- _disconnecting = true;
- while(_connecting){
- DEBUG("Waiting for connect to finish...");
-
- NdbMutex_Unlock(theMutexPtr);
- NdbSleep_MilliSleep(500);
- NdbMutex_Lock(theMutexPtr);
- }
-
- _connected = false;
-
disconnectImpl();
- _threadError = TE_NO_ERROR;
- _disconnecting = false;
-
- NdbMutex_Unlock(theMutexPtr);
+
+ m_connected= false;
}
diff --git a/ndb/src/common/transporter/Transporter.hpp b/ndb/src/common/transporter/Transporter.hpp
index 43b26d45899..9a39f8788bc 100644
--- a/ndb/src/common/transporter/Transporter.hpp
+++ b/ndb/src/common/transporter/Transporter.hpp
@@ -19,6 +19,9 @@
#include
+#include
+
+#include
#include
#include "TransporterDefinitions.hpp"
#include "Packer.hpp"
@@ -40,8 +43,9 @@ public:
* None blocking
* Use isConnected() to check status
*/
- virtual void doConnect();
-
+ bool connect_client();
+ bool connect_server(NDB_SOCKET_TYPE socket);
+
/**
* Blocking
*/
@@ -60,14 +64,17 @@ public:
*/
NodeId getRemoteNodeId() const;
-
/**
- * Set callback object
+ * Local (own) Node Id
*/
- void setCallbackObject(void * callback);
+ NodeId getLocalNodeId() const;
protected:
- Transporter(NodeId lNodeId,
+ Transporter(TransporterRegistry &,
+ const char *lHostName,
+ const char *rHostName,
+ int r_port,
+ NodeId lNodeId,
NodeId rNodeId,
int byteorder,
bool compression,
@@ -78,58 +85,59 @@ protected:
* Blocking, for max timeOut milli seconds
* Returns true if connect succeded
*/
- virtual bool connectImpl(Uint32 timeOut) = 0;
+ virtual bool connect_server_impl(NDB_SOCKET_TYPE sockfd) = 0;
+ virtual bool connect_client_impl(NDB_SOCKET_TYPE sockfd) = 0;
/**
* Blocking
*/
virtual void disconnectImpl() = 0;
- const NodeId localNodeId;
+ /**
+ * Remote host name/and address
+ */
+ char remoteHostName[256];
+ char localHostName[256];
+ struct in_addr remoteHostAddress;
+ struct in_addr localHostAddress;
+
+ const unsigned int m_r_port;
+
const NodeId remoteNodeId;
+ const NodeId localNodeId;
+ const bool isServer;
+
unsigned createIndex;
int byteOrder;
bool compressionUsed;
bool checksumUsed;
bool signalIdUsed;
- Packer m_packer;
-
+ Packer m_packer;
private:
- /**
- * Thread and mutex for connect
- */
- NdbThread* theThreadPtr;
- friend void* runConnect(void * me);
+
+ SocketClient *m_socket_client;
protected:
- /**
- * Error reporting from connect thread(s)
- */
- void reportThreadError(NodeId nodeId,
- TransporterError errorCode);
Uint32 getErrorCount();
- TransporterError getThreadError();
- void resetThreadError();
- TransporterError _threadError;
- Uint32 _timeOutMillis;
- Uint32 _errorCount;
+ Uint32 m_errorCount;
+ Uint32 m_timeOutMillis;
-protected:
- NdbMutex* theMutexPtr;
- bool _connected; // Are we connected
- bool _connecting; // Connect thread is running
- bool _disconnecting; // We are disconnecting
+protected:
+ bool m_connected; // Are we connected
- void * callbackObj;
+ TransporterRegistry &m_transporter_registry;
+ void *get_callback_obj() { return m_transporter_registry.callbackObj; };
+ void report_disconnect(int err){m_transporter_registry.report_disconnect(remoteNodeId,err);};
+ void report_error(enum TransporterError err){reportError(get_callback_obj(),remoteNodeId,err);};
};
inline
bool
Transporter::isConnected() const {
- return _connected;
+ return m_connected;
}
inline
@@ -138,42 +146,17 @@ Transporter::getRemoteNodeId() const {
return remoteNodeId;
}
-inline
-void
-Transporter::reportThreadError(NodeId nodeId, TransporterError errorCode)
-{
-#if 0
- ndbout_c("Transporter::reportThreadError (NodeId: %d, Error code: %d)",
- nodeId, errorCode);
-#endif
- _threadError = errorCode;
- _errorCount++;
-}
-
inline
-TransporterError
-Transporter::getThreadError(){
- return _threadError;
+NodeId
+Transporter::getLocalNodeId() const {
+ return remoteNodeId;
}
inline
Uint32
Transporter::getErrorCount()
{
- return _errorCount;
-}
-
-inline
-void
-Transporter::resetThreadError()
-{
- _threadError = TE_NO_ERROR;
-}
-
-inline
-void
-Transporter::setCallbackObject(void * callback) {
- callbackObj = callback;
+ return m_errorCount;
}
#endif // Define of Transporter_H
diff --git a/ndb/src/common/transporter/TransporterRegistry.cpp b/ndb/src/common/transporter/TransporterRegistry.cpp
index 3f98eeed89e..bad3b44706f 100644
--- a/ndb/src/common/transporter/TransporterRegistry.cpp
+++ b/ndb/src/common/transporter/TransporterRegistry.cpp
@@ -16,10 +16,11 @@
#include
-#include "TransporterRegistry.hpp"
+#include
#include "TransporterInternalDefinitions.hpp"
#include "Transporter.hpp"
+#include
#ifdef NDB_TCP_TRANSPORTER
#include "TCP_Transporter.hpp"
@@ -42,20 +43,67 @@
#include "NdbOut.hpp"
#include
#include
-#define STEPPING 1
+#include
+#include
+
+SocketServer::Session * TransporterService::newSession(NDB_SOCKET_TYPE sockfd)
+{
+ if (m_auth && !m_auth->server_authenticate(sockfd)){
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+
+ {
+ // read node id from client
+ int nodeId;
+ SocketInputStream s_input(sockfd);
+ char buf[256];
+ if (s_input.gets(buf, 256) == 0) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+ if (sscanf(buf, "%d", &nodeId) != 1) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+
+ //check that nodeid is valid and that there is an allocated transporter
+ if ( nodeId < 0 || nodeId >= m_transporter_registry->maxTransporters) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+ if (m_transporter_registry->theTransporters[nodeId] == 0) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+
+ //check that the transporter should be connected
+ if (m_transporter_registry->performStates[nodeId] != TransporterRegistry::CONNECTING) {
+ NDB_CLOSE_SOCKET(sockfd);
+ return 0;
+ }
+
+ Transporter *t= m_transporter_registry->theTransporters[nodeId];
+
+ // send info about own id (just as response to acnowledge connection)
+ SocketOutputStream s_output(sockfd);
+ s_output.println("%d", t->getLocalNodeId());
+
+ // setup transporter (transporter responsable for closing sockfd)
+ t->connect_server(sockfd);
+ }
+
+ return 0;
+}
TransporterRegistry::TransporterRegistry(void * callback,
unsigned _maxTransporters,
unsigned sizeOfLongSignalMemory) {
+ m_transporter_service= 0;
nodeIdSpecified = false;
maxTransporters = _maxTransporters;
sendCounter = 1;
- m_ccCount = 0;
- m_ccIndex = 0;
- m_ccStep = STEPPING;
- m_ccReady = false;
- m_nTransportersPerformConnect=0;
callbackObj=callback;
@@ -82,7 +130,7 @@ TransporterRegistry::TransporterRegistry(void * callback,
theSHMTransporters[i] = NULL;
theOSETransporters[i] = NULL;
theTransporters[i] = NULL;
- performStates[i] = PerformNothing;
+ performStates[i] = DISCONNECTED;
ioStates[i] = NoHalt;
}
theOSEReceiver = 0;
@@ -154,13 +202,14 @@ TransporterRegistry::createTransporter(TCP_TransporterConfiguration *config) {
return false;
- TCP_Transporter * t = new TCP_Transporter(config->sendBufferSize,
- config->maxReceiveSize,
- config->port,
- config->remoteHostName,
+ TCP_Transporter * t = new TCP_Transporter(*this,
+ config->sendBufferSize,
+ config->maxReceiveSize,
config->localHostName,
- config->remoteNodeId,
+ config->remoteHostName,
+ config->port,
localNodeId,
+ config->remoteNodeId,
config->byteOrder,
config->compression,
config->checksum,
@@ -172,13 +221,11 @@ TransporterRegistry::createTransporter(TCP_TransporterConfiguration *config) {
return false;
}
- t->setCallbackObject(callbackObj);
-
// Put the transporter in the transporter arrays
theTCPTransporters[nTCPTransporters] = t;
theTransporters[t->getRemoteNodeId()] = t;
theTransporterTypes[t->getRemoteNodeId()] = tt_TCP_TRANSPORTER;
- performStates[t->getRemoteNodeId()] = PerformNothing;
+ performStates[t->getRemoteNodeId()] = DISCONNECTED;
nTransporters++;
nTCPTransporters++;
@@ -228,12 +275,11 @@ TransporterRegistry::createTransporter(OSE_TransporterConfiguration *conf) {
delete t;
return false;
}
- t->setCallbackObject(callbackObj);
// Put the transporter in the transporter arrays
theOSETransporters[nOSETransporters] = t;
theTransporters[t->getRemoteNodeId()] = t;
theTransporterTypes[t->getRemoteNodeId()] = tt_OSE_TRANSPORTER;
- performStates[t->getRemoteNodeId()] = PerformNothing;
+ performStates[t->getRemoteNodeId()] = DISCONNECTED;
nTransporters++;
nOSETransporters++;
@@ -279,12 +325,11 @@ TransporterRegistry::createTransporter(SCI_TransporterConfiguration *config) {
delete t;
return false;
}
- t->setCallbackObject(callbackObj);
// Put the transporter in the transporter arrays
theSCITransporters[nSCITransporters] = t;
theTransporters[t->getRemoteNodeId()] = t;
theTransporterTypes[t->getRemoteNodeId()] = tt_SCI_TRANSPORTER;
- performStates[t->getRemoteNodeId()] = PerformNothing;
+ performStates[t->getRemoteNodeId()] = DISCONNECTED;
nTransporters++;
nSCITransporters++;
@@ -321,12 +366,11 @@ TransporterRegistry::createTransporter(SHM_TransporterConfiguration *config) {
delete t;
return false;
}
- t->setCallbackObject(callbackObj);
// Put the transporter in the transporter arrays
theSHMTransporters[nSHMTransporters] = t;
theTransporters[t->getRemoteNodeId()] = t;
theTransporterTypes[t->getRemoteNodeId()] = tt_SHM_TRANSPORTER;
- performStates[t->getRemoteNodeId()] = PerformNothing;
+ performStates[t->getRemoteNodeId()] = DISCONNECTED;
nTransporters++;
nSHMTransporters++;
@@ -781,7 +825,7 @@ TransporterRegistry::performReceive(){
TCP_Transporter *t = theTCPTransporters[i];
const NodeId nodeId = t->getRemoteNodeId();
const NDB_SOCKET_TYPE socket = t->getSocket();
- if(performStates[nodeId] == PerformIO){
+ if(is_connected(nodeId)){
if(t->isConnected() && FD_ISSET(socket, &tcpReadset)) {
const int receiveSize = t->doReceive();
if(receiveSize > 0){
@@ -804,7 +848,7 @@ TransporterRegistry::performReceive(){
checkJobBuffer();
SCI_Transporter *t = theSCITransporters[i];
const NodeId nodeId = t->getRemoteNodeId();
- if(performStates[nodeId] == PerformIO){
+ if(is_connected(nodeId)){
if(t->isConnected() && t->checkConnected()){
Uint32 * readPtr, * eodPtr;
t->getReceivePtr(&readPtr, &eodPtr);
@@ -819,7 +863,7 @@ TransporterRegistry::performReceive(){
checkJobBuffer();
SHM_Transporter *t = theSHMTransporters[i];
const NodeId nodeId = t->getRemoteNodeId();
- if(performStates[nodeId] == PerformIO){
+ if(is_connected(nodeId)){
if(t->isConnected() && t->checkConnected()){
Uint32 * readPtr, * eodPtr;
t->getReceivePtr(&readPtr, &eodPtr);
@@ -840,7 +884,7 @@ TransporterRegistry::performSend(){
#ifdef NDB_OSE_TRANSPORTER
for (int i = 0; i < nOSETransporters; i++){
OSE_Transporter *t = theOSETransporters[i];
- if((performStates[t->getRemoteNodeId()] == PerformIO) &&
+ if((is_connected(t->getRemoteNodeId()) &&
(t->isConnected())) {
t->doSend();
}//if
@@ -887,7 +931,7 @@ TransporterRegistry::performSend(){
TCP_Transporter *t = theTCPTransporters[i];
const NodeId nodeId = t->getRemoteNodeId();
const int socket = t->getSocket();
- if(performStates[nodeId] == PerformIO){
+ if(is_connected(nodeId)){
if(t->isConnected() && FD_ISSET(socket, &writeset)) {
t->doSend();
}//if
@@ -901,7 +945,7 @@ TransporterRegistry::performSend(){
if (t &&
(t->hasDataToSend()) &&
(t->isConnected()) &&
- (performStates[t->getRemoteNodeId()] == PerformIO)) {
+ (is_connected(t->getRemoteNodeId()))) {
t->doSend();
}//if
}//for
@@ -910,7 +954,7 @@ TransporterRegistry::performSend(){
if (t &&
(t->hasDataToSend()) &&
(t->isConnected()) &&
- (performStates[t->getRemoteNodeId()] == PerformIO)) {
+ (is_connected(t->getRemoteNodeId()))) {
t->doSend();
}//if
}//for
@@ -925,7 +969,7 @@ TransporterRegistry::performSend(){
SCI_Transporter *t = theSCITransporters[i];
const NodeId nodeId = t->getRemoteNodeId();
- if(performStates[nodeId] == PerformIO){
+ if(is_connected(nodeId)){
if(t->isConnected() && t->hasDataToSend()) {
t->doSend();
} //if
@@ -961,56 +1005,6 @@ TransporterRegistry::printState(){
}
#endif
-PerformState
-TransporterRegistry::performState(NodeId nodeId) {
- return performStates[nodeId];
-}
-
-#ifdef DEBUG_TRANSPORTER
-const char *
-performStateString(PerformState state){
- switch(state){
- case PerformNothing:
- return "PerformNothing";
- break;
- case PerformIO:
- return "PerformIO";
- break;
- case PerformConnect:
- return "PerformConnect";
- break;
- case PerformDisconnect:
- return "PerformDisconnect";
- break;
- case RemoveTransporter:
- return "RemoveTransporter";
- break;
- }
- return "Unknown";
-}
-#endif
-
-void
-TransporterRegistry::setPerformState(NodeId nodeId, PerformState state) {
- DEBUG("TransporterRegistry::setPerformState("
- << nodeId << ", " << performStateString(state) << ")");
-
- performStates[nodeId] = state;
-}
-
-void
-TransporterRegistry::setPerformState(PerformState state) {
- int count = 0;
- int index = 0;
- while(count < nTransporters){
- if(theTransporters[index] != 0){
- setPerformState(theTransporters[index]->getRemoteNodeId(), state);
- count ++;
- }
- index ++;
- }
-}
-
IOState
TransporterRegistry::ioState(NodeId nodeId) {
return ioStates[nodeId];
@@ -1023,8 +1017,198 @@ TransporterRegistry::setIOState(NodeId nodeId, IOState state) {
ioStates[nodeId] = state;
}
+static void *
+run_start_clients_C(void * me)
+{
+ ((TransporterRegistry*) me)->start_clients_thread();
+ NdbThread_Exit(0);
+ return me;
+}
+
+// Run by kernel thread
void
-TransporterRegistry::startReceiving(){
+TransporterRegistry::do_connect(NodeId node_id)
+{
+ PerformState &curr_state = performStates[node_id];
+ switch(curr_state){
+ case DISCONNECTED:
+ break;
+ case CONNECTED:
+ return;
+ case CONNECTING:
+ return;
+ case DISCONNECTING:
+ break;
+ }
+ curr_state= CONNECTING;
+}
+void
+TransporterRegistry::do_disconnect(NodeId node_id)
+{
+ PerformState &curr_state = performStates[node_id];
+ switch(curr_state){
+ case DISCONNECTED:
+ return;
+ case CONNECTED:
+ break;
+ case CONNECTING:
+ break;
+ case DISCONNECTING:
+ return;
+ }
+ curr_state= DISCONNECTING;
+}
+
+void
+TransporterRegistry::report_connect(NodeId node_id)
+{
+ performStates[node_id] = CONNECTED;
+ reportConnect(callbackObj, node_id);
+}
+
+void
+TransporterRegistry::report_disconnect(NodeId node_id, int errnum)
+{
+ performStates[node_id] = DISCONNECTED;
+ reportDisconnect(callbackObj, node_id, errnum);
+}
+
+void
+TransporterRegistry::update_connections()
+{
+ for (int i= 0, n= 0; n < nTransporters; i++){
+ Transporter * t = theTransporters[i];
+ if (!t)
+ continue;
+ n++;
+
+ const NodeId nodeId = t->getRemoteNodeId();
+ switch(performStates[nodeId]){
+ case CONNECTED:
+ case DISCONNECTED:
+ break;
+ case CONNECTING:
+ if(t->isConnected())
+ report_connect(nodeId);
+ break;
+ case DISCONNECTING:
+ if(!t->isConnected())
+ report_disconnect(nodeId, 0);
+ break;
+ }
+ }
+}
+
+// run as own thread
+void
+TransporterRegistry::start_clients_thread()
+{
+ while (m_run_start_clients_thread) {
+ NdbSleep_MilliSleep(100);
+ for (int i= 0, n= 0; n < nTransporters && m_run_start_clients_thread; i++){
+ Transporter * t = theTransporters[i];
+ if (!t)
+ continue;
+ n++;
+
+ const NodeId nodeId = t->getRemoteNodeId();
+ switch(performStates[nodeId]){
+ case CONNECTING:
+ if(!t->isConnected() && !t->isServer)
+ t->connect_client();
+ break;
+ case DISCONNECTING:
+ if(t->isConnected())
+ t->doDisconnect();
+ break;
+ default:
+ break;
+ }
+ }
+ }
+}
+
+bool
+TransporterRegistry::start_clients()
+{
+ m_run_start_clients_thread= true;
+ m_start_clients_thread= NdbThread_Create(run_start_clients_C,
+ (void**)this,
+ 32768,
+ "ndb_start_clients",
+ NDB_THREAD_PRIO_LOW);
+ if (m_start_clients_thread == 0) {
+ m_run_start_clients_thread= false;
+ return false;
+ }
+ return true;
+}
+
+bool
+TransporterRegistry::stop_clients()
+{
+ if (m_start_clients_thread) {
+ m_run_start_clients_thread= false;
+ void* status;
+ int r= NdbThread_WaitFor(m_start_clients_thread, &status);
+ NdbThread_Destroy(&m_start_clients_thread);
+ }
+ return true;
+}
+
+bool
+TransporterRegistry::start_service(SocketServer& socket_server)
+{
+#if 0
+ for (int i= 0, n= 0; n < nTransporters; i++){
+ Transporter * t = theTransporters[i];
+ if (!t)
+ continue;
+ n++;
+ if (t->isServer) {
+ t->m_service = new TransporterService(new SocketAuthSimple("ndbd passwd"));
+ if(!socket_server.setup(t->m_service, t->m_r_port, 0))
+ {
+ ndbout_c("Unable to setup transporter service port: %d!\n"
+ "Please check if the port is already used,\n"
+ "(perhaps a mgmtsrvrserver is already running)",
+ m_service_port);
+ delete t->m_service;
+ return false;
+ }
+ }
+ }
+#endif
+
+ m_transporter_service = new TransporterService(new SocketAuthSimple("ndbd passwd"));
+
+ if (nodeIdSpecified != true) {
+ ndbout_c("TransporterRegistry::startReceiving: localNodeId not specified");
+ return false;
+ }
+
+ m_service_port = 3307 + localNodeId;
+ //m_interface_name = "ndbd";
+ m_interface_name = 0;
+
+ if(!socket_server.setup(m_transporter_service, m_service_port, m_interface_name))
+ {
+ ndbout_c("Unable to setup transporter service port: %d!\n"
+ "Please check if the port is already used,\n"
+ "(perhaps a mgmtsrvrserver is already running)",
+ m_service_port);
+ delete m_transporter_service;
+ return false;
+ }
+
+ m_transporter_service->setTransporterRegistry(this);
+
+ return true;
+}
+
+void
+TransporterRegistry::startReceiving()
+{
#ifdef NDB_OSE_TRANSPORTER
if(theOSEReceiver != NULL){
theOSEReceiver->createPhantom();
@@ -1081,99 +1265,6 @@ TransporterRegistry::stopSending(){
#endif
}
-/**
- * The old implementation did not scale with a large
- * number of nodes. (Watchdog killed NDB because
- * it took too long time to allocated threads in
- * doConnect.
- *
- * The new implementation only checks the connection
- * for a number of transporters (STEPPING), until to
- * the point where all transporters has executed
- * doConnect once. After that, the behaviour is as
- * in the old implemenation, i.e, checking the connection
- * for all transporters.
- * @todo: instead of STEPPING, maybe we should only
- * allow checkConnections to execute for a certain
- * time that somehow factors in heartbeat times and
- * watchdog times.
- *
- */
-
-void
-TransporterRegistry::checkConnections(){
- if(m_ccStep > nTransporters)
- m_ccStep = nTransporters;
-
- while(m_ccCount < m_ccStep){
- if(theTransporters[m_ccIndex] != 0){
- Transporter * t = theTransporters[m_ccIndex];
- const NodeId nodeId = t->getRemoteNodeId();
- if(t->getThreadError() != 0) {
- reportError(callbackObj, nodeId, t->getThreadError());
- t->resetThreadError();
- }
-
- switch(performStates[nodeId]){
- case PerformConnect:
- if(!t->isConnected()){
- t->doConnect();
- if(m_nTransportersPerformConnect!=nTransporters)
- m_nTransportersPerformConnect++;
-
- } else {
- performStates[nodeId] = PerformIO;
- reportConnect(callbackObj, nodeId);
- }
- break;
- case PerformDisconnect:
- {
- bool wasConnected = t->isConnected();
- t->doDisconnect();
- performStates[nodeId] = PerformNothing;
- if(wasConnected){
- reportDisconnect(callbackObj, nodeId,0);
- }
- }
- break;
- case RemoveTransporter:
- removeTransporter(nodeId);
- break;
- case PerformNothing:
- case PerformIO:
- break;
- }
- m_ccCount ++;
- }
- m_ccIndex ++;
- }
-
- if(!m_ccReady) {
- if(m_ccCount < nTransporters) {
- if(nTransporters - m_ccStep < STEPPING)
- m_ccStep += nTransporters-m_ccStep;
- else
- m_ccStep += STEPPING;
-
- // ndbout_c("count %d step %d ", m_ccCount, m_ccStep);
- }
- else {
- m_ccCount = 0;
- m_ccIndex = 0;
- m_ccStep = STEPPING;
- // ndbout_c("count %d step %d ", m_ccCount, m_ccStep);
- }
- }
- if((nTransporters == m_nTransportersPerformConnect) || m_ccReady) {
- m_ccReady = true;
- m_ccCount = 0;
- m_ccIndex = 0;
- m_ccStep = nTransporters;
- // ndbout_c("alla count %d step %d ", m_ccCount, m_ccStep);
- }
-
-}//TransporterRegistry::checkConnections()
-
NdbOut & operator <<(NdbOut & out, SignalHeader & sh){
out << "-- Signal Header --" << endl;
out << "theLength: " << sh.theLength << endl;
diff --git a/ndb/src/common/util/Makefile.am b/ndb/src/common/util/Makefile.am
index 59d9775b8e3..678added01e 100644
--- a/ndb/src/common/util/Makefile.am
+++ b/ndb/src/common/util/Makefile.am
@@ -3,7 +3,8 @@ noinst_LTLIBRARIES = libgeneral.la
libgeneral_la_SOURCES = \
File.cpp md5_hash.cpp Properties.cpp socket_io.cpp \
- SimpleProperties.cpp Parser.cpp InputStream.cpp SocketServer.cpp \
+ SimpleProperties.cpp Parser.cpp InputStream.cpp \
+ SocketServer.cpp SocketClient.cpp SocketAuthenticator.cpp\
OutputStream.cpp NdbOut.cpp BaseString.cpp Base64.cpp \
NdbSqlUtil.cpp new.cpp \
uucode.c random.c getarg.c version.c \
diff --git a/ndb/src/common/util/SocketAuthenticator.cpp b/ndb/src/common/util/SocketAuthenticator.cpp
new file mode 100644
index 00000000000..d0abf89b2b1
--- /dev/null
+++ b/ndb/src/common/util/SocketAuthenticator.cpp
@@ -0,0 +1,63 @@
+/* Copyright (C) 2003 MySQL AB
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+
+#include
+
+#include
+#include
+#include
+
+SocketAuthSimple::SocketAuthSimple(const char *passwd) {
+ m_passwd= strdup(passwd);
+ m_buf= (char*)malloc(strlen(passwd)+1);
+}
+
+SocketAuthSimple::~SocketAuthSimple()
+{
+ if (m_passwd)
+ free((void*)m_passwd);
+ if (m_buf)
+ free(m_buf);
+}
+
+bool SocketAuthSimple::client_authenticate(int sockfd)
+{
+ if (!m_passwd)
+ return false;
+
+ int len = strlen(m_passwd);
+ int r;
+ r= send(sockfd, m_passwd, len, 0);
+
+ r= recv(sockfd, m_buf, len, 0);
+ m_buf[r]= '\0';
+
+ return true;
+}
+
+bool SocketAuthSimple::server_authenticate(int sockfd)
+{
+ if (!m_passwd)
+ return false;
+
+ int len = strlen(m_passwd), r;
+ r= recv(sockfd, m_buf, len, 0);
+ m_buf[r]= '\0';
+ r= send(sockfd, m_passwd, len, 0);
+
+ return true;
+}
diff --git a/ndb/src/common/util/SocketClient.cpp b/ndb/src/common/util/SocketClient.cpp
new file mode 100644
index 00000000000..b7769633875
--- /dev/null
+++ b/ndb/src/common/util/SocketClient.cpp
@@ -0,0 +1,90 @@
+/* Copyright (C) 2003 MySQL AB
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+
+#include
+#include
+
+#include
+#include
+
+SocketClient::SocketClient(const char *server_name, unsigned short port, SocketAuthenticator *sa)
+{
+ m_auth= sa;
+ m_port= port;
+ m_server_name= strdup(server_name);
+ m_sockfd= -1;
+}
+
+SocketClient::~SocketClient()
+{
+ if (m_server_name)
+ free(m_server_name);
+ if (m_sockfd >= 0)
+ NDB_CLOSE_SOCKET(m_sockfd);
+ if (m_auth)
+ delete m_auth;
+}
+
+bool
+SocketClient::init()
+{
+ if (m_sockfd >= 0)
+ NDB_CLOSE_SOCKET(m_sockfd);
+
+ memset(&m_servaddr, 0, sizeof(m_servaddr));
+ m_servaddr.sin_family = AF_INET;
+ m_servaddr.sin_port = htons(m_port);
+ // Convert ip address presentation format to numeric format
+ if (Ndb_getInAddr(&m_servaddr.sin_addr, m_server_name))
+ return false;
+
+ m_sockfd= socket(AF_INET, SOCK_STREAM, 0);
+ if (m_sockfd == NDB_INVALID_SOCKET) {
+ return false;
+ }
+
+ return true;
+}
+
+NDB_SOCKET_TYPE
+SocketClient::connect()
+{
+ if (m_sockfd < 0)
+ {
+ if (!init()) {
+ ndbout << "SocketClient::connect() failed " << m_server_name << " " << m_port << endl;
+ return -1;
+ }
+ }
+
+ const int r = ::connect(m_sockfd, (struct sockaddr*) &m_servaddr, sizeof(m_servaddr));
+ if (r == -1)
+ return -1;
+
+ if (m_auth)
+ if (!m_auth->client_authenticate(m_sockfd))
+ {
+ NDB_CLOSE_SOCKET(m_sockfd);
+ m_sockfd= -1;
+ return -1;
+ }
+
+ NDB_SOCKET_TYPE sockfd= m_sockfd;
+ m_sockfd= -1;
+
+ return sockfd;
+}
diff --git a/ndb/src/common/util/SocketServer.cpp b/ndb/src/common/util/SocketServer.cpp
index a0ec0aaa676..67cbf8aba4a 100644
--- a/ndb/src/common/util/SocketServer.cpp
+++ b/ndb/src/common/util/SocketServer.cpp
@@ -17,7 +17,7 @@
#include
-#include "SocketServer.hpp"
+#include
#include
#include
diff --git a/ndb/src/kernel/Makefile.am b/ndb/src/kernel/Makefile.am
index b2aa5f2e074..60284f6a369 100644
--- a/ndb/src/kernel/Makefile.am
+++ b/ndb/src/kernel/Makefile.am
@@ -4,7 +4,7 @@ include $(top_srcdir)/ndb/config/common.mk.am
ndbbin_PROGRAMS = ndbd
-ndbd_SOURCES = Main.cpp SimBlockList.cpp
+ndbd_SOURCES = main.cpp SimBlockList.cpp
include $(top_srcdir)/ndb/config/type_kernel.mk.am
diff --git a/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
index 694007c8508..fd7d129c790 100644
--- a/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
+++ b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
@@ -360,7 +360,7 @@ void Cmvmi::execCLOSE_COMREQ(Signal* signal)
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
globalTransporterRegistry.setIOState(i, HaltIO);
- globalTransporterRegistry.setPerformState(i, PerformDisconnect);
+ globalTransporterRegistry.do_disconnect(i);
/**
* Cancel possible event subscription
@@ -388,7 +388,7 @@ void Cmvmi::execOPEN_COMREQ(Signal* signal)
const Uint32 len = signal->getLength();
if(len == 2){
- globalTransporterRegistry.setPerformState(tStartingNode, PerformConnect);
+ globalTransporterRegistry.do_connect(tStartingNode);
globalTransporterRegistry.setIOState(tStartingNode, HaltIO);
//-----------------------------------------------------
@@ -403,7 +403,7 @@ void Cmvmi::execOPEN_COMREQ(Signal* signal)
jam();
if (i != getOwnNodeId() && getNodeInfo(i).m_type == tData2){
jam();
- globalTransporterRegistry.setPerformState(i, PerformConnect);
+ globalTransporterRegistry.do_connect(i);
globalTransporterRegistry.setIOState(i, HaltIO);
signal->theData[0] = EventReport::CommunicationOpened;
@@ -454,34 +454,21 @@ void Cmvmi::execDISCONNECT_REP(Signal *signal)
const NodeInfo::NodeType type = getNodeInfo(hostId).getType();
ndbrequire(type != NodeInfo::INVALID);
- if (globalTransporterRegistry.performState(hostId) != PerformDisconnect) {
+ if(type == NodeInfo::DB || globalData.theStartLevel == NodeState::SL_STARTED){
jam();
-
- // -------------------------------------------------------------------
- // We do not report the disconnection when disconnection is already ongoing.
- // This reporting should be looked into but this secures that we avoid
- // crashes due to too quick re-reporting of disconnection.
- // -------------------------------------------------------------------
- if(type == NodeInfo::DB || globalData.theStartLevel == NodeState::SL_STARTED){
- jam();
- DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0];
- rep->nodeId = hostId;
- rep->err = errNo;
- sendSignal(QMGR_REF, GSN_DISCONNECT_REP, signal,
- DisconnectRep::SignalLength, JBA);
- globalTransporterRegistry.setPerformState(hostId, PerformDisconnect);
- } else if(globalData.theStartLevel == NodeState::SL_CMVMI ||
- globalData.theStartLevel == NodeState::SL_STARTING) {
- /**
- * Someone disconnected during cmvmi period
- */
- if(type == NodeInfo::MGM){
- jam();
- globalTransporterRegistry.setPerformState(hostId, PerformConnect);
- } else {
- globalTransporterRegistry.setPerformState(hostId, PerformDisconnect);
- }
- }
+ DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0];
+ rep->nodeId = hostId;
+ rep->err = errNo;
+ sendSignal(QMGR_REF, GSN_DISCONNECT_REP, signal,
+ DisconnectRep::SignalLength, JBA);
+ } else if((globalData.theStartLevel == NodeState::SL_CMVMI ||
+ globalData.theStartLevel == NodeState::SL_STARTING)
+ && type == NodeInfo::MGM) {
+ /**
+ * Someone disconnected during cmvmi period
+ */
+ jam();
+ globalTransporterRegistry.do_connect(hostId);
}
signal->theData[0] = EventReport::Disconnected;
@@ -520,7 +507,8 @@ void Cmvmi::execCONNECT_REP(Signal *signal){
/**
* Dont allow api nodes to connect
*/
- globalTransporterRegistry.setPerformState(hostId, PerformDisconnect);
+ abort();
+ globalTransporterRegistry.do_disconnect(hostId);
}
}
@@ -754,8 +742,8 @@ Cmvmi::execSTART_ORD(Signal* signal) {
*/
for(unsigned int i = 1; i < MAX_NODES; i++ ){
if (getNodeInfo(i).m_type == NodeInfo::MGM){
- if(globalTransporterRegistry.performState(i) != PerformIO){
- globalTransporterRegistry.setPerformState(i, PerformConnect);
+ if(!globalTransporterRegistry.is_connected(i)){
+ globalTransporterRegistry.do_connect(i);
globalTransporterRegistry.setIOState(i, NoHalt);
}
}
@@ -781,7 +769,7 @@ Cmvmi::execSTART_ORD(Signal* signal) {
// without any connected nodes.
for(unsigned int i = 1; i < MAX_NODES; i++ ){
if (i != getOwnNodeId() && getNodeInfo(i).m_type != NodeInfo::MGM){
- globalTransporterRegistry.setPerformState(i, PerformDisconnect);
+ globalTransporterRegistry.do_disconnect(i);
globalTransporterRegistry.setIOState(i, HaltIO);
}
}
@@ -1060,29 +1048,10 @@ Cmvmi::execDUMP_STATE_ORD(Signal* signal)
if(nodeTypeStr == 0)
continue;
- const char* actionStr = "";
- switch (globalTransporterRegistry.performState(i)){
- case PerformNothing:
- actionStr = "does nothing";
- break;
- case PerformIO:
- actionStr = "is connected";
- break;
- case PerformConnect:
- actionStr = "is trying to connect";
- break;
- case PerformDisconnect:
- actionStr = "is trying to disconnect";
- break;
- case RemoveTransporter:
- actionStr = "will be removed";
- break;
- }
-
infoEvent("Connection to %d (%s) %s",
i,
nodeTypeStr,
- actionStr);
+ globalTransporterRegistry.getPerformStateString(i));
}
}
diff --git a/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp b/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
index f2d2edb615d..46f1acb9761 100644
--- a/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
+++ b/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
@@ -1704,6 +1704,7 @@ void Qmgr::sendApiFailReq(Signal* signal, Uint16 failedNodeNo)
sendSignal(DBTC_REF, GSN_API_FAILREQ, signal, 2, JBA);
sendSignal(DBDICT_REF, GSN_API_FAILREQ, signal, 2, JBA);
sendSignal(SUMA_REF, GSN_API_FAILREQ, signal, 2, JBA);
+
/**
* GREP also need the information that an API node
* (actually a REP node) has failed.
@@ -1978,8 +1979,11 @@ void Qmgr::execAPI_REGREQ(Signal* signal)
apiRegConf->nodeState.dynamicId = -dynamicId;
}
}
+ c_connectedNodes.copyto(NdbNodeBitmask::Size,
+ apiRegConf->connected_nodes.data);
+
sendSignal(ref, GSN_API_REGCONF, signal, ApiRegConf::SignalLength, JBB);
-
+
if ((getNodeState().startLevel == NodeState::SL_STARTED ||
getNodeState().getSingleUserMode())
&& apiNodePtr.p->phase == ZAPI_INACTIVE) {
diff --git a/ndb/src/kernel/Main.cpp b/ndb/src/kernel/main.cpp
similarity index 94%
rename from ndb/src/kernel/Main.cpp
rename to ndb/src/kernel/main.cpp
index 7bd4e75ca18..d2137a63c4d 100644
--- a/ndb/src/kernel/Main.cpp
+++ b/ndb/src/kernel/main.cpp
@@ -20,7 +20,7 @@
#include "Configuration.hpp"
#include
-#include "SimBlockList.hpp"
+#include "vm/SimBlockList.hpp"
#include "ThreadConfig.hpp"
#include
#include
@@ -171,13 +171,29 @@ NDB_MAIN(ndb_kernel){
NDB_ASSERT(0, "Illegal state globalData.theRestartFlag");
}
+ SocketServer socket_server;
+
globalTransporterRegistry.startSending();
globalTransporterRegistry.startReceiving();
+ if (!globalTransporterRegistry.start_service(socket_server))
+ NDB_ASSERT(0, "globalTransporterRegistry.start_service() failed");
+
+ if (!globalTransporterRegistry.start_clients())
+ NDB_ASSERT(0, "globalTransporterRegistry.start_clients() failed");
+
globalEmulatorData.theWatchDog->doStart();
+ socket_server.startServer();
+
globalEmulatorData.theThreadConfig->ipControlLoop();
NdbShutdown(NST_Normal);
+
+ socket_server.stopServer();
+ socket_server.stopSessions();
+
+ globalTransporterRegistry.stop_clients();
+
return NRT_Default;
}
diff --git a/ndb/src/kernel/vm/ThreadConfig.cpp b/ndb/src/kernel/vm/ThreadConfig.cpp
index d18b20a5bb5..4844bb9a477 100644
--- a/ndb/src/kernel/vm/ThreadConfig.cpp
+++ b/ndb/src/kernel/vm/ThreadConfig.cpp
@@ -147,8 +147,8 @@ void ThreadConfig::ipControlLoop()
// plus checking for any received messages.
//--------------------------------------------------------------------
if (i++ >= 20) {
+ globalTransporterRegistry.update_connections();
globalData.incrementWatchDogCounter(5);
- globalTransporterRegistry.checkConnections();
i = 0;
}//if
diff --git a/ndb/src/mgmapi/mgmapi.cpp b/ndb/src/mgmapi/mgmapi.cpp
index bb4b6be8221..21a2ab074e7 100644
--- a/ndb/src/mgmapi/mgmapi.cpp
+++ b/ndb/src/mgmapi/mgmapi.cpp
@@ -24,6 +24,7 @@
#include
#include
+#include
#include
#include
#include
@@ -318,8 +319,8 @@ ndb_mgm_call(NdbMgmHandle handle, const ParserRow *command_reply,
/**
* Print some info about why the parser returns NULL
*/
-// ndbout << " status=" << ctx.m_status << ", curr="
-// << ctx.m_currentToken << endl;
+ //ndbout << " status=" << ctx.m_status << ", curr="
+ //<< ctx.m_currentToken << endl;
}
#ifdef MGMAPI_LOG
else {
@@ -362,30 +363,11 @@ ndb_mgm_connect(NdbMgmHandle handle, const char * mgmsrv)
/**
* Do connect
*/
- const NDB_SOCKET_TYPE sockfd = socket(AF_INET, SOCK_STREAM, 0);
- if (sockfd == NDB_INVALID_SOCKET) {
- SET_ERROR(handle, NDB_MGM_ILLEGAL_SOCKET, "");
- return -1;
- }
-
- struct sockaddr_in servaddr;
- memset(&servaddr, 0, sizeof(servaddr));
- servaddr.sin_family = AF_INET;
- servaddr.sin_port = htons(handle->port);
- // Convert ip address presentation format to numeric format
- const int res1 = Ndb_getInAddr(&servaddr.sin_addr, handle->hostname);
- if (res1 != 0) {
- DEBUG("Ndb_getInAddr(...) == -1");
- setError(handle, EINVAL, __LINE__, "Invalid hostname/address");
- return -1;
- }
-
- const int res2 = connect(sockfd, (struct sockaddr*) &servaddr,
- sizeof(servaddr));
- if (res2 == -1) {
- NDB_CLOSE_SOCKET(sockfd);
- setError(handle, NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, __LINE__, "Unable to connect to %s",
- mgmsrv);
+ SocketClient s(handle->hostname, handle->port);
+ const NDB_SOCKET_TYPE sockfd = s.connect();
+ if (sockfd < 0) {
+ setError(handle, NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, __LINE__,
+ "Unable to connect to %s", mgmsrv);
return -1;
}
@@ -1523,6 +1505,55 @@ ndb_mgm_get_configuration(NdbMgmHandle handle, unsigned int version) {
return 0;
}
+extern "C"
+int
+ndb_mgm_alloc_nodeid(NdbMgmHandle handle, unsigned int version, unsigned *pnodeid, int nodetype)
+{
+
+ CHECK_HANDLE(handle, 0);
+ CHECK_CONNECTED(handle, 0);
+
+ Properties args;
+ args.put("version", version);
+ args.put("nodetype", nodetype);
+ args.put("nodeid", *pnodeid);
+ args.put("user", "mysqld");
+ args.put("password", "mysqld");
+ args.put("public key", "a public key");
+
+ const ParserRow reply[]= {
+ MGM_CMD("get nodeid reply", NULL, ""),
+ MGM_ARG("nodeid", Int, Optional, "Error message"),
+ MGM_ARG("result", String, Mandatory, "Error message"),
+ MGM_END()
+ };
+
+ const Properties *prop;
+ prop= ndb_mgm_call(handle, reply, "get nodeid", &args);
+
+ if(prop == NULL) {
+ SET_ERROR(handle, EIO, "Unable to alloc nodeid");
+ return -1;
+ }
+
+ int res= -1;
+ do {
+ const char * buf;
+ if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
+ ndbout_c("ERROR Message: %s\n", buf);
+ break;
+ }
+ if(!prop->get("nodeid", pnodeid) != 0){
+ ndbout_c("ERROR Message: \n");
+ break;
+ }
+ res= 0;
+ }while(0);
+
+ delete prop;
+ return res;
+}
+
/*****************************************************************************
* Global Replication
******************************************************************************/
diff --git a/ndb/src/mgmsrv/MgmtSrvr.cpp b/ndb/src/mgmsrv/MgmtSrvr.cpp
index 713433cb8e9..77ff52dc4bb 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.cpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.cpp
@@ -43,7 +43,7 @@
#include
#include
-#include "SocketServer.hpp"
+#include
#include "NodeLogLevel.hpp"
#include
@@ -390,6 +390,95 @@ MgmtSrvr::getNodeCount(enum ndb_mgm_node_type type) const
return count;
}
+int
+MgmtSrvr::getPort() const {
+ const Properties *mgmProps;
+
+ ndb_mgm_configuration_iterator * iter =
+ ndb_mgm_create_configuration_iterator(_config->m_configValues,
+ CFG_SECTION_NODE);
+ if(iter == 0)
+ return 0;
+
+ if(ndb_mgm_find(iter, CFG_NODE_ID, getOwnNodeId()) != 0){
+ ndbout << "Could not retrieve configuration for Node "
+ << getOwnNodeId() << " in config file." << endl
+ << "Have you set correct NodeId for this node?" << endl;
+ ndb_mgm_destroy_iterator(iter);
+ return 0;
+ }
+
+ unsigned type;
+ if(ndb_mgm_get_int_parameter(iter, CFG_TYPE_OF_SECTION, &type) != 0 ||
+ type != NODE_TYPE_MGM){
+ ndbout << "Local node id " << getOwnNodeId()
+ << " is not defined as management server" << endl
+ << "Have you set correct NodeId for this node?" << endl;
+ return 0;
+ }
+
+ Uint32 port = 0;
+ if(ndb_mgm_get_int_parameter(iter, CFG_MGM_PORT, &port) != 0){
+ ndbout << "Could not find PortNumber in the configuration file." << endl;
+ return 0;
+ }
+
+ /*****************
+ * Set Stat Port *
+ *****************/
+#if 0
+ if (!mgmProps->get("PortNumberStats", &tmp)){
+ ndbout << "Could not find PortNumberStats in the configuration file."
+ << endl;
+ return false;
+ }
+ glob.port_stats = tmp;
+#endif
+
+#if 0
+ const char * host;
+ if(ndb_mgm_get_string_parameter(iter, mgmProps->get("ExecuteOnComputer", host)){
+ ndbout << "Failed to find \"ExecuteOnComputer\" for my node" << endl;
+ ndbout << "Unable to verify own hostname" << endl;
+ return false;
+ }
+
+ const char * hostname;
+ {
+ const Properties * p;
+ char buf[255];
+ snprintf(buf, sizeof(buf), "Computer_%s", host.c_str());
+ if(!glob.cluster_config->get(buf, &p)){
+ ndbout << "Failed to find computer " << host << " in config" << endl;
+ ndbout << "Unable to verify own hostname" << endl;
+ return false;
+ }
+ if(!p->get("HostName", &hostname)){
+ ndbout << "Failed to find \"HostName\" for computer " << host
+ << " in config" << endl;
+ ndbout << "Unable to verify own hostname" << endl;
+ return false;
+ }
+ if(NdbHost_GetHostName(buf) != 0){
+ ndbout << "Unable to get own hostname" << endl;
+ ndbout << "Unable to verify own hostname" << endl;
+ return false;
+ }
+ }
+
+ const char * ip_address;
+ if(mgmProps->get("IpAddress", &ip_address)){
+ glob.use_specific_ip = true;
+ glob.interface_name = strdup(ip_address);
+ return true;
+ }
+
+ glob.interface_name = strdup(hostname);
+#endif
+
+ return port;
+}
+
int
MgmtSrvr::getStatPort() const {
#if 0
@@ -419,7 +508,6 @@ MgmtSrvr::MgmtSrvr(NodeId nodeId,
theWaitState(WAIT_SUBSCRIBE_CONF),
theConfCount(0) {
- _ownNodeId = nodeId;
_config = NULL;
_isStatPortActive = false;
_isClusterLogStatActive = false;
@@ -429,6 +517,8 @@ MgmtSrvr::MgmtSrvr(NodeId nodeId,
_logLevelThreadSleep = 500;
_startedNodeId = 0;
+ theFacade = 0;
+
m_newConfig = NULL;
m_configFilename = configFilename;
setCallback(CmdBackupCallback);
@@ -486,6 +576,15 @@ MgmtSrvr::MgmtSrvr(NodeId nodeId,
_clusterLogLevelList = new NodeLogLevelList();
_props = NULL;
+
+ _ownNodeId= 0;
+ NodeId tmp= nodeId > 0 ? nodeId-1 : 0;
+ if (getNextFreeNodeId(&tmp, NDB_MGM_NODE_TYPE_MGM)){
+ _ownNodeId= tmp;
+ if (nodeId != 0 && nodeId != tmp)
+ _ownNodeId= 0; // did not get nodeid requested
+ } else
+ NDB_ASSERT(0, "Unable to retrieve own node id");
}
@@ -510,8 +609,7 @@ MgmtSrvr::start()
return false;
}
theFacade = TransporterFacade::start_instance
- (_ownNodeId,
- (ndb_mgm_configuration*)_config->m_configValues);
+ (_ownNodeId,(ndb_mgm_configuration*)_config->m_configValues);
if(theFacade == 0) {
DEBUG("MgmtSrvr.cpp: theFacade is NULL.");
@@ -1896,6 +1994,7 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
int returnCode;
int gsn = signal->readSignalNumber();
+
switch (gsn) {
case GSN_API_VERSION_CONF: {
if (theWaitState == WAIT_VERSION) {
@@ -2187,6 +2286,36 @@ MgmtSrvr::getNodeType(NodeId nodeId) const
return nodeTypes[nodeId];
}
+bool
+MgmtSrvr::getNextFreeNodeId(NodeId * nodeId,
+ enum ndb_mgm_node_type type) const
+{
+#if 0
+ ndbout << "MgmtSrvr::getNextFreeNodeId type=" << type
+ << " *nodeid=" << *nodeId << endl;
+#endif
+
+ NodeId tmp= *nodeId;
+ if (theFacade && theFacade->theClusterMgr) {
+ while(getNextNodeId(&tmp, type)){
+ if (theFacade->theClusterMgr->m_connected_nodes.get(tmp))
+ continue;
+#if 0
+ ndbout << "MgmtSrvr::getNextFreeNodeId ret=" << tmp << endl;
+#endif
+ *nodeId= tmp;
+ return true;
+ }
+ } else if (getNextNodeId(&tmp, type)){
+#if 0
+ ndbout << "MgmtSrvr::getNextFreeNodeId (theFacade==0) ret=" << tmp << endl;
+#endif
+ *nodeId= tmp;
+ return true;
+ }
+ return false;
+}
+
bool
MgmtSrvr::getNextNodeId(NodeId * nodeId, enum ndb_mgm_node_type type) const
{
diff --git a/ndb/src/mgmsrv/MgmtSrvr.hpp b/ndb/src/mgmsrv/MgmtSrvr.hpp
index 1d394a14857..5760a55a676 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.hpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.hpp
@@ -150,10 +150,12 @@ public:
enum LogMode {In, Out, InOut, Off};
/* Constructor */
+
MgmtSrvr(NodeId nodeId, /* Local nodeid */
const BaseString &config_filename, /* Where to save config */
const BaseString &ndb_config_filename, /* Ndb.cfg filename */
Config * config);
+ NodeId getOwnNodeId() const {return _ownNodeId;};
/**
* Read (initial) config file, create TransporterFacade,
@@ -448,6 +450,7 @@ public:
* @return false if none found
*/
bool getNextNodeId(NodeId * _nodeId, enum ndb_mgm_node_type type) const ;
+ bool getNextFreeNodeId(NodeId * _nodeId, enum ndb_mgm_node_type type) const ;
/**
*
@@ -492,6 +495,11 @@ public:
* @return statistic port number.
*/
int getStatPort() const;
+ /**
+ * Returns the port number.
+ * @return port number.
+ */
+ int getPort() const;
//**************************************************************************
diff --git a/ndb/src/mgmsrv/Services.cpp b/ndb/src/mgmsrv/Services.cpp
index 739eef90c52..2049ca54864 100644
--- a/ndb/src/mgmsrv/Services.cpp
+++ b/ndb/src/mgmsrv/Services.cpp
@@ -121,6 +121,14 @@ ParserRow commands[] = {
MGM_ARG("version", Int, Mandatory, "Configuration version number"),
MGM_ARG("node", Int, Optional, "Node ID"),
+ MGM_CMD("get nodeid", &MgmApiSession::get_nodeid, ""),
+ MGM_ARG("version", Int, Mandatory, "Configuration version number"),
+ MGM_ARG("nodetype", Int, Mandatory, "Node type"),
+ MGM_ARG("nodeid", Int, Optional, "Node ID"),
+ MGM_ARG("user", String, Mandatory, "Password"),
+ MGM_ARG("password", String, Mandatory, "Password"),
+ MGM_ARG("public key", String, Mandatory, "Public key"),
+
MGM_CMD("get version", &MgmApiSession::getVersion, ""),
MGM_CMD("get status", &MgmApiSession::getStatus, ""),
@@ -332,6 +340,82 @@ backward(const char * base, const Properties* reply){
return ret;
}
+void
+MgmApiSession::get_nodeid(Parser_t::Context &,
+ const class Properties &args)
+{
+ const char *cmd= "get nodeid reply";
+ Uint32 version, nodeid= 0, nodetype= 0xff;
+ const char * user;
+ const char * password;
+ const char * public_key;
+
+ args.get("version", &version);
+ args.get("nodetype", &nodetype);
+ args.get("nodeid", &nodeid);
+ args.get("user", &user);
+ args.get("password", &password);
+ args.get("public key", &public_key);
+
+ NodeId free_id= 0;
+ NodeId tmp= nodeid > 0 ? nodeid-1 : 0;
+ bool compatible;
+ switch (nodetype) {
+ case NODE_TYPE_MGM:
+ compatible = ndbCompatible_mgmt_api(NDB_VERSION, version);
+ if (m_mgmsrv.getNextFreeNodeId(&tmp, NDB_MGM_NODE_TYPE_MGM))
+ free_id= tmp;
+ break;
+ case NODE_TYPE_API:
+ compatible = ndbCompatible_mgmt_api(NDB_VERSION, version);
+ if (m_mgmsrv.getNextFreeNodeId(&tmp, NDB_MGM_NODE_TYPE_API))
+ free_id= tmp;
+ break;
+ case NODE_TYPE_DB:
+ compatible = ndbCompatible_mgmt_ndb(NDB_VERSION, version);
+ if (m_mgmsrv.getNextFreeNodeId(&tmp, NDB_MGM_NODE_TYPE_NDB))
+ free_id= tmp;
+ break;
+ default:
+ m_output->println(cmd);
+ m_output->println("result: unknown nodetype %d", nodetype);
+ m_output->println("");
+ return;
+ }
+
+ if (nodeid != 0 && free_id != nodeid){
+ m_output->println(cmd);
+ m_output->println("result: no free nodeid %d for nodetype %d",
+ nodeid, nodetype);
+ m_output->println("");
+ return;
+ }
+
+ if (free_id == 0){
+ m_output->println(cmd);
+ m_output->println("result: no free nodeid for nodetype %d", nodetype);
+ m_output->println("");
+ return;
+ }
+
+#if 0
+ if (!compatible){
+ m_output->println(cmd);
+ m_output->println("result: incompatible version mgmt 0x%x and node 0x%x",
+ NDB_VERSION, version);
+ m_output->println("");
+ return;
+ }
+#endif
+
+ m_output->println(cmd);
+ m_output->println("nodeid: %u", free_id);
+ m_output->println("result: Ok");
+ m_output->println("");
+
+ return;
+}
+
void
MgmApiSession::getConfig_common(Parser_t::Context &,
const class Properties &args,
@@ -432,7 +516,6 @@ MgmApiSession::getConfig_common(Parser_t::Context &,
m_output->println("Content-Transfer-Encoding: base64");
m_output->println("");
m_output->println(str.c_str());
- m_output->println("");
return;
}
diff --git a/ndb/src/mgmsrv/Services.hpp b/ndb/src/mgmsrv/Services.hpp
index 3690f1a5a93..545d2bf846f 100644
--- a/ndb/src/mgmsrv/Services.hpp
+++ b/ndb/src/mgmsrv/Services.hpp
@@ -51,6 +51,7 @@ public:
void getConfig_old(Parser_t::Context &ctx);
#endif /* MGM_GET_CONFIG_BACKWARDS_COMPAT */
+ void get_nodeid(Parser_t::Context &ctx, const class Properties &args);
void getVersion(Parser_t::Context &ctx, const class Properties &args);
void getStatus(Parser_t::Context &ctx, const class Properties &args);
void getInfoClusterLog(Parser_t::Context &ctx, const class Properties &args);
diff --git a/ndb/src/mgmsrv/main.cpp b/ndb/src/mgmsrv/main.cpp
index d9eb0001c44..db977cc492f 100644
--- a/ndb/src/mgmsrv/main.cpp
+++ b/ndb/src/mgmsrv/main.cpp
@@ -20,7 +20,7 @@
#include "MgmtSrvr.hpp"
#include "EventLogger.hpp"
-#include "Config.hpp"
+#include
#include "InitConfigFileParser.hpp"
#include
#include "Services.hpp"
@@ -88,7 +88,6 @@ static MgmGlobals glob;
******************************************************************************/
static bool readLocalConfig();
static bool readGlobalConfig();
-static bool setPortNo();
/**
* Global variables
@@ -146,7 +145,9 @@ NDB_MAIN(mgmsrv){
exit(1);
}
glob.socketServer = new SocketServer();
+
MgmApiService * mapi = new MgmApiService();
+
MgmStatService * mstat = new MgmStatService();
/****************************
@@ -157,9 +158,26 @@ NDB_MAIN(mgmsrv){
if (!readGlobalConfig())
goto error_end;
- if (!setPortNo())
+ glob.mgmObject = new MgmtSrvr(glob.localNodeId,
+ BaseString(glob.config_filename),
+ BaseString(glob.local_config_filename == 0 ?
+ "" : glob.local_config_filename),
+ glob.cluster_config);
+
+ glob.cluster_config = 0;
+ glob.localNodeId= glob.mgmObject->getOwnNodeId();
+
+ if (glob.localNodeId == 0)
goto error_end;
-
+
+ glob.port= glob.mgmObject->getPort();
+
+ if (glob.port == 0)
+ goto error_end;
+
+ glob.interface_name = 0;
+ glob.use_specific_ip = false;
+
if(!glob.use_specific_ip){
if(!glob.socketServer->tryBind(glob.port, glob.interface_name)){
ndbout_c("Unable to setup port: %s:%d!\n"
@@ -190,15 +208,8 @@ NDB_MAIN(mgmsrv){
goto error_end;
}
- glob.mgmObject = new MgmtSrvr(glob.localNodeId,
- BaseString(glob.config_filename),
- BaseString(glob.local_config_filename == 0 ? "" : glob.local_config_filename),
- glob.cluster_config);
-
- glob.cluster_config = 0;
-
if(!glob.mgmObject->check_start()){
- ndbout_c("Unable to start management server.");
+ ndbout_c("Unable to check start management server.");
ndbout_c("Probably caused by illegal initial configuration file.");
goto error_end;
}
@@ -343,108 +354,3 @@ readGlobalConfig() {
}
return true;
}
-
-/**
- * @fn setPortNo
- * @param glob : Global variables
- * @return true if success, false otherwise.
- *
- * Port number:
- * 2. Use port number from global configuration file
- * 4. Use port number for statistics from global configuration file
- */
-static bool
-setPortNo(){
- const Properties *mgmProps;
-
- ndb_mgm_configuration_iterator * iter =
- ndb_mgm_create_configuration_iterator(glob.cluster_config->m_configValues,
- CFG_SECTION_NODE);
- if(iter == 0)
- return false;
-
- if(ndb_mgm_find(iter, CFG_NODE_ID, glob.localNodeId) != 0){
- ndbout << "Could not retrieve configuration for Node "
- << glob.localNodeId << " in config file." << endl
- << "Have you set correct NodeId for this node?" << endl;
- ndb_mgm_destroy_iterator(iter);
- return false;
- }
-
- unsigned type;
- if(ndb_mgm_get_int_parameter(iter, CFG_TYPE_OF_SECTION, &type) != 0 ||
- type != NODE_TYPE_MGM){
- ndbout << "Local node id " << glob.localNodeId
- << " is not defined as management server" << endl
- << "Have you set correct NodeId for this node?" << endl;
- return false;
- }
-
- /************
- * Set Port *
- ************/
- Uint32 tmp = 0;
- if(ndb_mgm_get_int_parameter(iter, CFG_MGM_PORT, &tmp) != 0){
- ndbout << "Could not find PortNumber in the configuration file." << endl;
- return false;
- }
- glob.port = tmp;
-
- /*****************
- * Set Stat Port *
- *****************/
-#if 0
- if (!mgmProps->get("PortNumberStats", &tmp)){
- ndbout << "Could not find PortNumberStats in the configuration file."
- << endl;
- return false;
- }
- glob.port_stats = tmp;
-#endif
-
-#if 0
- const char * host;
- if(ndb_mgm_get_string_parameter(iter, mgmProps->get("ExecuteOnComputer", host)){
- ndbout << "Failed to find \"ExecuteOnComputer\" for my node" << endl;
- ndbout << "Unable to verify own hostname" << endl;
- return false;
- }
-
- const char * hostname;
- {
- const Properties * p;
- char buf[255];
- snprintf(buf, sizeof(buf), "Computer_%s", host.c_str());
- if(!glob.cluster_config->get(buf, &p)){
- ndbout << "Failed to find computer " << host << " in config" << endl;
- ndbout << "Unable to verify own hostname" << endl;
- return false;
- }
- if(!p->get("HostName", &hostname)){
- ndbout << "Failed to find \"HostName\" for computer " << host
- << " in config" << endl;
- ndbout << "Unable to verify own hostname" << endl;
- return false;
- }
- if(NdbHost_GetHostName(buf) != 0){
- ndbout << "Unable to get own hostname" << endl;
- ndbout << "Unable to verify own hostname" << endl;
- return false;
- }
- }
-
- const char * ip_address;
- if(mgmProps->get("IpAddress", &ip_address)){
- glob.use_specific_ip = true;
- glob.interface_name = strdup(ip_address);
- return true;
- }
-
- glob.interface_name = strdup(hostname);
-#endif
-
- glob.interface_name = 0;
- glob.use_specific_ip = false;
-
- return true;
-}
diff --git a/ndb/src/ndbapi/ClusterMgr.cpp b/ndb/src/ndbapi/ClusterMgr.cpp
index b26d550fe31..b5428cb46b0 100644
--- a/ndb/src/ndbapi/ClusterMgr.cpp
+++ b/ndb/src/ndbapi/ClusterMgr.cpp
@@ -295,11 +295,14 @@ ClusterMgr::execAPI_REGREQ(const Uint32 * theData){
}
int global_mgmt_server_check = 0; // set to one in mgmtsrvr main;
+
void
ClusterMgr::execAPI_REGCONF(const Uint32 * theData){
const ApiRegConf * const apiRegConf = (ApiRegConf *)&theData[0];
const NodeId nodeId = refToNode(apiRegConf->qmgrRef);
+ m_connected_nodes.assign(apiRegConf->connected_nodes);
+
#if 0
ndbout_c("ClusterMgr: Recd API_REGCONF from node %d", nodeId);
#endif
@@ -309,6 +312,7 @@ ClusterMgr::execAPI_REGCONF(const Uint32 * theData){
Node & node = theNodes[nodeId];
assert(node.defined == true);
assert(node.connected == true);
+
if(node.m_info.m_version != apiRegConf->version){
node.m_info.m_version = apiRegConf->version;
if (global_mgmt_server_check == 1)
@@ -422,6 +426,8 @@ ClusterMgr::reportDisconnected(NodeId nodeId){
void
ClusterMgr::reportNodeFailed(NodeId nodeId){
+ m_connected_nodes.clear(nodeId);
+
Node & theNode = theNodes[nodeId];
theNode.m_alive = false;
diff --git a/ndb/src/ndbapi/ClusterMgr.hpp b/ndb/src/ndbapi/ClusterMgr.hpp
index cc3cf66c8aa..a516df3e27f 100644
--- a/ndb/src/ndbapi/ClusterMgr.hpp
+++ b/ndb/src/ndbapi/ClusterMgr.hpp
@@ -78,6 +78,7 @@ public:
const Node & getNodeInfo(NodeId) const;
Uint32 getNoOfConnectedNodes() const;
+ NodeBitmask m_connected_nodes;
private:
Uint32 noOfConnectedNodes;
diff --git a/ndb/src/ndbapi/TransporterFacade.cpp b/ndb/src/ndbapi/TransporterFacade.cpp
index e725144a8f8..dea7b1e4bec 100644
--- a/ndb/src/ndbapi/TransporterFacade.cpp
+++ b/ndb/src/ndbapi/TransporterFacade.cpp
@@ -39,6 +39,7 @@
#endif
//#define REPORT_TRANSPORTER
+//#define API_TRACE;
#if defined DEBUG_TRANSPORTER
#define TRP_DEBUG(t) ndbout << __FILE__ << ":" << __LINE__ << ":" << t << endl;
@@ -440,7 +441,17 @@ runSendRequest_C(void * me)
void TransporterFacade::threadMainSend(void)
{
+ SocketServer socket_server;
+
theTransporterRegistry->startSending();
+ if (!theTransporterRegistry->start_service(socket_server))
+ NDB_ASSERT(0, "Unable to start theTransporterRegistry->start_service");
+
+ if (!theTransporterRegistry->start_clients())
+ NDB_ASSERT(0, "Unable to start theTransporterRegistry->start_clients");
+
+ socket_server.startServer();
+
while(!theStopReceive) {
NdbSleep_MilliSleep(10);
NdbMutex_Lock(theMutexPtr);
@@ -451,6 +462,11 @@ void TransporterFacade::threadMainSend(void)
NdbMutex_Unlock(theMutexPtr);
}
theTransporterRegistry->stopSending();
+
+ socket_server.stopServer();
+ socket_server.stopSessions();
+
+ theTransporterRegistry->stop_clients();
}
extern "C"
@@ -466,7 +482,7 @@ void TransporterFacade::threadMainReceive(void)
{
theTransporterRegistry->startReceiving();
NdbMutex_Lock(theMutexPtr);
- theTransporterRegistry->checkConnections();
+ theTransporterRegistry->update_connections();
NdbMutex_Unlock(theMutexPtr);
while(!theStopReceive) {
for(int i = 0; i<10; i++){
@@ -478,7 +494,7 @@ void TransporterFacade::threadMainReceive(void)
}
}
NdbMutex_Lock(theMutexPtr);
- theTransporterRegistry->checkConnections();
+ theTransporterRegistry->update_connections();
NdbMutex_Unlock(theMutexPtr);
}//while
theTransporterRegistry->stopReceiving();
@@ -875,13 +891,13 @@ TransporterFacade::sendFragmentedSignalUnCond(NdbApiSignal* aSignal,
void
TransporterFacade::doConnect(int aNodeId){
theTransporterRegistry->setIOState(aNodeId, NoHalt);
- theTransporterRegistry->setPerformState(aNodeId, PerformConnect);
+ theTransporterRegistry->do_connect(aNodeId);
}
void
TransporterFacade::doDisconnect(int aNodeId)
{
- theTransporterRegistry->setPerformState(aNodeId, PerformDisconnect);
+ theTransporterRegistry->do_disconnect(aNodeId);
}
void
@@ -906,7 +922,7 @@ TransporterFacade::ownId() const
bool
TransporterFacade::isConnected(NodeId aNodeId){
- return theTransporterRegistry->performState(aNodeId) == PerformIO;
+ return theTransporterRegistry->is_connected(aNodeId);
}
NodeId
diff --git a/ndb/src/ndbapi/TransporterFacade.hpp b/ndb/src/ndbapi/TransporterFacade.hpp
index 4b76cbe864a..e6720f7de2e 100644
--- a/ndb/src/ndbapi/TransporterFacade.hpp
+++ b/ndb/src/ndbapi/TransporterFacade.hpp
@@ -110,7 +110,6 @@ public:
// Close this block number
int close_local(BlockNumber blockNumber);
- void setState(Uint32 aNodeId, PerformState aState);
private:
/**
From 90b01f1cd2d960570aa9f35976b97dfd53ce4bd5 Mon Sep 17 00:00:00 2001
From: "pekka@mysql.com" <>
Date: Wed, 23 Jun 2004 11:49:38 +0200
Subject: [PATCH 022/579] testOIBasic.cpp: quick fix to new scan
---
ndb/test/ndbapi/testOIBasic.cpp | 46 ++++++++++++++++++++-------------
1 file changed, 28 insertions(+), 18 deletions(-)
diff --git a/ndb/test/ndbapi/testOIBasic.cpp b/ndb/test/ndbapi/testOIBasic.cpp
index a255cc74331..cd7b34b647b 100644
--- a/ndb/test/ndbapi/testOIBasic.cpp
+++ b/ndb/test/ndbapi/testOIBasic.cpp
@@ -567,22 +567,23 @@ struct Con {
NdbDictionary::Dictionary* m_dic;
NdbConnection* m_tx;
NdbOperation* m_op;
- NdbConnection* m_scantx;
- NdbIndexScanOperation* m_scanop;
- NdbResultSet* m_resultSet;
+ NdbScanOperation* m_scanop;
+ NdbIndexScanOperation* m_indexscanop;
+ NdbResultSet* m_resultset;
enum ScanMode { ScanNo = 0, Committed, Latest, Exclusive };
ScanMode m_scanmode;
enum ErrType { ErrNone = 0, ErrDeadlock, ErrOther };
ErrType m_errtype;
Con() :
m_ndb(0), m_dic(0), m_tx(0), m_op(0),
- m_scantx(0), m_scanop(0), m_scanmode(ScanNo), m_errtype(ErrNone) {}
+ m_scanop(0), m_indexscanop(0), m_resultset(0), m_scanmode(ScanNo), m_errtype(ErrNone) {}
int connect();
void disconnect();
int startTransaction();
int startBuddyTransaction(const Con& con);
int getNdbOperation(const Tab& tab);
- int getNdbOperation(const ITab& itab, const Tab& tab);
+ int getNdbScanOperation(const Tab& tab);
+ int getNdbScanOperation(const ITab& itab, const Tab& tab);
int equal(int num, const char* addr);
int getValue(int num, NdbRecAttr*& rec);
int setValue(int num, const char* addr);
@@ -648,9 +649,18 @@ Con::getNdbOperation(const Tab& tab)
}
int
-Con::getNdbOperation(const ITab& itab, const Tab& tab)
+Con::getNdbScanOperation(const Tab& tab)
{
- CHKCON((m_scanop = m_tx->getNdbIndexScanOperation(itab.m_name, tab.m_name)) != 0, *this);
+ assert(m_tx != 0);
+ CHKCON((m_op = m_scanop = m_tx->getNdbScanOperation(tab.m_name)) != 0, *this);
+ return 0;
+}
+
+int
+Con::getNdbScanOperation(const ITab& itab, const Tab& tab)
+{
+ assert(m_tx != 0);
+ CHKCON((m_op = m_scanop = m_indexscanop = m_tx->getNdbIndexScanOperation(itab.m_name, tab.m_name)) != 0, *this);
return 0;
}
@@ -682,7 +692,7 @@ int
Con::setBound(int num, int type, const void* value)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON(m_scanop->setBound(num, type, value) == 0, *this);
+ CHKCON(m_indexscanop->setBound(num, type, value) == 0, *this);
return 0;
}
@@ -698,7 +708,7 @@ int
Con::openScanRead(unsigned parallelism)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON((m_resultSet = m_scanop->readTuples(parallelism)) != 0, *this);
+ CHKCON((m_resultset = m_scanop->readTuples(parallelism)) != 0, *this);
return 0;
}
@@ -706,7 +716,7 @@ int
Con::openScanExclusive(unsigned parallelism)
{
assert(m_tx != 0 && m_op != 0);
- CHKCON((m_resultSet = m_scanop->readTuplesExclusive(parallelism)) != 0, *this);
+ CHKCON((m_resultset = m_scanop->readTuplesExclusive(parallelism)) != 0, *this);
return 0;
}
@@ -721,8 +731,8 @@ int
Con::nextScanResult()
{
int ret;
- assert(m_resultSet != 0);
- CHKCON((ret = m_resultSet->nextResult()) != -1, *this);
+ assert(m_resultset != 0);
+ CHKCON((ret = m_resultset->nextResult()) != -1, *this);
assert(ret == 0 || ret == 1);
return ret;
}
@@ -731,7 +741,7 @@ int
Con::takeOverForUpdate(Con& scan)
{
assert(m_tx != 0 && scan.m_op != 0);
- CHKCON((m_op = scan.m_resultSet->updateTuple(m_tx)) != 0, scan);
+ CHKCON((m_op = scan.m_resultset->updateTuple(m_tx)) != 0, scan);
return 0;
}
@@ -739,7 +749,7 @@ int
Con::takeOverForDelete(Con& scan)
{
assert(m_tx != 0 && scan.m_op != 0);
- CHKCON(scan.m_resultSet->deleteTuple(m_tx) == 0, scan);
+ CHKCON(scan.m_resultset->deleteTuple(m_tx) == 0, scan);
return 0;
}
@@ -1930,7 +1940,7 @@ scanreadtable(Par par)
LL3((par.m_verify ? "scanverify " : "scanread ") << tab.m_name);
Set set2(tab, set.m_rows);
CHK(con.startTransaction() == 0);
- CHK(con.getNdbOperation(tab) == 0);
+ CHK(con.getNdbScanOperation(tab) == 0);
CHK(con.openScanRead(par.m_scanrd) == 0);
set2.getval(par);
CHK(con.executeScan() == 0);
@@ -1963,7 +1973,7 @@ scanreadindex(Par par, const ITab& itab, const BSet& bset)
LL4(bset);
Set set2(tab, set.m_rows);
CHK(con.startTransaction() == 0);
- CHK(con.getNdbOperation(itab, tab) == 0);
+ CHK(con.getNdbScanOperation(itab, tab) == 0);
CHK(con.openScanRead(par.m_scanrd) == 0);
CHK(bset.setbnd(par) == 0);
set2.getval(par);
@@ -2030,7 +2040,7 @@ scanupdatetable(Par par)
LL3("scan update " << tab.m_name);
Set set2(tab, set.m_rows);
CHK(con.startTransaction() == 0);
- CHK(con.getNdbOperation(tab) == 0);
+ CHK(con.getNdbScanOperation(tab) == 0);
CHK(con.openScanExclusive(par.m_scanex) == 0);
set2.getval(par);
CHK(con.executeScan() == 0);
@@ -2075,7 +2085,7 @@ scanupdateindex(Par par, const ITab& itab, const BSet& bset)
LL3("scan update " << itab.m_name);
Set set2(tab, set.m_rows);
CHK(con.startTransaction() == 0);
- CHK(con.getNdbOperation(itab, tab) == 0);
+ CHK(con.getNdbScanOperation(itab, tab) == 0);
CHK(con.openScanExclusive(par.m_scanex) == 0);
CHK(bset.setbnd(par) == 0);
set2.getval(par);
From 1201a2e5990a4776e34d01e9757bdb55c86ab9cb Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 23 Jun 2004 14:11:35 +0200
Subject: [PATCH 023/579] Bug fixes, related to wl1671 & BUG#4230
---
ndb/src/kernel/blocks/dbtc/Dbtc.hpp | 3 +-
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 121 ++--
ndb/src/ndbapi/NdbApiSignal.cpp | 2 +-
ndb/src/ndbapi/NdbScanOperation.cpp | 17 +
ndb/test/include/HugoOperations.hpp | 47 +-
ndb/test/ndbapi/testScan.cpp | 51 +-
ndb/test/ndbapi/testTimeout.cpp | 10 +-
ndb/test/ndbapi/testTransactions.cpp | 9 +-
ndb/test/run-test/daily-basic-tests.txt | 767 ++++++++++++++++++++++++
ndb/test/run-test/daily-devel-tests.txt | 236 ++++++++
ndb/test/src/HugoOperations.cpp | 142 +----
11 files changed, 1126 insertions(+), 279 deletions(-)
create mode 100644 ndb/test/run-test/daily-basic-tests.txt
create mode 100644 ndb/test/run-test/daily-devel-tests.txt
diff --git a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
index 501cec1f231..d4979ad39c6 100644
--- a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
+++ b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
@@ -235,7 +235,6 @@ public:
enum ReturnSignal {
RS_NO_RETURN = 0,
RS_TCKEYCONF = 1,
- RS_TCKEYREF = 2,
RS_TC_COMMITCONF = 3,
RS_TCROLLBACKCONF = 4,
RS_TCROLLBACKREP = 5
@@ -699,7 +698,7 @@ public:
UintR lqhkeyreqrec;
AbortState abortState;
Uint32 buddyPtr;
- Uint8 unused;
+ Uint8 m_exec_flag;
Uint8 unused2;
Uint8 takeOverRec;
Uint8 currentReplicaNo;
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index 4f1e6cdd74c..051c6d7de27 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -1688,15 +1688,8 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
case 59:{
jam();
- const TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0];
- const Uint32 t1 = tcKeyReq->transId1;
- const Uint32 t2 = tcKeyReq->transId2;
- signal->theData[0] = apiConnectptr.p->ndbapiConnect;
- signal->theData[1] = t1;
- signal->theData[2] = t2;
- signal->theData[3] = ZABORTINPROGRESS;
- sendSignal(apiConnectptr.p->ndbapiBlockref,
- GSN_TCROLLBACKREP, signal, 4, JBB);
+ terrorCode = ZABORTINPROGRESS;
+ abortErrorLab(signal);
return;
}
@@ -2217,6 +2210,8 @@ void Dbtc::initApiConnectRec(Signal* signal,
UintR Ttransid0 = tcKeyReq->transId1;
UintR Ttransid1 = tcKeyReq->transId2;
+ regApiPtr->m_exec_flag = 0;
+ regApiPtr->returncode = 0;
regApiPtr->returnsignal = RS_TCKEYCONF;
regApiPtr->firstTcConnect = RNIL;
regApiPtr->lastTcConnect = RNIL;
@@ -2382,6 +2377,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
bool isIndexOp = regApiPtr->isIndexOp;
bool isIndexOpReturn = regApiPtr->indexOpReturn;
regApiPtr->isIndexOp = false; // Reset marker
+ regApiPtr->m_exec_flag |= TexecFlag;
switch (regApiPtr->apiConnectstate) {
case CS_CONNECTED:{
if (TstartFlag == 1 && getAllowStartTransaction() == true){
@@ -2390,6 +2386,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
//---------------------------------------------------------------------
jam();
initApiConnectRec(signal, regApiPtr);
+ regApiPtr->m_exec_flag = TexecFlag;
} else {
if(getAllowStartTransaction() == true){
/*------------------------------------------------------------------
@@ -2432,6 +2429,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
//--------------------------------------------------------------------
jam();
initApiConnectRec(signal, regApiPtr);
+ regApiPtr->m_exec_flag = TexecFlag;
} else if(TexecFlag) {
TCKEY_abort(signal, 59);
return;
@@ -5101,8 +5099,8 @@ void Dbtc::execTC_COMMITREQ(Signal* signal)
// We will abort it instead.
/*******************************************************************/
regApiPtr->returnsignal = RS_NO_RETURN;
- abort010Lab(signal);
errorCode = ZTRANS_STATUS_ERROR;
+ abort010Lab(signal);
}//if
} else {
jam();
@@ -5128,8 +5126,8 @@ void Dbtc::execTC_COMMITREQ(Signal* signal)
// transaction. We will abort it instead.
/***********************************************************************/
regApiPtr->returnsignal = RS_NO_RETURN;
- abort010Lab(signal);
errorCode = ZPREPAREINPROGRESS;
+ abort010Lab(signal);
break;
case CS_START_COMMITTING:
@@ -5661,7 +5659,10 @@ void Dbtc::abortErrorLab(Signal* signal)
return;
}
transP->returnsignal = RS_TCROLLBACKREP;
- transP->returncode = terrorCode;
+ if(transP->returncode == 0){
+ jam();
+ transP->returncode = terrorCode;
+ }
abort010Lab(signal);
}//Dbtc::abortErrorLab()
@@ -5989,7 +5990,8 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
/* FIND OUT WHAT WE NEED TO DO BASED ON THE STATE INFORMATION.*/
/*------------------------------------------------------------------*/
DEBUG("Time-out in state = " << apiConnectptr.p->apiConnectstate
- << " apiConnectptr.i = " << apiConnectptr.i);
+ << " apiConnectptr.i = " << apiConnectptr.i
+ << " - exec: " << apiConnectptr.p->m_exec_flag);
switch (apiConnectptr.p->apiConnectstate) {
case CS_STARTED:
if(apiConnectptr.p->lqhkeyreqrec == apiConnectptr.p->lqhkeyconfrec){
@@ -6003,11 +6005,8 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
jam();
return;
}//if
- apiConnectptr.p->returnsignal = RS_NO_RETURN;
- } else {
- jam();
- apiConnectptr.p->returnsignal = RS_TCROLLBACKREP;
}
+ apiConnectptr.p->returnsignal = RS_TCROLLBACKREP;
apiConnectptr.p->returncode = ZTIME_OUT_ERROR;
abort010Lab(signal);
return;
@@ -9385,9 +9384,9 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
return;
}
- if(!apiFail){
+ Uint32 ref = apiConnectptr.p->ndbapiBlockref;
+ if(!apiFail && ref){
jam();
- Uint32 ref = apiConnectptr.p->ndbapiBlockref;
ScanTabConf * conf = (ScanTabConf*)&signal->theData[0];
conf->apiConnectPtr = apiConnectptr.p->ndbapiConnect;
conf->requestInfo = ScanTabConf::EndOfData;
@@ -9395,7 +9394,7 @@ Dbtc::close_scan_req_send_conf(Signal* signal, ScanRecordPtr scanPtr){
conf->transId2 = apiConnectptr.p->transid[1];
sendSignal(ref, GSN_SCAN_TABCONF, signal, ScanTabConf::SignalLength, JBB);
}
-
+
releaseScanResources(scanPtr);
if(apiFail){
@@ -9926,48 +9925,52 @@ void Dbtc::releaseAbortResources(Signal* signal)
apiConnectptr.p->apiConnectstate = CS_ABORTING;
apiConnectptr.p->abortState = AS_IDLE;
- bool ok = false;
- Uint32 blockRef = apiConnectptr.p->ndbapiBlockref;
- switch(apiConnectptr.p->returnsignal){
- case RS_TCROLLBACKCONF:
+ if(apiConnectptr.p->m_exec_flag || apiConnectptr.p->apiFailState == ZTRUE){
jam();
- ok = true;
- signal->theData[0] = apiConnectptr.p->ndbapiConnect;
- signal->theData[1] = apiConnectptr.p->transid[0];
- signal->theData[2] = apiConnectptr.p->transid[1];
- sendSignal(blockRef, GSN_TCROLLBACKCONF, signal, 3, JBB);
- break;
- case RS_TCROLLBACKREP:{
- jam();
- ok = true;
- TcRollbackRep * const tcRollbackRep =
- (TcRollbackRep *) signal->getDataPtr();
-
- tcRollbackRep->connectPtr = apiConnectptr.p->ndbapiConnect;
- tcRollbackRep->transId[0] = apiConnectptr.p->transid[0];
- tcRollbackRep->transId[1] = apiConnectptr.p->transid[1];
- tcRollbackRep->returnCode = apiConnectptr.p->returncode;
- sendSignal(blockRef, GSN_TCROLLBACKREP, signal,
- TcRollbackRep::SignalLength, JBB);
- }
- break;
- case RS_NO_RETURN:
- jam();
- ok = true;
- break;
- case RS_TCKEYCONF:
- case RS_TCKEYREF:
- case RS_TC_COMMITCONF:
- break;
- }
- if(!ok){
- jam();
- ndbout_c("returnsignal = %d", apiConnectptr.p->returnsignal);
- sendSystemError(signal);
- }//if
+ bool ok = false;
+ Uint32 blockRef = apiConnectptr.p->ndbapiBlockref;
+ ReturnSignal ret = apiConnectptr.p->returnsignal;
+ apiConnectptr.p->returnsignal = RS_NO_RETURN;
+ apiConnectptr.p->m_exec_flag = 0;
+ switch(ret){
+ case RS_TCROLLBACKCONF:
+ jam();
+ ok = true;
+ signal->theData[0] = apiConnectptr.p->ndbapiConnect;
+ signal->theData[1] = apiConnectptr.p->transid[0];
+ signal->theData[2] = apiConnectptr.p->transid[1];
+ sendSignal(blockRef, GSN_TCROLLBACKCONF, signal, 3, JBB);
+ break;
+ case RS_TCROLLBACKREP:{
+ jam();
+ ok = true;
+ TcRollbackRep * const tcRollbackRep =
+ (TcRollbackRep *) signal->getDataPtr();
+
+ tcRollbackRep->connectPtr = apiConnectptr.p->ndbapiConnect;
+ tcRollbackRep->transId[0] = apiConnectptr.p->transid[0];
+ tcRollbackRep->transId[1] = apiConnectptr.p->transid[1];
+ tcRollbackRep->returnCode = apiConnectptr.p->returncode;
+ sendSignal(blockRef, GSN_TCROLLBACKREP, signal,
+ TcRollbackRep::SignalLength, JBB);
+ }
+ break;
+ case RS_NO_RETURN:
+ jam();
+ ok = true;
+ break;
+ case RS_TCKEYCONF:
+ case RS_TC_COMMITCONF:
+ break;
+ }
+ if(!ok){
+ jam();
+ ndbout_c("returnsignal = %d", apiConnectptr.p->returnsignal);
+ sendSystemError(signal);
+ }//if
+ }
setApiConTimer(apiConnectptr.i, 0, __LINE__);
- apiConnectptr.p->abortState = AS_IDLE;
if (apiConnectptr.p->apiFailState == ZTRUE) {
jam();
handleApiFailState(signal, apiConnectptr.i);
diff --git a/ndb/src/ndbapi/NdbApiSignal.cpp b/ndb/src/ndbapi/NdbApiSignal.cpp
index d173a462020..4dc9bfb6fce 100644
--- a/ndb/src/ndbapi/NdbApiSignal.cpp
+++ b/ndb/src/ndbapi/NdbApiSignal.cpp
@@ -162,7 +162,7 @@ NdbApiSignal::setSignal(int aNdbSignalType)
theTrace = TestOrd::TraceAPI;
theReceiversBlockNumber = DBTC;
theVerId_signalNumber = GSN_TCROLLBACKREQ;
- theLength = 5;
+ theLength = 3;
}
break;
diff --git a/ndb/src/ndbapi/NdbScanOperation.cpp b/ndb/src/ndbapi/NdbScanOperation.cpp
index efc167cbc5e..edecb5855e1 100644
--- a/ndb/src/ndbapi/NdbScanOperation.cpp
+++ b/ndb/src/ndbapi/NdbScanOperation.cpp
@@ -665,6 +665,23 @@ void NdbScanOperation::closeScan()
break;
}
+ while(m_sent_receivers_count){
+ theNdb->theWaiter.m_node = nodeId;
+ theNdb->theWaiter.m_state = WAIT_SCAN;
+ int return_code = theNdb->receiveResponse(WAITFOR_SCAN_TIMEOUT);
+ switch(return_code){
+ case 0:
+ break;
+ case -1:
+ setErrorCode(4008);
+ case -2:
+ m_api_receivers_count = 0;
+ m_conf_receivers_count = 0;
+ m_sent_receivers_count = 0;
+ theNdbCon->theReleaseOnClose = true;
+ }
+ }
+
if(m_api_receivers_count+m_conf_receivers_count){
// Send close scan
send_next_scan(0, true); // Close scan
diff --git a/ndb/test/include/HugoOperations.hpp b/ndb/test/include/HugoOperations.hpp
index 7295b72b18f..37e53e322c8 100644
--- a/ndb/test/include/HugoOperations.hpp
+++ b/ndb/test/include/HugoOperations.hpp
@@ -57,11 +57,10 @@ public:
int pkDeleteRecord(Ndb*,
int recordNo,
int numRecords = 1);
-
- int scanReadRecords(Ndb* pNdb,
- Uint32 parallelism = 240, ScanLock lock = SL_Read);
- int executeScanRead(Ndb*);
+ NdbResultSet* scanReadRecords(Ndb* pNdb, ScanLock lock = SL_Read);
+ int readTuples(NdbResultSet*);
+
int execute_Commit(Ndb*,
AbortOption ao = AbortOnError);
int execute_NoCommit(Ndb*,
@@ -104,46 +103,6 @@ protected:
Vector savedRecords;
private:
NdbConnection* pTrans;
-
- struct ScanTmp {
- ScanTmp() {
- pTrans = 0;
- m_tmpRow = 0;
- m_delete = true;
- m_op = DONE;
- }
- ScanTmp(NdbConnection* a, NDBT_ResultRow* b){
- pTrans = a;
- m_tmpRow = b;
- m_delete = true;
- m_op = DONE;
- }
- ScanTmp(const ScanTmp& org){
- * this = org;
- }
- ScanTmp& operator=(const ScanTmp& org){
- pTrans = org.pTrans;
- m_tmpRow = org.m_tmpRow;
- m_delete = org.m_delete;
- m_op = org.m_op;
- return * this;
- }
-
- ~ScanTmp() {
- if(m_delete && pTrans)
- pTrans->close();
- if(m_delete && m_tmpRow)
- delete m_tmpRow;
- }
-
- NdbConnection * pTrans;
- NDBT_ResultRow * m_tmpRow;
- bool m_delete;
- enum { DONE, READ, UPDATE, DELETE } m_op;
- };
- Vector m_scans;
- int run(ScanTmp & tmp);
-
};
#endif
diff --git a/ndb/test/ndbapi/testScan.cpp b/ndb/test/ndbapi/testScan.cpp
index 55ee6bc2b78..97eb1691552 100644
--- a/ndb/test/ndbapi/testScan.cpp
+++ b/ndb/test/ndbapi/testScan.cpp
@@ -809,58 +809,11 @@ int runExecuteScanWithoutOpenScan(NDBT_Context* ctx, NDBT_Step* step){
}
int runOnlyOneOpBeforeOpenScan(NDBT_Context* ctx, NDBT_Step* step){
- const NdbDictionary::Table* pTab = ctx->getTab();
- int records = ctx->getNumRecords();
- int numFailed = 0;
-
- ScanFunctions scanF(*pTab);
- if (scanF.scanReadFunctions(GETNDB(step),
- records,
- 6,
- ScanFunctions::OnlyOneOpBeforeOpenScan,
- false) == 0){
- numFailed++;
- }
- if (scanF.scanReadFunctions(GETNDB(step),
- records,
- 6,
- ScanFunctions::OnlyOneOpBeforeOpenScan,
- true) == 0){
- numFailed++;
- }
-
- if(numFailed > 0)
- return NDBT_FAILED;
- else
return NDBT_OK;
-
}
+
int runOnlyOneScanPerTrans(NDBT_Context* ctx, NDBT_Step* step){
- const NdbDictionary::Table* pTab = ctx->getTab();
- int records = ctx->getNumRecords();
- int numFailed = 0;
-
- ScanFunctions scanF(*pTab);
- if (scanF.scanReadFunctions(GETNDB(step),
- records,
- 6,
- ScanFunctions::OnlyOneScanPerTrans,
- false) == 0){
- numFailed++;
- }
- if (scanF.scanReadFunctions(GETNDB(step),
- records,
- 6,
- ScanFunctions::OnlyOneScanPerTrans,
- true) == 0){
- numFailed++;
- }
-
- if(numFailed > 0)
- return NDBT_FAILED;
- else
- return NDBT_OK;
-
+ return NDBT_OK;
}
int runNoCloseTransaction(NDBT_Context* ctx, NDBT_Step* step){
diff --git a/ndb/test/ndbapi/testTimeout.cpp b/ndb/test/ndbapi/testTimeout.cpp
index ba6b53df9a9..d37c58f7ea6 100644
--- a/ndb/test/ndbapi/testTimeout.cpp
+++ b/ndb/test/ndbapi/testTimeout.cpp
@@ -206,7 +206,7 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
// Expect that transaction has timed-out
res = hugoOps.execute_Commit(pNdb);
- if(op1 != 0 && res != 237){
+ if(op1 != 0 && res != 266){
g_err << stepNo << ": Fail: " << res << "!= 237, op1="
<< op1 << ", op2=" << op2 << endl;
return NDBT_FAILED;
@@ -299,9 +299,11 @@ int runBuddyTransNoTimeout(NDBT_Context* ctx, NDBT_Step* step){
for (int i = 0; i < 10; i++){
// Perform buddy scan reads
- CHECK(hugoOps.scanReadRecords(pNdb) == 0);
- CHECK(hugoOps.executeScanRead(pNdb) == 0);
-
+ NdbResultSet* rs = 0;
+ CHECK((rs = hugoOps.scanReadRecords(pNdb)) != 0);
+ CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
+ CHECK(hugoOps.readTuples(rs) == 0);
+
int sleep = myRandom48(maxSleep);
ndbout << "Sleeping for " << sleep << " milliseconds" << endl;
NdbSleep_MilliSleep(sleep);
diff --git a/ndb/test/ndbapi/testTransactions.cpp b/ndb/test/ndbapi/testTransactions.cpp
index 9ce928f8736..7b4bb60cdf7 100644
--- a/ndb/test/ndbapi/testTransactions.cpp
+++ b/ndb/test/ndbapi/testTransactions.cpp
@@ -204,11 +204,14 @@ runOp(HugoOperations & hugoOps,
} else if(strcmp(op, "DELETE") == 0){
C2(hugoOps.pkDeleteRecord(pNdb, 1, 1) == 0);
} else if(strcmp(op, "SCAN") == 0){
- C2(hugoOps.scanReadRecords(pNdb) == 0);
+ abort();
+ //C2(hugoOps.scanReadRecords(pNdb) == 0);
} else if(strcmp(op, "SCAN-HL") == 0){
- C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_ReadHold) == 0);
+ abort();
+ //C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_ReadHold)== 0);
} else if(strcmp(op, "SCAN-EX") == 0){
- C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_Exclusive) == 0);
+ abort();
+ //C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_Exclusive)== 0);
} else {
g_err << __FILE__ << " - " << __LINE__
<< ": Unknown operation" << op << endl;
diff --git a/ndb/test/run-test/daily-basic-tests.txt b/ndb/test/run-test/daily-basic-tests.txt
new file mode 100644
index 00000000000..f64c1c3f8ba
--- /dev/null
+++ b/ndb/test/run-test/daily-basic-tests.txt
@@ -0,0 +1,767 @@
+# BASIC FUNCTIONALITY
+max-time: 500
+cmd: testBasic
+args: -n PkRead
+
+max-time: 500
+cmd: testBasic
+args: -n PkUpdate
+
+max-time: 500
+cmd: testBasic
+args: -n PkDelete
+
+max-time: 500
+cmd: testBasic
+args: -n PkInsert
+
+max-time: 600
+cmd: testBasic
+args: -n UpdateAndRead
+
+max-time: 500
+cmd: testBasic
+args: -n PkReadAndLocker T6
+
+max-time: 500
+cmd: testBasic
+args: -n PkReadAndLocker2 T6
+
+max-time: 500
+cmd: testBasic
+args: -n PkReadUpdateAndLocker T6
+
+max-time: 500
+cmd: testBasic
+args: -n ReadWithLocksAndInserts T6
+
+max-time: 500
+cmd: testBasic
+args: -n PkInsertTwice T1 T6 T10
+
+max-time: 1500
+cmd: testBasic
+args: -n Fill T1
+
+max-time: 1500
+cmd: testBasic
+args: -n Fill T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommitSleep T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommit626 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommitAndClose T6
+
+max-time: 500
+cmd: testBasic
+args: -n Commit626 T6
+
+max-time: 500
+cmd: testBasic
+args: -n CommitTry626 T6
+
+max-time: 500
+cmd: testBasic
+args: -n CommitAsMuch626 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommit626 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommitRollback626 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n Commit630 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n CommitTry630 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n CommitAsMuch630 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommit630 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommitRollback630 T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n NoCommitAndClose T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n RollbackUpdate T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n RollbackDeleteMultiple T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n ImplicitRollbackDelete T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n CommitDelete T1 T6
+
+max-time: 500
+cmd: testBasic
+args: -n RollbackNothing T1 T6
+
+max-time: 500
+cmd: testBasicAsynch
+args: -n PkInsertAsynch
+
+max-time: 500
+cmd: testBasicAsynch
+args: -n PkReadAsynch
+
+max-time: 500
+cmd: testBasicAsynch
+args: -n PkUpdateAsynch
+
+max-time: 500
+cmd: testBasicAsynch
+args: -n PkDeleteAsynch
+
+max-time: 500
+cmd: testBasic
+args: -n MassiveRollback T1 T6 T13
+
+max-time: 500
+cmd: testBasic
+args: -n MassiveRollback2 T1 T6 T13
+
+#-m 500 1: testBasic -n ReadConsistency T6
+cmd: testTimeout
+args: -n DontTimeoutTransaction T1
+
+cmd: testTimeout
+args: -n DontTimeoutTransaction5 T1
+
+cmd: testTimeout
+args: -n TimeoutTransaction T1
+
+cmd: testTimeout
+args: -n TimeoutTransaction5 T1
+
+cmd: testTimeout
+args: -n BuddyTransNoTimeout T1
+
+cmd: testTimeout
+args: -n BuddyTransNoTimeout5 T1
+
+#
+# SCAN TESTS
+#
+max-time: 500
+cmd: testScan
+args: -n ScanRead16
+
+max-time: 500
+cmd: testScan
+args: -n ScanRead240
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadCommitted240
+
+max-time: 500
+cmd: testScan
+args: -n ScanUpdate
+
+max-time: 500
+cmd: testScan
+args: -n ScanUpdate2 T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanDelete
+
+max-time: 500
+cmd: testScan
+args: -n ScanDelete2 T10
+
+max-time: 500
+cmd: testScan
+args: -n ScanUpdateAndScanRead T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadAndLocker T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadAndPkRead T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanRead488 -l 10 T6
+
+max-time: 600
+cmd: testScan
+args: -n ScanRead40 -l 100 T2
+
+max-time: 1800
+cmd: testScan
+args: -n ScanRead100 -l 100 T1
+
+max-time: 600
+cmd: testScan
+args: -n ScanRead40 -l 100 T1
+
+max-time: 1800
+cmd: testScan
+args: -n ScanRead40RandomTable -l 100 T1
+
+max-time: 3600
+cmd: testScan
+args: -n ScanRead40RandomTable -l 1000 T2
+
+max-time: 500
+cmd: testScan
+args: -n ScanWithLocksAndInserts T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadAbort T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadAbort15 T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadAbort240 T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanUpdateAbort16 T6
+
+max-time: 3600
+cmd: testScan
+args: -n ScanReadRestart T1 T6 T13
+
+max-time: 500
+cmd: testScan
+args: -n ScanUpdateRestart T6
+
+max-time: 500
+cmd: testScan
+args: -n CheckGetValue T6
+
+max-time: 500
+cmd: testScan
+args: -n CloseWithoutStop T6
+
+max-time: 500
+cmd: testScan
+args: -n NextScanWhenNoMore T6
+
+max-time: 500
+cmd: testScan
+args: -n ExecuteScanWithoutOpenScan T6
+
+max-time: 500
+cmd: testScan
+args: -n OnlyOpenScanOnce T6
+
+max-time: 500
+cmd: testScan
+args: -n OnlyOneOpInScanTrans T6
+
+max-time: 500
+cmd: testScan
+args: -n OnlyOneOpBeforeOpenScan T6
+
+max-time: 500
+cmd: testScan
+args: -n OnlyOneScanPerTrans T6
+
+max-time: 500
+cmd: testScan
+args: -n NoCloseTransaction T6
+
+max-time: 500
+cmd: testScan
+args: -n CheckInactivityTimeOut T6
+
+max-time: 500
+cmd: testScan
+args: -n CheckInactivityBeforeClose T6
+
+max-time: 500
+cmd: testScan
+args: -n CheckAfterTerror T6
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadError5021 T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReaderror5022 T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadError5023 T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadError5024 T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadError5025 T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadError5030 T1
+
+# OLD FLEX
+max-time: 500
+cmd: flexBench
+args: -c 25 -t 10
+
+max-time: 500
+cmd: flexHammer
+args: -r 5 -t 32
+
+#
+# DICT TESTS
+max-time: 1500
+cmd: testDict
+args: -n CreateAndDrop
+
+max-time: 1500
+cmd: testDict
+args: -n CreateAndDropWithData
+
+max-time: 1500
+cmd: testDict
+args: -n CreateAndDropDuring T6 T10
+
+max-time: 1500
+cmd: testDict
+args: -n CreateInvalidTables
+
+max-time: 1500
+cmd: testDict
+args: -n CreateTableWhenDbIsFull T6
+
+max-time: 1500
+cmd: testDict
+args: -n CreateMaxTables T6
+
+max-time: 500
+cmd: testDict
+args: -n FragmentTypeSingle T1
+
+max-time: 1500
+cmd: testDict
+args: -n FragmentTypeAll T1 T6 T7 T8
+
+max-time: 1500
+cmd: testDict
+args: -n FragmentTypeAllLarge T1 T6 T7 T8
+
+max-time: 1500
+cmd: testDict
+args: -n TemporaryTables T1 T6 T7 T8
+
+#
+# TEST NDBAPI
+#
+max-time: 500
+cmd: testDataBuffers
+args:
+
+# Testsuite: testNdbApi
+# Number of tests: 5
+max-time: 500
+cmd: testNdbApi
+args: -n MaxNdb T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n MaxTransactions T1 T6 T7 T8 T13
+
+max-time: 500
+cmd: testNdbApi
+args: -n MaxOperations T1 T6 T7 T8 T13
+
+max-time: 500
+cmd: testNdbApi
+args: -n MaxGetValue T1 T6 T7 T8 T13
+
+max-time: 500
+cmd: testNdbApi
+args: -n MaxEqual
+
+max-time: 500
+cmd: testNdbApi
+args: -n DeleteNdb T1 T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n WaitUntilReady T1 T6 T7 T8 T13
+
+max-time: 500
+cmd: testNdbApi
+args: -n GetOperationNoTab T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n NdbErrorOperation T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n MissingOperation T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n GetValueInUpdate T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n UpdateWithoutKeys T6
+
+max-time: 500
+cmd: testNdbApi
+args: -n UpdateWithoutValues T6
+
+max-time: 500
+cmd: testInterpreter
+args: T1
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadRead
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadRead
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExRead
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertRead
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateRead
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteRead
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteReadEx
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteInsert
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteUpdate
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteDelete
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadDirtyRead
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n FReadDirtyRead
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n ReadExDirtyRead
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n InsertDirtyRead
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n UpdateDirtyRead
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteSimpleRead
+
+max-time: 1500
+cmd: testOperations
+args: -n DeleteDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteDirtyRead
+
+max-time: 1500
+cmd: testRestartGci
+args: T6
+
+max-time: 300
+cmd: testBlobs
+args:
+
diff --git a/ndb/test/run-test/daily-devel-tests.txt b/ndb/test/run-test/daily-devel-tests.txt
new file mode 100644
index 00000000000..e967de2aea3
--- /dev/null
+++ b/ndb/test/run-test/daily-devel-tests.txt
@@ -0,0 +1,236 @@
+#
+# INDEX
+#
+max-time: 1500
+cmd: testIndex
+args: -n CreateAll
+
+#-m 7200 1: testIndex -n InsertDeleteGentle T7
+max-time: 3600
+cmd: testIndex
+args: -n InsertDelete T1 T10
+
+#-m 3600 1: testIndex -n CreateLoadDropGentle T7
+max-time: 3600
+cmd: testIndex
+args: -n CreateLoadDrop T1 T10
+
+#
+# BACKUP
+#
+max-time: 600
+cmd: testBackup
+args: -n BackupOne
+
+max-time: 600
+cmd: testBackup
+args: -n BackupBank T6
+
+#
+# MGMAPI AND MGSRV
+#
+max-time: 1800
+cmd: testMgm
+args: -n SingleUserMode T1
+
+#
+#
+# SYSTEM RESTARTS
+#
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR1 T1
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR1 T6
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR1 T7
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR1 T8
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR2 T1
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR2 T6
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR2 T7
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR_UNDO T1
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR_UNDO T6
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR_UNDO T7
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR_UNDO T8
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR3 T6
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR4 T6
+
+#
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR_FULLDB T1
+
+#
+# NODE RESTARTS
+#
+max-time: 2500
+cmd: testNodeRestart
+args: -n NoLoad T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n PkRead T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -l 1 -n PkReadPkUpdate
+
+max-time: 2500
+cmd: testNodeRestart
+args: -l 1 -n ReadUpdateScan
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n Terror T6 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n FullDb T6 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartRandomNode T6 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartRandomNodeError T6 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartRandomNodeInitial T6 T13
+
+max-time: 3600
+cmd: testNodeRestart
+args: -l 1 -n RestartNFDuringNR T6 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartMasterNodeError T6 T8 T13
+
+max-time: 3600
+cmd: testNodeRestart
+args: -n RestartNodeDuringLCP T6
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n TwoNodeFailure T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n TwoMasterNodeFailure T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n FiftyPercentFail T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartAllNodes T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartAllNodesAbort T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n RestartAllNodesError9999 T6 T8 T13
+
+max-time: 2500
+cmd: testNodeRestart
+args: -n FiftyPercentStopAndWait T6 T8 T13
+
+max-time: 500
+cmd: testNodeRestart
+args: -n StopOnError T1
+
+#
+max-time: 2500
+cmd: testIndex
+args: -n NFNR1 T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n NFNR2 T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n NFNR3 T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n BuildDuring T6
+
+max-time: 2500
+cmd: testIndex
+args: -l 2 -n SR1 T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n NFNR1_O T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n NFNR2_O T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n NFNR3_O T6 T13
+
+max-time: 2500
+cmd: testIndex
+args: -n BuildDuring_O T6
+
+max-time: 2500
+cmd: testIndex
+args: -l 2 -n SR1_O T6 T13
+
+max-time: 500
+cmd: testIndex
+args: -n MixedTransaction T1
+
+max-time: 2500
+cmd: testDict
+args: -n NF1 T1 T6 T13
+
+max-time: 2500
+cmd: test_event
+args: -n BasicEventOperation T1 T6
+
+max-time: 2500
+cmd: testOIBasic
+args:
+
diff --git a/ndb/test/src/HugoOperations.cpp b/ndb/test/src/HugoOperations.cpp
index f4b814adee2..d5dbf1388d1 100644
--- a/ndb/test/src/HugoOperations.cpp
+++ b/ndb/test/src/HugoOperations.cpp
@@ -292,91 +292,61 @@ int HugoOperations::pkDeleteRecord(Ndb* pNdb,
return NDBT_OK;
}
-int HugoOperations::scanReadRecords(Ndb* pNdb,
- Uint32 parallelism, ScanLock lock){
-
-#ifdef JONAS_NOT_DONE
- NdbConnection * pCon = pNdb->hupp(pTrans);
+NdbResultSet*
+HugoOperations::scanReadRecords(Ndb* pNdb, ScanLock lock){
+
NDBT_ResultRow * m_tmpRow = new NDBT_ResultRow(tab);
- ScanTmp tmp(pCon, m_tmpRow);
- tmp.m_op = ScanTmp::READ;
- NdbOperation* pOp = pCon->getNdbOperation(tab.getName());
+ NdbScanOperation* pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
- ERR(pCon->getNdbError());
- return NDBT_FAILED;
+ ERR(pTrans->getNdbError());
+ return 0;
}
+
int check = 0;
+ NdbResultSet * rs = 0;
switch(lock){
case SL_ReadHold:
- check = pOp->openScanReadHoldLock(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Read, 1, 1);
break;
case SL_Exclusive:
- check = pOp->openScanExclusive(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, 1, 1);
break;
case SL_Read:
default:
- check = pOp->openScanRead(parallelism);
+ rs = pOp->readTuples(NdbScanOperation::LM_Dirty, 1, 1);
}
- if( check == -1 ) {
- ERR(pCon->getNdbError());
- return NDBT_FAILED;
+ if( rs == 0) {
+ ERR(pTrans->getNdbError());
+ return 0;
}
check = pOp->interpret_exit_ok();
if( check == -1 ) {
- ERR(pCon->getNdbError());
- return NDBT_FAILED;
+ ERR(pTrans->getNdbError());
+ return 0;
}
// Define attributes to read
for(int a = 0; aattributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
- ERR(pCon->getNdbError());
- return NDBT_FAILED;
+ ERR(pTrans->getNdbError());
+ return 0;
}
}
-
- check = tmp.pTrans->executeScan();
- if( check == -1 ) {
- NdbError err = tmp.pTrans->getNdbError();
- ERR(err);
- return err.code;
- }
-
- tmp.m_delete = false;
- m_scans.push_back(tmp);
-
- return 0;
-#endif
+ return rs;
}
-int HugoOperations::executeScanRead(Ndb* pNdb){
-
- int check = 0;
- for(Uint32 i = 0; inextResult()) == 0){
}
- while(m_scans.size() > 0){
- ScanTmp & tmp = m_scans[m_scans.size() - 1];
- if(tmp.m_op != ScanTmp::DONE)
- abort();
-
- tmp.pTrans->close();
- delete tmp.m_tmpRow;
- m_scans.erase(m_scans.size() - 1);
- }
- if(check != 0){
- return check;
- }
-
+ if(res != 1)
+ return NDBT_FAILED;
return NDBT_OK;
}
@@ -384,19 +354,6 @@ int HugoOperations::execute_Commit(Ndb* pNdb,
AbortOption eao){
int check = 0;
- while(m_scans.size() > 0){
- ScanTmp & tmp = m_scans[m_scans.size() - 1];
- if(tmp.m_op != ScanTmp::DONE)
- abort();
-
- tmp.pTrans->close();
- delete tmp.m_tmpRow;
- m_scans.erase(m_scans.size() - 1);
- }
- if(check != 0){
- return check;
- }
-
check = pTrans->execute(Commit, eao);
if( check == -1 ) {
@@ -414,54 +371,9 @@ int HugoOperations::execute_Commit(Ndb* pNdb,
return NDBT_OK;
}
-int
-HugoOperations::run(ScanTmp & tmp){
-#if JONAS_NOT_DONE
- int count = 0;
- if(tmp.m_op == ScanTmp::DONE)
- abort();
-
- int eof = tmp.pTrans->nextScanResult(true) ;
- while(eof == 0){
- count++;
- switch(tmp.m_op){
- case ScanTmp::READ:
- case ScanTmp::UPDATE:
- case ScanTmp::DELETE:
- break;
- case ScanTmp::DONE:
- abort();
- }
- rows.push_back(tmp.m_tmpRow->clone());
- eof = tmp.pTrans->nextScanResult(false);
- }
-
- tmp.m_op = ScanTmp::DONE;
- if (eof == -1) {
- deallocRows();
- NdbError err = tmp.pTrans->getNdbError();
- ERR(err);
- return err.code;
- }
-
- if(count == 0)
- return 626;
-#endif
-
- return 0;
-}
-
int HugoOperations::execute_NoCommit(Ndb* pNdb, AbortOption eao){
int check;
- for(Uint32 i = 0; iexecute(NoCommit, eao);
if( check == -1 ) {
@@ -701,10 +613,6 @@ HugoOperations::refresh() {
NdbConnection* t = getTransaction();
if(t)
t->refresh();
- for(Uint32 i = 0; irefresh();
- }
}
int HugoOperations::indexReadRecords(Ndb*, const char * idxName, int recordNo,
From f53d8a8286fbf52a2737e99602b2091239706057 Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 23 Jun 2004 15:34:18 +0200
Subject: [PATCH 024/579] wl1292 Move atrt install-path to mysql-test/ndb
---
ndb/test/run-test/Makefile.am | 20 ++++++++++----------
1 file changed, 10 insertions(+), 10 deletions(-)
diff --git a/ndb/test/run-test/Makefile.am b/ndb/test/run-test/Makefile.am
index 3dd9632ce4b..04be35325db 100644
--- a/ndb/test/run-test/Makefile.am
+++ b/ndb/test/run-test/Makefile.am
@@ -1,18 +1,18 @@
-ndbtest_PROGRAMS = atrt
-
-atrt_SOURCES = main.cpp
-
-ndbtest_SCRIPTS = atrt-analyze-result.sh atrt-gather-result.sh atrt-setup.sh \
- atrt-clear-result.sh make-config.sh make-index.sh make-html-reports.sh
-EXTRA_DIST = $(ndbtest_SCRIPTS)
-
-INCLUDES_LOC = -I$(top_srcdir)/ndb/src/mgmclient
-LDADD_LOC = $(top_builddir)/ndb/src/mgmclient/CpcClient.o $(top_builddir)/ndb/src/libndbclient.la
+testdir=$(prefix)/mysql-test/ndb
include $(top_srcdir)/ndb/config/common.mk.am
include $(top_srcdir)/ndb/config/type_util.mk.am
include $(top_srcdir)/ndb/config/type_mgmapiclient.mk.am
+test_PROGRAMS = atrt
+test_DATA=daily-basic-tests.txt daily-devel-tests.txt
+test_SCRIPTS=atrt-analyze-result.sh atrt-gather-result.sh atrt-setup.sh \
+ atrt-clear-result.sh make-config.sh make-index.sh make-html-reports.sh
+
+atrt_SOURCES = main.cpp
+INCLUDES_LOC = -I$(top_srcdir)/ndb/src/mgmclient
+LDADD_LOC = $(top_builddir)/ndb/src/mgmclient/CpcClient.o $(top_builddir)/ndb/src/libndbclient.la
+
# Don't update the files from bitkeeper
%::SCCS/s.%
From 432020a18d8f0987e92b89fac2e0bd4cf4013a14 Mon Sep 17 00:00:00 2001
From: "mskold@mysql.com" <>
Date: Wed, 23 Jun 2004 15:34:45 +0200
Subject: [PATCH 025/579] Modified ndbcluster_print_error to stack allocate
table and handler, NOT for review, will make patch instead
---
mysql-test/r/ndb_transaction.result | 228 +++++++++++++++++++++
mysql-test/t/ndb_transaction.test | 300 ++++++++++++++++++++++++++++
sql/ha_ndbcluster.cc | 37 +---
3 files changed, 539 insertions(+), 26 deletions(-)
create mode 100644 mysql-test/r/ndb_transaction.result
create mode 100644 mysql-test/t/ndb_transaction.test
diff --git a/mysql-test/r/ndb_transaction.result b/mysql-test/r/ndb_transaction.result
new file mode 100644
index 00000000000..886fc0f71a0
--- /dev/null
+++ b/mysql-test/r/ndb_transaction.result
@@ -0,0 +1,228 @@
+DROP TABLE IF EXISTS t1,t2,t3,t4,t5,t6,t7;
+CREATE TABLE t1 (
+pk1 INT NOT NULL PRIMARY KEY,
+attr1 INT NOT NULL
+) ENGINE=ndbcluster;
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 1
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+attr1
+2
+rollback;
+select count(*) from t1;
+count(*)
+0
+select * from t1 where pk1 = 1;
+pk1 attr1
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+attr1
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+commit;
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 1
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+attr1
+2
+begin;
+update t1 set attr1 = attr1 * 2;
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 2
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+2 4 1 2
+rollback;
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 1
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+begin;
+update t1 set attr1 = attr1 * 2;
+commit;
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 2
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+2 4 1 2
+begin;
+delete from t1 where attr1 = 2;
+select count(*) from t1;
+count(*)
+1
+select * from t1 where pk1 = 1;
+pk1 attr1
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+rollback;
+select count(*) from t1;
+count(*)
+2
+select * from t1 where pk1 = 1;
+pk1 attr1
+1 2
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+2 4 1 2
+begin;
+delete from t1 where attr1 = 2;
+commit;
+select count(*) from t1;
+count(*)
+1
+select * from t1 where pk1 = 1;
+pk1 attr1
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+pk1 attr1 pk1 attr1
+DROP TABLE t1;
+CREATE TABLE t1 (id INT, id2 int) engine=ndbcluster;
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+select sum(id) from t1;
+sum(id)
+3
+select * from t1 where id = 1;
+id id2
+1 1
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+id
+2
+rollback;
+select sum(id) from t1;
+sum(id)
+NULL
+select * from t1 where id = 1;
+id id2
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+id
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+commit;
+select sum(id) from t1;
+sum(id)
+3
+select * from t1 where id = 1;
+id id2
+1 1
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+id
+2
+begin;
+update t1 set id = id * 2;
+select sum(id) from t1;
+sum(id)
+6
+select * from t1 where id = 2;
+id id2
+2 1
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+id id2 id id2
+4 2 2 1
+rollback;
+select sum(id) from t1;
+sum(id)
+3
+select * from t1 where id = 2;
+id id2
+2 2
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+id id2 id id2
+begin;
+update t1 set id = id * 2;
+commit;
+select sum(id) from t1;
+sum(id)
+6
+select * from t1 where id = 2;
+id id2
+2 1
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+id id2 id id2
+4 2 2 1
+DROP TABLE t1;
+CREATE TABLE t2 (
+a bigint unsigned NOT NULL PRIMARY KEY,
+b int unsigned not null,
+c int unsigned
+) engine=ndbcluster;
+CREATE TABLE t3 (
+a bigint unsigned NOT NULL,
+b bigint unsigned not null,
+c bigint unsigned,
+PRIMARY KEY(a)
+) engine=ndbcluster;
+CREATE TABLE t4 (
+a bigint unsigned NOT NULL,
+b bigint unsigned not null,
+c bigint unsigned NOT NULL,
+d int unsigned,
+PRIMARY KEY(a, b, c)
+) engine=ndbcluster;
+select count(*) from t2;
+count(*)
+0
+select count(*) from t3;
+count(*)
+0
+select count(*) from t4;
+count(*)
+0
+ERROR HY000: Lock wait timeout exceeded; try restarting transaction
+select count(*) from t2;
+count(*)
+0
+select count(*) from t3;
+count(*)
+0
+select count(*) from t4;
+count(*)
+0
+ERROR HY000: Lock wait timeout exceeded; try restarting transaction
+select count(*) from t2;
+count(*)
+0
+select count(*) from t3;
+count(*)
+0
+select count(*) from t4;
+count(*)
+0
+select count(*) from t2;
+count(*)
+100
+select count(*) from t3;
+count(*)
+100
+select count(*) from t4;
+count(*)
+100
+begin;
+begin;
+drop table t2;
+drop table t3;
+drop table t4;
diff --git a/mysql-test/t/ndb_transaction.test b/mysql-test/t/ndb_transaction.test
new file mode 100644
index 00000000000..6423f4456c6
--- /dev/null
+++ b/mysql-test/t/ndb_transaction.test
@@ -0,0 +1,300 @@
+-- source include/have_ndb.inc
+
+--disable_warnings
+DROP TABLE IF EXISTS t1,t2,t3,t4,t5,t6,t7;
+--enable_warnings
+
+#
+# Transactionc test to show that the NDB
+# table handler is working properly with
+# transactions
+#
+
+#
+# Create a normal table with primary key
+#
+CREATE TABLE t1 (
+ pk1 INT NOT NULL PRIMARY KEY,
+ attr1 INT NOT NULL
+) ENGINE=ndbcluster;
+
+# insert
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+rollback;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+commit;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select t1.attr1 from t1, t1 as t1x where t1.pk1 = t1x.pk1 + 1;
+
+# update
+begin;
+update t1 set attr1 = attr1 * 2;
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+rollback;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+
+begin;
+update t1 set attr1 = attr1 * 2;
+commit;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+
+# delete
+begin;
+delete from t1 where attr1 = 2;
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+rollback;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+
+begin;
+delete from t1 where attr1 = 2;
+commit;
+
+select count(*) from t1;
+select * from t1 where pk1 = 1;
+select * from t1, t1 as t1x where t1x.attr1 = t1.attr1 - 2;
+
+DROP TABLE t1;
+
+#
+# Create table without primary key
+# a hidden primary key column is created by handler
+#
+CREATE TABLE t1 (id INT, id2 int) engine=ndbcluster;
+
+# insert
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+select sum(id) from t1;
+select * from t1 where id = 1;
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+rollback;
+
+select sum(id) from t1;
+select * from t1 where id = 1;
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+
+begin;
+insert into t1 values(1,1);
+insert into t1 values(2,2);
+commit;
+
+select sum(id) from t1;
+select * from t1 where id = 1;
+select t1.id from t1, t1 as t1x where t1.id2 = t1x.id2 + 1;
+
+# update
+begin;
+update t1 set id = id * 2;
+select sum(id) from t1;
+select * from t1 where id = 2;
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+rollback;
+
+select sum(id) from t1;
+select * from t1 where id = 2;
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+
+begin;
+update t1 set id = id * 2;
+commit;
+
+select sum(id) from t1;
+select * from t1 where id = 2;
+select * from t1, t1 as t1x where t1x.id = t1.id - 2;
+
+# delete
+
+DROP TABLE t1;
+
+#
+# A more extensive test with a lot more records
+#
+
+CREATE TABLE t2 (
+ a bigint unsigned NOT NULL PRIMARY KEY,
+ b int unsigned not null,
+ c int unsigned
+) engine=ndbcluster;
+
+CREATE TABLE t3 (
+ a bigint unsigned NOT NULL,
+ b bigint unsigned not null,
+ c bigint unsigned,
+ PRIMARY KEY(a)
+) engine=ndbcluster;
+
+CREATE TABLE t4 (
+ a bigint unsigned NOT NULL,
+ b bigint unsigned not null,
+ c bigint unsigned NOT NULL,
+ d int unsigned,
+ PRIMARY KEY(a, b, c)
+) engine=ndbcluster;
+
+
+#
+# insert records into tables and rollback
+#
+let $1=100;
+disable_query_log;
+begin;
+while ($1)
+{
+ eval insert into t2 values($1, $1+9, 5);
+ eval insert into t3 values($1, $1+9, 5);
+ eval insert into t4 values($1, $1+9, 5, $1+26000);
+ dec $1;
+}
+rollback;
+enable_query_log;
+
+select count(*) from t2;
+select count(*) from t3;
+select count(*) from t4;
+
+#
+# insert records into tables and commit after timeout;
+#
+let $1=100;
+disable_query_log;
+begin;
+while ($1)
+{
+ eval insert into t2 values($1, $1+9, 5);
+ eval insert into t3 values($1, $1+9, 5);
+ eval insert into t4 values($1, $1+9, 5, $1+26000);
+ dec $1;
+}
+sleep 15;
+-- error 1205
+commit;
+enable_query_log;
+
+select count(*) from t2;
+select count(*) from t3;
+select count(*) from t4;
+
+#
+# insert records into tables and timeout before last operation
+#
+let $1=100;
+disable_query_log;
+begin;
+while ($1)
+{
+ eval insert into t2 values($1, $1+9, 5);
+ eval insert into t3 values($1, $1+9, 5);
+ eval insert into t4 values($1, $1+9, 5, $1+26000);
+ dec $1;
+}
+sleep 15;
+-- error 1205
+insert into t2 values(10000, 10000, 36000);
+commit;
+enable_query_log;
+
+select count(*) from t2;
+select count(*) from t3;
+select count(*) from t4;
+
+#
+# insert records into tables and commit;
+#
+let $1=100;
+disable_query_log;
+begin;
+while ($1)
+{
+ eval insert into t2 values($1, $1+9, 5);
+ eval insert into t3 values($1, $1+9, 5);
+ eval insert into t4 values($1, $1+9, 5, $1+26000);
+ dec $1;
+}
+commit;
+enable_query_log;
+
+select count(*) from t2;
+select count(*) from t3;
+select count(*) from t4;
+
+#
+# delete every other record in the tables
+#
+let $1=100;
+disable_query_log;
+while ($1)
+{
+ eval delete from t2 where a=$1;
+ eval delete from t3 where a=$1;
+ eval delete from t4 where a=$1 and b=$1+9 and c=5;
+ dec $1;
+ dec $1;
+}
+enable_query_log;
+
+#
+# update records and rollback
+#
+begin;
+let $1=100;
+disable_query_log;
+while ($1)
+{
+ eval update t2 set c=$1 where a=$1;
+ eval update t3 set c=7 where a=$1 and b=$1+9 and c=5;
+ eval update t4 set d=$1+21987 where a=$1 and b=$1+9 and c=5;
+ dec $1;
+ dec $1;
+}
+rollback;
+enable_query_log;
+
+#
+# update records and commit
+#
+begin;
+let $1=100;
+disable_query_log;
+while ($1)
+{
+ eval update t2 set c=$1 where a=$1;
+ eval update t3 set c=7 where a=$1 and b=$1+9 and c=5;
+ eval update t4 set d=$1+21987 where a=$1 and b=$1+9 and c=5;
+ dec $1;
+ dec $1;
+}
+rollback;
+enable_query_log;
+
+drop table t2;
+drop table t3;
+drop table t4;
+
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 8bf2948563f..1b7c504aff3 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -63,11 +63,6 @@ typedef NdbDictionary::Dictionary NDBDICT;
bool ndbcluster_inited= false;
-// Error handler for printing out ndbcluster error messages
-TABLE *g_tab_dummy;
-static ha_ndbcluster* g_ha_error= NULL;
-static bool g_error_handler = FALSE;
-
static Ndb* g_ndb= NULL;
// Handler synchronization
@@ -2659,17 +2654,6 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg):
m_unique_index_name[i]= NULL;
}
- // Create error handler needed for error msg handling in static
- // handler functions (ha_commit_trans and ha_rollback_trans)
- if (!g_error_handler)
- {
- DBUG_PRINT("info", ("Setting up error printing handler object"));
- g_tab_dummy = new TABLE();
- g_tab_dummy->table_name = NULL;
- g_error_handler = TRUE;
- g_ha_error= new ha_ndbcluster(g_tab_dummy);
- }
-
DBUG_VOID_RETURN;
}
@@ -2944,15 +2928,7 @@ bool ndbcluster_init()
bool ndbcluster_end()
{
DBUG_ENTER("ndbcluster_end");
- if (g_ha_error)
- {
- DBUG_PRINT("info", ("deallocating error printing handler object"));
- delete g_tab_dummy;
- g_tab_dummy= NULL;
- delete g_ha_error;
- g_ha_error= NULL;
- g_ha_error = FALSE;
- }
+
delete g_ndb;
g_ndb= NULL;
if (!ndbcluster_inited)
@@ -2966,9 +2942,18 @@ bool ndbcluster_end()
DBUG_RETURN(0);
}
+/*
+ Static error print function called from
+ static handler method ndbcluster_commit
+ and ndbcluster_rollback
+*/
void ndbcluster_print_error(int error)
{
- g_ha_error->print_error(error, MYF(0));
+ DBUG_ENTER("ndbcluster_print_error");
+ TABLE tab;
+ tab.table_name = NULL;
+ ha_ndbcluster error_handler(&tab);
+ error_handler.print_error(error, MYF(0));
}
/*
From 1429c70982067838726c92e58c4f6b3dbe8804fc Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 23 Jun 2004 21:13:41 +0200
Subject: [PATCH 026/579] testcases for BUG#4230
---
ndb/test/run-test/daily-basic-tests.txt | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/ndb/test/run-test/daily-basic-tests.txt b/ndb/test/run-test/daily-basic-tests.txt
index f64c1c3f8ba..e458eea8653 100644
--- a/ndb/test/run-test/daily-basic-tests.txt
+++ b/ndb/test/run-test/daily-basic-tests.txt
@@ -148,24 +148,33 @@ cmd: testBasic
args: -n MassiveRollback2 T1 T6 T13
#-m 500 1: testBasic -n ReadConsistency T6
+max-time: 500
cmd: testTimeout
args: -n DontTimeoutTransaction T1
+max-time: 500
cmd: testTimeout
args: -n DontTimeoutTransaction5 T1
+max-time: 500
cmd: testTimeout
args: -n TimeoutTransaction T1
+max-time: 500
cmd: testTimeout
args: -n TimeoutTransaction5 T1
+max-time: 500
cmd: testTimeout
args: -n BuddyTransNoTimeout T1
+max-time: 500
cmd: testTimeout
args: -n BuddyTransNoTimeout5 T1
+max-time: 500
+cmd: testTimeout
+args: -n TimeoutRandTransaction T1
#
# SCAN TESTS
#
@@ -333,6 +342,18 @@ max-time: 500
cmd: testScan
args: -n ScanReadError5030 T1
+max-time: 500
+cmd: testScan
+args: -n InsertDelete T1 T6
+
+max-time: 500
+cmd: testScan
+args: -n CheckAfterTerror T1
+
+max-time: 500
+cmd: testScan
+args: -n ScanReadWhileNodeIsDown T1
+
# OLD FLEX
max-time: 500
cmd: flexBench
From 5e5178a6adc9afb6a7dc90e4bf08861668d9ab7c Mon Sep 17 00:00:00 2001
From: "joreland@mysql.com" <>
Date: Wed, 23 Jun 2004 21:33:47 +0200
Subject: [PATCH 027/579] Reset exec_flag when contacting API
---
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index 051c6d7de27..bcb7dd4e7c1 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -3767,7 +3767,8 @@ void Dbtc::sendtckeyconf(Signal* signal, UintR TcommitFlag)
return; // No queued TcKeyConf
}//if
}//if
-
+
+ regApiPtr->m_exec_flag = 0;
TcKeyConf::setNoOfOperations(confInfo, (TopWords >> 1));
if ((TpacketLen > 25) || !is_api){
TcKeyConf * const tcKeyConf = (TcKeyConf *)signal->getDataPtrSend();
@@ -10999,7 +11000,8 @@ void Dbtc::sendTcIndxConf(Signal* signal, UintR TcommitFlag)
TcIndxConf::setMarkerFlag(confInfo, Tmarker);
const UintR TpacketLen = 6 + TopWords;
regApiPtr->tcindxrec = 0;
-
+ regApiPtr->m_exec_flag = 0;
+
if ((TpacketLen > 25) || !is_api){
TcIndxConf * const tcIndxConf = (TcIndxConf *)signal->getDataPtrSend();
From e80c66b06337a9cfe127887d7e6b2bdb87a4b822 Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.bredbandsbolaget.se" <>
Date: Wed, 23 Jun 2004 23:53:48 +0000
Subject: [PATCH 028/579] wl 1748
---
ndb/include/kernel/NodeInfo.hpp | 9 +-
ndb/include/kernel/NodeState.hpp | 6 +-
.../kernel/signaldata/ApiRegSignalData.hpp | 4 +-
ndb/include/mgmapi/mgmapi.h | 10 +-
ndb/include/mgmapi/mgmapi_config_parameters.h | 1 +
ndb/include/util/Bitmask.hpp | 122 +++++++++---------
ndb/include/util/SocketAuthenticator.hpp | 4 +-
ndb/src/common/mgmcommon/ConfigInfo.cpp | 69 +++++++++-
ndb/src/common/transporter/Transporter.cpp | 2 +-
.../transporter/TransporterRegistry.cpp | 2 +-
ndb/src/common/util/SocketAuthenticator.cpp | 66 +++++++---
ndb/src/kernel/blocks/qmgr/QmgrMain.cpp | 3 +-
ndb/src/mgmsrv/MgmtSrvr.cpp | 109 +++++++++++-----
ndb/src/mgmsrv/MgmtSrvr.hpp | 21 ++-
ndb/src/mgmsrv/Services.cpp | 39 ++++--
ndb/src/mgmsrv/Services.hpp | 2 +
ndb/src/mgmsrv/main.cpp | 7 +-
ndb/src/ndbapi/ClusterMgr.cpp | 4 -
ndb/src/ndbapi/ClusterMgr.hpp | 1 -
19 files changed, 327 insertions(+), 154 deletions(-)
diff --git a/ndb/include/kernel/NodeInfo.hpp b/ndb/include/kernel/NodeInfo.hpp
index 86aca7d6883..5377f001949 100644
--- a/ndb/include/kernel/NodeInfo.hpp
+++ b/ndb/include/kernel/NodeInfo.hpp
@@ -18,6 +18,7 @@
#define NODE_INFO_HPP
#include
+#include
class NodeInfo {
public:
@@ -27,10 +28,10 @@ public:
* NodeType
*/
enum NodeType {
- DB = 0, ///< Database node
- API = 1, ///< NDB API node
- MGM = 2, ///< Management node (incl. NDB API)
- REP = 3, ///< Replication node (incl. NDB API)
+ DB = NODE_TYPE_DB, ///< Database node
+ API = NODE_TYPE_API, ///< NDB API node
+ MGM = NODE_TYPE_MGM, ///< Management node (incl. NDB API)
+ REP = NODE_TYPE_REP, ///< Replication node (incl. NDB API)
INVALID = 255 ///< Invalid type
};
NodeType getType() const;
diff --git a/ndb/include/kernel/NodeState.hpp b/ndb/include/kernel/NodeState.hpp
index 1bc7806876d..3b4925868f5 100644
--- a/ndb/include/kernel/NodeState.hpp
+++ b/ndb/include/kernel/NodeState.hpp
@@ -18,6 +18,7 @@
#define NODE_STATE_HPP
#include
+#include
class NodeState {
public:
@@ -99,7 +100,7 @@ public:
/**
* Length in 32-bit words
*/
- static const Uint32 DataLength = 8;
+ static const Uint32 DataLength = 8 + NdbNodeBitmask::Size;
/**
* Constructor(s)
@@ -146,6 +147,8 @@ public:
Uint32 singleUserMode;
Uint32 singleUserApi; //the single user node
+ BitmaskPOD m_connected_nodes;
+
void setDynamicId(Uint32 dynamic);
void setNodeGroup(Uint32 group);
void setSingleUser(Uint32 s);
@@ -182,6 +185,7 @@ NodeState::NodeState(){
dynamicId = 0xFFFFFFFF;
singleUserMode = 0;
singleUserApi = 0xFFFFFFFF;
+ m_connected_nodes.clear();
}
inline
diff --git a/ndb/include/kernel/signaldata/ApiRegSignalData.hpp b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
index 9ce99d3e45c..84dca8fb260 100644
--- a/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
+++ b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp
@@ -80,15 +80,13 @@ class ApiRegConf {
friend class ClusterMgr;
public:
- STATIC_CONST( SignalLength = 3 + NodeState::DataLength +
- NdbNodeBitmask::Size );
+ STATIC_CONST( SignalLength = 3 + NodeState::DataLength );
private:
Uint32 qmgrRef;
Uint32 version; // Version of NDB node
Uint32 apiHeartbeatFrequency;
NodeState nodeState;
- Bitmask::Data connected_nodes;
};
#endif
diff --git a/ndb/include/mgmapi/mgmapi.h b/ndb/include/mgmapi/mgmapi.h
index 45a421855b0..123297b0d71 100644
--- a/ndb/include/mgmapi/mgmapi.h
+++ b/ndb/include/mgmapi/mgmapi.h
@@ -49,6 +49,8 @@
* @{
*/
+#include "mgmapi_config_parameters.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -81,10 +83,10 @@ extern "C" {
*/
enum ndb_mgm_node_type {
NDB_MGM_NODE_TYPE_UNKNOWN = -1, /*/< Node type not known*/
- NDB_MGM_NODE_TYPE_API = 0, /*/< An application node (API)*/
- NDB_MGM_NODE_TYPE_NDB = 1, /*/< A database node (DB)*/
- NDB_MGM_NODE_TYPE_MGM = 2, /*/< A management server node (MGM)*/
- NDB_MGM_NODE_TYPE_REP = 3, ///< A replication node
+ NDB_MGM_NODE_TYPE_API = NODE_TYPE_API, /*/< An application node (API)*/
+ NDB_MGM_NODE_TYPE_NDB = NODE_TYPE_DB, /*/< A database node (DB)*/
+ NDB_MGM_NODE_TYPE_MGM = NODE_TYPE_MGM, /*/< A management server node (MGM)*/
+ NDB_MGM_NODE_TYPE_REP = NODE_TYPE_REP, ///< A replication node
NDB_MGM_NODE_TYPE_MIN = 0, /*/< Min valid value*/
NDB_MGM_NODE_TYPE_MAX = 3 /*/< Max valid value*/
diff --git a/ndb/include/mgmapi/mgmapi_config_parameters.h b/ndb/include/mgmapi/mgmapi_config_parameters.h
index 22b9f8f31dd..f6069066b14 100644
--- a/ndb/include/mgmapi/mgmapi_config_parameters.h
+++ b/ndb/include/mgmapi/mgmapi_config_parameters.h
@@ -6,6 +6,7 @@
#define CFG_SYS_PRIMARY_MGM_NODE 1
#define CFG_SYS_CONFIG_GENERATION 2
#define CFG_SYS_REPLICATION_ROLE 7
+#define CFG_SYS_PORT_BASE 8
#define CFG_NODE_ID 3
#define CFG_NODE_BYTE_ORDER 4
diff --git a/ndb/include/util/Bitmask.hpp b/ndb/include/util/Bitmask.hpp
index 7355742f845..7435e351ddc 100644
--- a/ndb/include/util/Bitmask.hpp
+++ b/ndb/include/util/Bitmask.hpp
@@ -326,7 +326,7 @@ BitmaskImpl::getText(unsigned size, const Uint32 data[], char* buf)
* XXX replace size by length in bits
*/
template
-class Bitmask {
+struct BitmaskPOD {
public:
/**
* POD data representation
@@ -334,7 +334,7 @@ public:
struct Data {
Uint32 data[size];
#if 0
- Data & operator=(const Bitmask & src) {
+ Data & operator=(const BitmaskPOD & src) {
src.copyto(size, data);
return *this;
}
@@ -348,19 +348,17 @@ public:
STATIC_CONST( NotFound = BitmaskImpl::NotFound );
STATIC_CONST( TextLength = size * 8 );
- Bitmask() { clear();}
-
/**
* assign - Set all bits in dst to corresponding in src/
*/
- void assign(const typename Bitmask::Data & src);
+ void assign(const typename BitmaskPOD::Data & src);
/**
* assign - Set all bits in dst to corresponding in src/
*/
static void assign(Uint32 dst[], const Uint32 src[]);
- static void assign(Uint32 dst[], const Bitmask & src);
- void assign(const Bitmask & src);
+ static void assign(Uint32 dst[], const BitmaskPOD & src);
+ void assign(const BitmaskPOD & src);
/**
* copy this to dst
@@ -432,43 +430,43 @@ public:
* equal - Bitwise equal.
*/
static bool equal(const Uint32 data[], const Uint32 data2[]);
- bool equal(const Bitmask& mask2) const;
+ bool equal(const BitmaskPOD& mask2) const;
/**
* bitOR - Bitwise (x | y) into first operand.
*/
static void bitOR(Uint32 data[], const Uint32 data2[]);
- Bitmask& bitOR(const Bitmask& mask2);
+ BitmaskPOD& bitOR(const BitmaskPOD& mask2);
/**
* bitAND - Bitwise (x & y) into first operand.
*/
static void bitAND(Uint32 data[], const Uint32 data2[]);
- Bitmask& bitAND(const Bitmask& mask2);
+ BitmaskPOD& bitAND(const BitmaskPOD& mask2);
/**
* bitANDC - Bitwise (x & ~y) into first operand.
*/
static void bitANDC(Uint32 data[], const Uint32 data2[]);
- Bitmask& bitANDC(const Bitmask& mask2);
+ BitmaskPOD& bitANDC(const BitmaskPOD& mask2);
/**
* bitXOR - Bitwise (x ^ y) into first operand.
*/
static void bitXOR(Uint32 data[], const Uint32 data2[]);
- Bitmask& bitXOR(const Bitmask& mask2);
+ BitmaskPOD& bitXOR(const BitmaskPOD& mask2);
/**
* contains - Check if all bits set in data2 (that) are also set in data (this)
*/
static bool contains(Uint32 data[], const Uint32 data2[]);
- bool contains(Bitmask that);
+ bool contains(BitmaskPOD