int
UtilTransactions::addRowToInsert(Ndb* pNdb,
NdbConnection* pInsTrans,
NDBT_ResultRow & row,
const char *insertTabName){
int check;
NdbOperation* pInsOp;
pInsOp = pInsTrans->getNdbOperation(insertTabName);
if (pInsOp == NULL) {
ERR(pInsTrans->getNdbError());
return NDBT_FAILED;
}
check = pInsOp->insertTuple();
if( check == -1 ) {
ERR(pInsTrans->getNdbError());
return NDBT_FAILED;
}
// Set all attributes
for (int a = 0; a < tab.getNoOfColumns(); a++){
NdbRecAttr* r = row.attributeStore(a);
int sz = r->get_size_in_bytes();
if (pInsOp->setValue(tab.getColumn(a)->getName(),
r->aRef(),
sz) != 0) {
ERR(pInsTrans->getNdbError());
return NDBT_FAILED;
}
}
return NDBT_OK;
}
int
UtilTransactions::get_values(NdbOperation* op, NDBT_ResultRow& dst)
{
for (int a = 0; a < tab.getNoOfColumns(); a++){
NdbRecAttr*& ref= dst.attributeStore(a);
if ((ref= op->getValue(a)) == 0)
{
return NDBT_FAILED;
}
}
return 0;
}
int
UtilTransactions::equal(const NdbDictionary::Index* pIndex,
NdbOperation* op, const NDBT_ResultRow& src)
{
for(Uint32 a = 0; a<pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
if(op->equal(col->getName(),
src.attributeStore(col->getName())->aRef()) != 0){
return NDBT_FAILED;
}
}
return 0;
}
int
UtilTransactions::equal(const NdbDictionary::Table* pTable,
NdbOperation* op, const NDBT_ResultRow& src)
{
for(Uint32 a = 0; a<tab.getNoOfColumns(); a++){
const NdbDictionary::Column* attr = tab.getColumn(a);
if (attr->getPrimaryKey() == true){
if (op->equal(attr->getName(), src.attributeStore(a)->aRef()) != 0){
return NDBT_FAILED;
}
}
}
return 0;
}
int
UtilTransactions::readRowFromTableAndIndex(Ndb* pNdb,
NdbConnection* scanTrans,
const NdbDictionary::Index* pIndex,
NDBT_ResultRow& row ){
NdbDictionary::Index::Type indexType= pIndex->getType();
int retryAttempt = 0;
const int retryMax = 100;
int check, a;
NdbConnection *pTrans1=NULL;
NdbOperation *pOp;
int return_code= NDBT_FAILED;
// Allocate place to store the result
NDBT_ResultRow tabRow(tab);
NDBT_ResultRow indexRow(tab);
const char * indexName = pIndex->getName();
while (true){
if(retryAttempt)
ndbout_c("retryAttempt %d", retryAttempt);
if (retryAttempt >= retryMax){
g_info << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
goto close_all;
}
pTrans1 = pNdb->hupp(scanTrans); //startTransaction();
if (pTrans1 == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
if(err.code == 0){
return_code = NDBT_OK;
goto close_all;
}
ERR(err);
goto close_all;
}
/**
* Read the record from TABLE
*/
pOp = pTrans1->getNdbOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
check = pOp->readTuple();
if( check == -1 ) {
ERR(pTrans1->getNdbError());
goto close_all;
}
// Define primary keys
#if VERBOSE
printf("PK: ");
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
const NdbDictionary::Column* attr = tab.getColumn(a);
if (attr->getPrimaryKey() == true){
if (pOp->equal(attr->getName(), row.attributeStore(a)->aRef()) != 0){
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s = %d: ", attr->getName(), row.attributeStore(a)->aRef());
#endif
}
}
#if VERBOSE
printf("\n");
#endif
// Read all attributes
#if VERBOSE
printf("Reading %u attributes: ", tab.getNoOfColumns());
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
if((tabRow.attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s ", tab.getColumn(a)->getName());
#endif
}
#if VERBOSE
printf("\n");
#endif
/**
* Read the record from INDEX_TABLE
*/
NdbIndexOperation* pIndexOp= NULL;
NdbIndexScanOperation *pScanOp= NULL;
NdbOperation *pIOp= 0;
bool null_found= false;
for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
if (row.attributeStore(col->getName())->isNULL())
{
null_found= true;
break;
}
}
const char * tabName= tab.getName();
if(!null_found)
{
if (indexType == NdbDictionary::Index::UniqueHashIndex) {
pIOp= pIndexOp= pTrans1->getNdbIndexOperation(indexName, tabName);
} else {
pIOp= pScanOp= pTrans1->getNdbIndexScanOperation(indexName, tabName);
}
if (pIOp == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
{
bool not_ok;
if (pIndexOp) {
not_ok = pIndexOp->readTuple() == -1;
} else {
not_ok = pScanOp->readTuples();
}
if( not_ok ) {
ERR(pTrans1->getNdbError());
goto close_all;
}
}
// Define primary keys for index
#if VERBOSE
printf("SI: ");
#endif
for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
int r;
if ( !row.attributeStore(col->getName())->isNULL() ) {
if(pIOp->equal(col->getName(),
row.attributeStore(col->getName())->aRef()) != 0){
ERR(pTrans1->getNdbError());
goto close_all;
}
}
#if VERBOSE
printf("%s = %d: ", col->getName(), row.attributeStore(a)->aRef());
#endif
}
#if VERBOSE
printf("\n");
#endif
// Read all attributes
#if VERBOSE
printf("Reading %u attributes: ", tab.getNoOfColumns());
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
void* pCheck;
pCheck= indexRow.attributeStore(a)=
pIOp->getValue(tab.getColumn(a)->getName());
if(pCheck == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s ", tab.getColumn(a)->getName());
#endif
}
}
#if VERBOSE
printf("\n");
#endif
scanTrans->refresh();
check = pTrans1->execute(Commit, AbortOnError);
if( check == -1 ) {
const NdbError err = pTrans1->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans1);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ndbout << "Error when comparing records - normal op" << endl;
ERR(err);
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
/**
* Compare the two rows
*/
if(!null_found){
if (pScanOp) {
if (pScanOp->nextResult() != 0){
const NdbError err = pTrans1->getNdbError();
ERR(err);
ndbout << "Error when comparing records - index op next_result missing" << endl;
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
}
if (!(tabRow.c_str() == indexRow.c_str())){
ndbout << "Error when comapring records" << endl;
ndbout << " tabRow: \n" << tabRow.c_str().c_str() << endl;
ndbout << " indexRow: \n" << indexRow.c_str().c_str() << endl;
goto close_all;
}
if (pScanOp) {
if (pScanOp->nextResult() == 0){
ndbout << "Error when comparing records - index op next_result to many" << endl;
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
}
}
return_code= NDBT_OK;
goto close_all;
}
close_all:
if (pTrans1)
pNdb->closeTransaction(pTrans1);
return return_code;
}
inline
int
ScanInterpretTest::addRowToInsert(Ndb* pNdb,
NdbConnection* pInsTrans){
NdbOperation* pOp =
pInsTrans->getNdbOperation(restab.getName());
if (pOp == NULL) {
ERR(pInsTrans->getNdbError());
pNdb->closeTransaction(pInsTrans);
return NDBT_FAILED;
}
if( pOp->insertTuple() == -1 ) {
ERR(pInsTrans->getNdbError());
pNdb->closeTransaction(pInsTrans);
return NDBT_FAILED;
}
// Copy all attribute to the new operation
for (int a = 0; a<restab.getNoOfColumns(); a++){
const NdbDictionary::Column* attr = tab.getColumn(a);
NdbRecAttr* reca = row.attributeStore(a);
int check = -1;
switch (attr->getType()){
case NdbDictionary::Column::Char:
case NdbDictionary::Column::Varchar:
case NdbDictionary::Column::Binary:
case NdbDictionary::Column::Varbinary:{
check = pOp->setValue( attr->getName(),
reca->aRef());
break;
}
case NdbDictionary::Column::Int:{
check = pOp->setValue( attr->getName(),
reca->int32_value());
}
break;
case NdbDictionary::Column::Bigint:{
check = pOp->setValue( attr->getName(),
reca->int64_value());
}
break;
case NdbDictionary::Column::Unsigned:{
check = pOp->setValue( attr->getName(),
reca->u_32_value());
}
break;
case NdbDictionary::Column::Bigunsigned:{
check = pOp->setValue( attr->getName(),
reca->u_64_value());
}
break;
case NdbDictionary::Column::Float:
check = pOp->setValue( attr->getName(),
reca->float_value());
break;
default:
check = -1;
break;
}
if(check != 0){
ERR(pInsTrans->getNdbError());
pNdb->closeTransaction(pInsTrans);
return NDBT_FAILED;
}
}
return NDBT_OK;
}
inline
int
ScanInterpretTest::scanReadVerify(Ndb* pNdb,
int records,
int parallelism,
ScanFilter& filter){
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbConnection *pTrans;
NdbScanOperation *pOp;
while (true){
if (retryAttempt >= retryMax){
ndbout << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
return NDBT_FAILED;
}
pTrans = pNdb->startTransaction();
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
return NDBT_FAILED;
}
pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) { if (pOp->getValue("KOL2") == 0){
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
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;
}
// Read all attributes
for(int a = 0; a<tab.getNoOfColumns(); a++){
if((row.attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
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 eof;
int rows = 0;
int rowsNoExist = 0;
int rowsExist = 0;
int existingRecordsNotFound = 0;
int nonExistingRecordsFound = 0;
NdbConnection* pExistTrans;
NdbConnection* pNoExistTrans;
while((eof = pOp->nextResult(true)) == 0){
pExistTrans = pNdb->startTransaction();
if (pExistTrans == NULL) {
const NdbError err = pNdb->getNdbError();
ERR(err);
return NDBT_FAILED;
}
pNoExistTrans = pNdb->startTransaction();
if (pNoExistTrans == NULL) {
const NdbError err = pNdb->getNdbError();
ERR(err);
return NDBT_FAILED;
}
do {
rows++;
if (filter.verifyRecord(row) == NDBT_OK){
rowsExist++;
if (addRowToCheckTrans(pNdb, pExistTrans) != 0){
pNdb->closeTransaction(pTrans);
pNdb->closeTransaction(pExistTrans);
pNdb->closeTransaction(pNoExistTrans);
return NDBT_FAILED;
}
}else{
rowsNoExist++;
if (addRowToCheckTrans(pNdb, pNoExistTrans) != 0){
pNdb->closeTransaction(pTrans);
pNdb->closeTransaction(pExistTrans);
pNdb->closeTransaction(pNoExistTrans);
return NDBT_FAILED;
}
}
} while((eof = pOp->nextResult(false)) == 0);
// Execute the transaction containing reads of
// all the records that should be in the result table
check = pExistTrans->execute(Commit);
if( check == -1 ) {
const NdbError err = pExistTrans->getNdbError();
ERR(err);
if (err.code != 626){
pNdb->closeTransaction(pExistTrans);
pNdb->closeTransaction(pNoExistTrans);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}else{
// Some of the records expected to be found wasn't
// there
existingRecordsNotFound = 1;
}
}
pNdb->closeTransaction(pExistTrans);
// Execute the transaction containing reads of
// all the records that should NOT be in the result table
check = pNoExistTrans->execute(Commit, CommitAsMuchAsPossible);
if( check == -1 ) {
const NdbError err = pNoExistTrans->getNdbError();
// The transactions error code should be zero
if (err.code != 626){
ERR(err);
pNdb->closeTransaction(pNoExistTrans);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
// Loop through the no existing transaction and check that no
// operations where successful
const NdbOperation* pOp2 = NULL;
while ((pOp2 = pNoExistTrans->getNextCompletedOperation(pOp2)) != NULL){
const NdbError err = pOp2->getNdbError();
if (err.code != 626){
ndbout << "err.code = " << err.code<< endl;
nonExistingRecordsFound = 1;
}
}
}
pNdb->closeTransaction(pNoExistTrans);
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
int testResult = NDBT_OK;
int rowsResult = 0;
UtilTransactions utilTrans(restab);
if (utilTrans.selectCount(pNdb,
240,
&rowsResult) != 0){
return NDBT_FAILED;
}
if (existingRecordsNotFound == 1){
ndbout << "!!! Expected records not found" << endl;
testResult = NDBT_FAILED;
}
if (nonExistingRecordsFound == 1){
ndbout << "!!! Unxpected records found" << endl;
testResult = NDBT_FAILED;
}
ndbout << rows << " rows scanned("
<< rowsExist << " found, " << rowsResult<<" expected)" << endl;
if (rowsResult != rowsExist){
ndbout << "!!! Number of rows in result table different from expected" << endl;
testResult = NDBT_FAILED;
}
return testResult;
}
return NDBT_FAILED;
}
inline
int
ScanInterpretTest::scanRead(Ndb* pNdb,
int records,
int parallelism,
ScanFilter& filter){
int retryAttempt = 0;
int retryMax = 100;
int check;
NdbConnection *pTrans;
NdbScanOperation *pOp;
while (true){
if (retryAttempt >= retryMax){
ndbout << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
return NDBT_FAILED;
}
pTrans = pNdb->startTransaction();
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
return NDBT_FAILED;
}
pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
if (filter.filterOp(pOp) != 0){
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
// Read all attributes
for(int a = 0; a<tab.getNoOfColumns(); a++){
if((row.attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
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 eof;
int rows = 0;
NdbConnection* pInsTrans;
while((eof = pOp->nextResult(true)) == 0){
do {
rows++;
if (addRowToInsert(pNdb, pTrans) != 0){
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
} while((eof = pOp->nextResult(false)) == 0);
check = pTrans->execute(Commit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
ERR(err);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
pNdb->closeTransaction(pTrans);
return NDBT_FAILED;
}
pNdb->closeTransaction(pTrans);
g_info << rows << " rows have been scanned" << endl;
return NDBT_OK;
}
return NDBT_FAILED;
}
inline
int
ScanInterpretTest::addRowToCheckTrans(Ndb* pNdb,
NdbConnection* pCheckTrans){
NdbOperation* pOp =
pCheckTrans->getNdbOperation(restab.getName());
if (pOp == NULL) {
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
if(pOp->readTuple() != 0) {
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
// Copy pk attribute's to the new operation
for (int a = 0; a<restab.getNoOfColumns(); a++){
const NdbDictionary::Column* attr = restab.getColumn(a);
if (attr->getPrimaryKey() == true){
NdbRecAttr* reca = row.attributeStore(a);
int check = -1;
switch (attr->getType()){
case NdbDictionary::Column::Char:
case NdbDictionary::Column::Varchar:
case NdbDictionary::Column::Binary:
case NdbDictionary::Column::Varbinary:{
check = pOp->equal( attr->getName(),
reca->aRef());
break;
}
case NdbDictionary::Column::Int:{
check = pOp->equal( attr->getName(),
reca->int32_value());
}
break;
case NdbDictionary::Column::Bigint:{
check = pOp->equal( attr->getName(),
reca->int64_value());
}
break;
case NdbDictionary::Column::Unsigned:{
check = pOp->equal( attr->getName(),
reca->u_32_value());
}
break;
case NdbDictionary::Column::Bigunsigned:{
check = pOp->equal( attr->getName(),
reca->u_64_value());
}
break;
default:
check = -1;
break;
}
if(check != 0){
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
}
}
return NDBT_OK;
}
bool
NDBT_ResultRow::operator==(const NDBT_ResultRow& other) const
{
// quick and dirty
return c_str() == other.c_str();
}
int scanReadRecords(Ndb* pNdb,
const NdbDictionary::Table* pTab,
const NdbDictionary::Index* pIdx,
int parallel,
int _lock,
bool headers,
bool useHexFormat,
char delimiter, bool order, bool descending) {
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbTransaction *pTrans;
NdbScanOperation *pOp;
NdbIndexScanOperation * pIOp= 0;
NDBT_ResultRow * row = new NDBT_ResultRow(*pTab, delimiter);
while (true) {
if (retryAttempt >= retryMax) {
ndbout << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
return -1;
}
pTrans = pNdb->startTransaction();
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError) {
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
return -1;
}
pOp = (!pIdx) ? pTrans->getNdbScanOperation(pTab->getName()) :
pIOp=pTrans->getNdbIndexScanOperation(pIdx->getName(), pTab->getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
int rs;
unsigned scan_flags = 0;
if (_tup) scan_flags |= NdbScanOperation::SF_TupScan;
switch(_lock + (3 * order)) {
case 1:
rs = pOp->readTuples(NdbScanOperation::LM_Read, scan_flags, parallel);
break;
case 2:
rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, scan_flags, parallel);
break;
case 3:
rs = pIOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallel,
true, descending);
break;
case 4:
rs = pIOp->readTuples(NdbScanOperation::LM_Read, 0, parallel, true, descending);
break;
case 5:
rs = pIOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallel, true, descending);
break;
case 0:
default:
rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead, scan_flags, parallel);
break;
}
if( rs != 0 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
if(0) {
NdbScanFilter sf(pOp);
#if 0
sf.begin(NdbScanFilter::AND);
sf.le(0, (Uint32)10);
sf.end();
#elif 0
sf.begin(NdbScanFilter::OR);
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)10);
sf.lt(0, (Uint32)20);
sf.end();
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)30);
sf.lt(0, (Uint32)40);
sf.end();
sf.end();
#elif 1
sf.begin(NdbScanFilter::AND);
sf.begin(NdbScanFilter::OR);
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)10);
sf.lt(0, (Uint32)20);
sf.end();
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)30);
sf.lt(0, (Uint32)40);
sf.end();
sf.end();
sf.begin(NdbScanFilter::OR);
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)0);
sf.lt(0, (Uint32)50);
sf.end();
sf.begin(NdbScanFilter::AND);
sf.ge(0, (Uint32)100);
sf.lt(0, (Uint32)200);
sf.end();
sf.end();
sf.end();
#endif
} else {
check = pOp->interpret_exit_ok();
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
}
bool disk= false;
for(int a = 0; a<pTab->getNoOfColumns(); a++)
{
const NdbDictionary::Column* col = pTab->getColumn(a);
if(col->getStorageType() == NdbDictionary::Column::StorageTypeDisk)
disk= true;
if (!nodata)
if((row->attributeStore(a) = pOp->getValue(col)) == 0)
{
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
return -1;
}
}
NdbRecAttr * disk_ref= 0;
if(_dumpDisk && disk)
disk_ref = pOp->getValue(NdbDictionary::Column::DISK_REF);
NdbRecAttr * rowid= 0, *frag = 0, *gci = 0;
if (use_rowid)
{
frag = pOp->getValue(NdbDictionary::Column::FRAGMENT);
rowid = pOp->getValue(NdbDictionary::Column::ROWID);
}
if (use_gci)
{
gci = pOp->getValue(NdbDictionary::Column::ROW_GCI);
}
check = pTrans->execute(NdbTransaction::NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError) {
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
pNdb->closeTransaction(pTrans);
return -1;
}
if (rowid)
ndbout << "ROWID\t";
if (gci)
ndbout << "\tGCI";
if (headers && !nodata)
row->header(ndbout);
if (disk_ref)
ndbout << "\tDISK_REF";
ndbout << endl;
int eof;
int rows = 0;
eof = pOp->nextResult();
while(eof == 0) {
rows++;
if (useHexFormat)
ndbout.setHexFormat(1);
if (rowid)
{
ndbout << "[ fragment: " << frag->u_32_value()
<< " m_page: " << rowid->u_32_value()
<< " m_page_idx: " << *(Uint32*)(rowid->aRef() + 4) << " ]";
ndbout << "\t";
}
if (gci)
{
if (gci->isNULL())
ndbout << "NULL\t";
else
ndbout << gci->u_64_value() << "\t";
}
if (!nodata)
ndbout << (*row);
if(disk_ref)
{
ndbout << "\t";
ndbout << "[ m_file_no: " << *(Uint16*)(disk_ref->aRef()+6)
<< " m_page: " << disk_ref->u_32_value()
<< " m_page_idx: " << *(Uint16*)(disk_ref->aRef() + 4) << " ]";
}
if (rowid || disk_ref || gci || !nodata)
ndbout << endl;
eof = pOp->nextResult();
}
if (eof == -1) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError) {
pNdb->closeTransaction(pTrans);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
pNdb->closeTransaction(pTrans);
return -1;
}
pNdb->closeTransaction(pTrans);
ndbout << rows << " rows returned" << endl;
return 0;
}
return -1;
}
