Skip to content

Commit f06f09f

Browse files
author
Ole John Aske
committed
Merge 7.1 -> 7.2
2 parents bf15e62 + add30d5 commit f06f09f

40 files changed

+734
-735
lines changed

‎storage/ndb/test/include/NDBT_Error.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ class ErrorData {
8383
// ERR prints an NdbError object together with a description of where the
8484
// error occured
8585
//
86-
#define ERR_OUT(where, error) \
86+
#define NDB_ERR_OUT(where, error) \
8787
{ where << "ERROR: " << error.code << " " \
8888
<< error.message << endl \
8989
<< " " << "Status: " << error.status \
@@ -93,11 +93,11 @@ class ErrorData {
9393
; \
9494
}
9595

96-
#define ERR(error) \
96+
#define NDB_ERR(error) \
9797
{ \
9898
const NdbError &_error= (error); \
99-
ERR_OUT(g_err, _error); \
99+
NDB_ERR_OUT(g_err, _error); \
100100
}
101-
#define ERR_INFO(error) ERR_OUT(g_info, error)
101+
#define NDB_ERR_INFO(error) NDB_ERR_OUT(g_info, error)
102102

103103
#endif

‎storage/ndb/test/ndbapi/ScanFunctions.hpp

+11-11
Original file line numberDiff line numberDiff line change
@@ -95,27 +95,27 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
9595
if (pTrans == NULL) {
9696
const NdbError err = pNdb->getNdbError();
9797
if (err.status == NdbError::TemporaryError){
98-
ERR(err);
98+
NDB_ERR(err);
9999
NdbSleep_MilliSleep(50);
100100
retryAttempt++;
101101
continue;
102102
}
103-
ERR(err);
103+
NDB_ERR(err);
104104
return NDBT_FAILED;
105105
}
106106

107107
// Execute the scan without defining a scan operation
108108
pOp = pTrans->getNdbScanOperation(tab.getName());
109109
if (pOp == NULL) {
110-
ERR(pTrans->getNdbError());
110+
NDB_ERR(pTrans->getNdbError());
111111
pNdb->closeTransaction(pTrans);
112112
return NDBT_FAILED;
113113
}
114114

115115
if( pOp->readTuples(exclusive ?
116116
NdbScanOperation::LM_Exclusive :
117117
NdbScanOperation::LM_Read) ) {
118-
ERR(pTrans->getNdbError());
118+
NDB_ERR(pTrans->getNdbError());
119119
pNdb->closeTransaction(pTrans);
120120
return NDBT_FAILED;
121121
}
@@ -124,7 +124,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
124124
if (action == OnlyOpenScanOnce){
125125
// Call openScan one more time when it's already defined
126126
if( pOp->readTuples(NdbScanOperation::LM_Read) ) {
127-
ERR(pTrans->getNdbError());
127+
NDB_ERR(pTrans->getNdbError());
128128
pNdb->closeTransaction(pTrans);
129129
return NDBT_FAILED;
130130
}
@@ -133,23 +133,23 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
133133
if (action==EqualAfterOpenScan){
134134
check = pOp->equal(tab.getColumn(0)->getName(), 10);
135135
if( check == -1 ) {
136-
ERR(pTrans->getNdbError());
136+
NDB_ERR(pTrans->getNdbError());
137137
pNdb->closeTransaction(pTrans);
138138
return NDBT_FAILED;
139139
}
140140
}
141141

142142
for(int a = 0; a<tab.getNoOfColumns(); a++){
143143
if(pOp->getValue(tab.getColumn(a)->getName()) == NULL) {
144-
ERR(pTrans->getNdbError());
144+
NDB_ERR(pTrans->getNdbError());
145145
pNdb->closeTransaction(pTrans);
146146
return NDBT_FAILED;
147147
}
148148
}
149149

150150
check = pTrans->execute(NoCommit);
151151
if( check == -1 ) {
152-
ERR(pTrans->getNdbError());
152+
NDB_ERR(pTrans->getNdbError());
153153
pNdb->closeTransaction(pTrans);
154154
return NDBT_FAILED;
155155
}
@@ -170,7 +170,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
170170
// Test that we can closeTrans without stopScan
171171
pOp->close();
172172
if( check == -1 ) {
173-
ERR(pTrans->getNdbError());
173+
NDB_ERR(pTrans->getNdbError());
174174
pNdb->closeTransaction(pTrans);
175175
return NDBT_FAILED;
176176
}
@@ -197,7 +197,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
197197
const NdbError err = pTrans->getNdbError();
198198

199199
if (err.status == NdbError::TemporaryError){
200-
ERR(err);
200+
NDB_ERR(err);
201201

202202
// Be cruel, call nextScanResult after error
203203
for(int i=0; i<10; i++){
@@ -223,7 +223,7 @@ ScanFunctions::scanReadFunctions(Ndb* pNdb,
223223

224224
continue;
225225
}
226-
ERR(err);
226+
NDB_ERR(err);
227227
pNdb->closeTransaction(pTrans);
228228
return NDBT_FAILED;
229229
}

‎storage/ndb/test/ndbapi/ScanInterpretTest.hpp

+29-29
Original file line numberDiff line numberDiff line change
@@ -59,13 +59,13 @@ ScanInterpretTest::addRowToInsert(Ndb* pNdb,
5959
NdbOperation* pOp =
6060
pInsTrans->getNdbOperation(restab.getName());
6161
if (pOp == NULL) {
62-
ERR(pInsTrans->getNdbError());
62+
NDB_ERR(pInsTrans->getNdbError());
6363
pNdb->closeTransaction(pInsTrans);
6464
return NDBT_FAILED;
6565
}
6666

6767
if( pOp->insertTuple() == -1 ) {
68-
ERR(pInsTrans->getNdbError());
68+
NDB_ERR(pInsTrans->getNdbError());
6969
pNdb->closeTransaction(pInsTrans);
7070
return NDBT_FAILED;
7171
}
@@ -114,7 +114,7 @@ ScanInterpretTest::addRowToInsert(Ndb* pNdb,
114114
break;
115115
}
116116
if(check != 0){
117-
ERR(pInsTrans->getNdbError());
117+
NDB_ERR(pInsTrans->getNdbError());
118118
pNdb->closeTransaction(pInsTrans);
119119
return NDBT_FAILED;
120120
}
@@ -131,12 +131,12 @@ ScanInterpretTest::addRowToCheckTrans(Ndb* pNdb,
131131
NdbOperation* pOp =
132132
pCheckTrans->getNdbOperation(restab.getName());
133133
if (pOp == NULL) {
134-
ERR(pNdb->getNdbError());
134+
NDB_ERR(pNdb->getNdbError());
135135
return NDBT_FAILED;
136136
}
137137

138138
if(pOp->readTuple() != 0) {
139-
ERR(pNdb->getNdbError());
139+
NDB_ERR(pNdb->getNdbError());
140140
return NDBT_FAILED;
141141
}
142142

@@ -180,7 +180,7 @@ ScanInterpretTest::addRowToCheckTrans(Ndb* pNdb,
180180
break;
181181
}
182182
if(check != 0){
183-
ERR(pNdb->getNdbError());
183+
NDB_ERR(pNdb->getNdbError());
184184
return NDBT_FAILED;
185185
}
186186
}
@@ -213,30 +213,30 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
213213
if (pTrans == NULL) {
214214
const NdbError err = pNdb->getNdbError();
215215
if (err.status == NdbError::TemporaryError){
216-
ERR(err);
216+
NDB_ERR(err);
217217
NdbSleep_MilliSleep(50);
218218
retryAttempt++;
219219
continue;
220220
}
221-
ERR(err);
221+
NDB_ERR(err);
222222
return NDBT_FAILED;
223223
}
224224

225225
pOp = pTrans->getNdbScanOperation(tab.getName());
226226
if (pOp == NULL) {
227-
ERR(pTrans->getNdbError());
227+
NDB_ERR(pTrans->getNdbError());
228228
pNdb->closeTransaction(pTrans);
229229
return NDBT_FAILED;
230230
}
231231

232232
if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
233-
ERR(pTrans->getNdbError());
233+
NDB_ERR(pTrans->getNdbError());
234234
pNdb->closeTransaction(pTrans);
235235
return NDBT_FAILED;
236236
}
237237

238238
if (filter.filterOp(pOp) != 0){
239-
ERR(pTrans->getNdbError());
239+
NDB_ERR(pTrans->getNdbError());
240240
pNdb->closeTransaction(pTrans);
241241
return NDBT_FAILED;
242242
}
@@ -245,14 +245,14 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
245245
for(int a = 0; a<tab.getNoOfColumns(); a++){
246246
if((row.attributeStore(a) =
247247
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
248-
ERR(pTrans->getNdbError());
248+
NDB_ERR(pTrans->getNdbError());
249249
pNdb->closeTransaction(pTrans);
250250
return NDBT_FAILED;
251251
}
252252
}
253253
check = pTrans->execute(NoCommit);
254254
if( check == -1 ) {
255-
ERR(pTrans->getNdbError());
255+
NDB_ERR(pTrans->getNdbError());
256256
pNdb->closeTransaction(pTrans);
257257
return NDBT_FAILED;
258258
}
@@ -272,7 +272,7 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
272272
check = pTrans->execute(Commit);
273273
if( check == -1 ) {
274274
const NdbError err = pTrans->getNdbError();
275-
ERR(err);
275+
NDB_ERR(err);
276276
pNdb->closeTransaction(pTrans);
277277
return NDBT_FAILED;
278278
}
@@ -281,13 +281,13 @@ ScanInterpretTest::scanRead(Ndb* pNdb,
281281
const NdbError err = pTrans->getNdbError();
282282

283283
if (err.status == NdbError::TemporaryError){
284-
ERR(err);
284+
NDB_ERR(err);
285285
pNdb->closeTransaction(pTrans);
286286
NdbSleep_MilliSleep(50);
287287
retryAttempt++;
288288
continue;
289289
}
290-
ERR(err);
290+
NDB_ERR(err);
291291
pNdb->closeTransaction(pTrans);
292292
return NDBT_FAILED;
293293
}
@@ -325,30 +325,30 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
325325
if (pTrans == NULL) {
326326
const NdbError err = pNdb->getNdbError();
327327
if (err.status == NdbError::TemporaryError){
328-
ERR(err);
328+
NDB_ERR(err);
329329
NdbSleep_MilliSleep(50);
330330
retryAttempt++;
331331
continue;
332332
}
333-
ERR(err);
333+
NDB_ERR(err);
334334
return NDBT_FAILED;
335335
}
336336

337337

338338
pOp = pTrans->getNdbScanOperation(tab.getName());
339339
if (pOp == NULL) { if (pOp->getValue("KOL2") == 0){
340-
ERR(pNdb->getNdbError());
340+
NDB_ERR(pNdb->getNdbError());
341341
return NDBT_FAILED;
342342
}
343343

344344

345-
ERR(pTrans->getNdbError());
345+
NDB_ERR(pTrans->getNdbError());
346346
pNdb->closeTransaction(pTrans);
347347
return NDBT_FAILED;
348348
}
349349

350350
if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
351-
ERR(pTrans->getNdbError());
351+
NDB_ERR(pTrans->getNdbError());
352352
pNdb->closeTransaction(pTrans);
353353
return NDBT_FAILED;
354354
}
@@ -357,14 +357,14 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
357357
for(int a = 0; a<tab.getNoOfColumns(); a++){
358358
if((row.attributeStore(a) =
359359
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
360-
ERR(pTrans->getNdbError());
360+
NDB_ERR(pTrans->getNdbError());
361361
pNdb->closeTransaction(pTrans);
362362
return NDBT_FAILED;
363363
}
364364
}
365365
check = pTrans->execute(NoCommit);
366366
if( check == -1 ) {
367-
ERR(pTrans->getNdbError());
367+
NDB_ERR(pTrans->getNdbError());
368368
pNdb->closeTransaction(pTrans);
369369
return NDBT_FAILED;
370370
}
@@ -384,13 +384,13 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
384384
pExistTrans = pNdb->startTransaction();
385385
if (pExistTrans == NULL) {
386386
const NdbError err = pNdb->getNdbError();
387-
ERR(err);
387+
NDB_ERR(err);
388388
return NDBT_FAILED;
389389
}
390390
pNoExistTrans = pNdb->startTransaction();
391391
if (pNoExistTrans == NULL) {
392392
const NdbError err = pNdb->getNdbError();
393-
ERR(err);
393+
NDB_ERR(err);
394394
return NDBT_FAILED;
395395
}
396396
do {
@@ -420,7 +420,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
420420
check = pExistTrans->execute(Commit);
421421
if( check == -1 ) {
422422
const NdbError err = pExistTrans->getNdbError();
423-
ERR(err);
423+
NDB_ERR(err);
424424
if (err.code != 626){
425425
pNdb->closeTransaction(pExistTrans);
426426
pNdb->closeTransaction(pNoExistTrans);
@@ -441,7 +441,7 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
441441
const NdbError err = pNoExistTrans->getNdbError();
442442
// The transactions error code should be zero
443443
if (err.code != 626){
444-
ERR(err);
444+
NDB_ERR(err);
445445
pNdb->closeTransaction(pNoExistTrans);
446446
pNdb->closeTransaction(pTrans);
447447
return NDBT_FAILED;
@@ -466,13 +466,13 @@ ScanInterpretTest::scanReadVerify(Ndb* pNdb,
466466
const NdbError err = pTrans->getNdbError();
467467

468468
if (err.status == NdbError::TemporaryError){
469-
ERR(err);
469+
NDB_ERR(err);
470470
pNdb->closeTransaction(pTrans);
471471
NdbSleep_MilliSleep(50);
472472
retryAttempt++;
473473
continue;
474474
}
475-
ERR(err);
475+
NDB_ERR(err);
476476
pNdb->closeTransaction(pTrans);
477477
return NDBT_FAILED;
478478
}

0 commit comments

Comments
 (0)