From d20bcbac6cfa54750e2a7bbe2a8a78751081b68b Mon Sep 17 00:00:00 2001
From: unknown <joreland@mysql.com>
Date: Wed, 13 Oct 2004 11:28:24 +0200
Subject: testBasic -n NoCommit626

Handle commit of zero operations


ndb/test/ndbapi/testBasic.cpp:
  Update usage of HugoOperattions::pkReadRecord
  More test for IgnoreError
---
 ndb/src/kernel/blocks/dbtc/DbtcMain.cpp |  26 +++-----
 ndb/test/ndbapi/testBasic.cpp           | 108 ++++++++++++++++++--------------
 2 files changed, 67 insertions(+), 67 deletions(-)

(limited to 'ndb')

diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index f6e7b5895a4..3276e4e5bce 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -5107,27 +5107,15 @@ void Dbtc::execLQHKEYREF(Signal* signal)
        *---------------------------------------------------------------------*/
       regApiPtr->lqhkeyreqrec--;
       if (regApiPtr->lqhkeyconfrec == regApiPtr->lqhkeyreqrec) {
-	if ((regApiPtr->lqhkeyconfrec == 0) &&
-	    (regApiPtr->apiConnectstate == CS_START_COMMITTING)) {
-	  
-	  if(abort == TcKeyReq::IgnoreError){
+	if (regApiPtr->apiConnectstate == CS_START_COMMITTING) {
+	  if(regApiPtr->lqhkeyconfrec) {
 	    jam();
-	    regApiPtr->returnsignal = RS_NO_RETURN;
-	    abort010Lab(signal);
-	    return;
+	    diverify010Lab(signal);
+	  } else {
+	    jam();
+	    sendtckeyconf(signal, 1);
+	    regApiPtr->apiConnectstate = CS_CONNECTED;
 	  }
-	  
-	  /*----------------------------------------------------------------
-	   * Not a single operation was successful. 
-	   * This we report as an aborted transaction 
-	   * to avoid performing a commit of zero operations.
-	   *----------------------------------------------------------------*/
-	  TCKEY_abort(signal, 54);
-	  return;
-	}//if
-	if (regApiPtr->apiConnectstate == CS_START_COMMITTING) {
-	  jam();
-	  diverify010Lab(signal);
 	  return;
 	} else if (regApiPtr->tckeyrec > 0 || regApiPtr->m_exec_flag) {
 	  jam();
diff --git a/ndb/test/ndbapi/testBasic.cpp b/ndb/test/ndbapi/testBasic.cpp
index 4fa9ae77ca2..4d64b15ecfa 100644
--- a/ndb/test/ndbapi/testBasic.cpp
+++ b/ndb/test/ndbapi/testBasic.cpp
@@ -398,14 +398,14 @@ int runNoCommitSleep(NDBT_Context* ctx, NDBT_Step* step){
   for (int i = 2; i < 8; i++){
 
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
 
     ndbout << i <<": Sleeping for " << sleepTime << " ms" << endl;
     NdbSleep_MilliSleep(sleepTime);
 
     // Dont care about result of these ops
-    hugoOps.pkReadRecord(pNdb, 1, true);
+    hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive);
     hugoOps.closeTransaction(pNdb);
 
     sleepTime = sleepTime *i;
@@ -424,16 +424,16 @@ int runCommit626(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // Commit transaction
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb) == 626);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
 
     // Commit transaction
     // Multiple operations
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 2, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 3, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb) == 626);
   }while(false);
 
@@ -467,7 +467,7 @@ int runCommit_TryCommit626(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // Commit transaction, TryCommit
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
 
@@ -475,11 +475,11 @@ int runCommit_TryCommit626(NDBT_Context* ctx, NDBT_Step* step){
     // Several operations in one transaction
     // The insert is OK
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 2, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 3, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 4, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626);
   }while(false);
 
@@ -513,20 +513,23 @@ int runCommit_CommitAsMuchAsPossible626(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // Commit transaction, CommitAsMuchAsPossible
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
 
     // Commit transaction, CommitAsMuchAsPossible
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 2, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 3, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 4, true) == 0);
     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
-  }while(false);
+
+    CHECK(hugoOps.startTransaction(pNdb) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1) == 0);
+    CHECK(hugoOps.execute_Commit(pNdb) == 0);
+    CHECK(hugoOps.closeTransaction(pNdb) == 0);
+  } while(false);
 
   hugoOps.closeTransaction(pNdb);
 
@@ -542,8 +545,14 @@ int runCommit_CommitAsMuchAsPossible630(NDBT_Context* ctx, NDBT_Step* step){
     // Commit transaction, CommitAsMuchAsPossible
     CHECK(hugoOps.startTransaction(pNdb) == 0);
     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
+    CHECK(hugoOps.pkDeleteRecord(pNdb, 2) == 0);
     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 630);
-  }while(false);
+    CHECK(hugoOps.closeTransaction(pNdb) == 0);
+
+    CHECK(hugoOps.startTransaction(pNdb) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 2) == 0);
+    CHECK(hugoOps.execute_Commit(pNdb) == 0);
+  } while(false);
 
   hugoOps.closeTransaction(pNdb);
   
@@ -558,13 +567,13 @@ int runNoCommit626(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // No commit transaction, readTuple
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, false) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
 
     // No commit transaction, readTupleExcluive
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
   }while(false);
 
@@ -598,7 +607,7 @@ int runNoCommitRollback626(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // No commit transaction, rollback
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
@@ -606,10 +615,10 @@ int runNoCommitRollback626(NDBT_Context* ctx, NDBT_Step* step){
     // No commit transaction, rollback
     // Multiple operations
     CHECK(hugoOps.startTransaction(pNdb) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 1, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 2, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 3, true) == 0);
-    CHECK(hugoOps.pkReadRecord(pNdb, 4, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
   }while(false);
@@ -647,7 +656,7 @@ int runNoCommitAndClose(NDBT_Context* ctx, NDBT_Step* step){
     // Read 
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
     for (i = 0; i < 10; i++)
-      CHECK(hugoOps.pkReadRecord(pNdb, i, true) == 0);
+      CHECK(hugoOps.pkReadRecord(pNdb, i, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
   
@@ -701,7 +710,7 @@ int runCheckRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
 
     // Check record is deleted
-    CHECK(hugoOps.pkReadRecord(pNdb, 5, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
 
@@ -709,13 +718,13 @@ int runCheckRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
 
     // Check record is not deleted
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    CHECK(hugoOps.pkReadRecord(pNdb, 5, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb) == 0);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
 
     // Check record is back to original value
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    CHECK(hugoOps.pkReadRecord(pNdb, 5, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb) == 0);
     CHECK(hugoOps.compareRecordToCopy() == NDBT_OK);
 
@@ -853,7 +862,7 @@ int runCheckImplicitRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
   do{
     // Read  record 5
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    CHECK(hugoOps.pkReadRecord(pNdb, 5, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
     CHECK(hugoOps.closeTransaction(pNdb) == 0);
     
@@ -872,7 +881,7 @@ int runCheckImplicitRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
     // Check record is not deleted
     // Close transaction should have rollbacked
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    CHECK(hugoOps.pkReadRecord(pNdb, 5, true) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
     CHECK(hugoOps.execute_Commit(pNdb) == 0);
   }while(false);
 
@@ -964,8 +973,8 @@ int runMassiveRollback(NDBT_Context* ctx, NDBT_Step* step){
   for(int row = 0; row < records; row++){
     int res;
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    for(int i = 0; i<OPS_TOTAL; i += OPS_PER_TRANS){
-      for(int j = 0; j<OPS_PER_TRANS; j++){
+    for(Uint32 i = 0; i<OPS_TOTAL; i += OPS_PER_TRANS){
+      for(Uint32 j = 0; j<OPS_PER_TRANS; j++){
 	CHECK(hugoOps.pkUpdateRecord(pNdb, row, 1, i) == 0);
       }
       g_info << "Performed " << (i+OPS_PER_TRANS) << " updates on row: " << row
@@ -1007,9 +1016,9 @@ runMassiveRollback2(NDBT_Context* ctx, NDBT_Step* step){
   const Uint32 OPS_TOTAL = 4096;
   const Uint32 LOOPS = 10;
   
-  for(int loop = 0; loop<LOOPS; loop++){
+  for(Uint32 loop = 0; loop<LOOPS; loop++){
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    for(int i = 0; i<OPS_TOTAL-1; i ++){
+    for(Uint32 i = 0; i<OPS_TOTAL-1; i ++){
       if((i & 1) == 0){
 	CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, loop) == 0);
       } else {
@@ -1110,13 +1119,6 @@ TESTCASE("ReadWithLocksAndInserts",
   STEP(runInsertUntilStopped);
   FINALIZER(runClearTable);
 }
-TESTCASE("ReadConsistency",
-	 "Check that a read within a transaction returns the " \
-	 "same result no matter"){
-  STEP(runInsertOne);
-  STEP(runReadOne);
-  FINALIZER(runClearTable2);
-}
 TESTCASE("PkInsertTwice", 
 	 "Verify that we can't insert an already inserted record."
 	 "Error should be returned" ){
@@ -1124,12 +1126,6 @@ TESTCASE("PkInsertTwice",
   STEP(runInsertTwice);
   FINALIZER(runClearTable);
 }
-TESTCASE("Fill", 
-	 "Verify what happens when we fill the db" ){
-  INITIALIZER(runFillTable);
-  INITIALIZER(runPkRead);
-  FINALIZER(runClearTable2);
-}
 TESTCASE("NoCommitSleep", 
 	 "Verify what happens when a NoCommit transaction is aborted by "
 	 "NDB because the application is sleeping" ){
@@ -1275,8 +1271,24 @@ TESTCASE("MassiveTransaction",
   INITIALIZER(runLoadTable2);
   FINALIZER(runClearTable2);
 }
+TESTCASE("Fill", 
+	 "Verify what happens when we fill the db" ){
+  INITIALIZER(runFillTable);
+  INITIALIZER(runPkRead);
+  FINALIZER(runClearTable2);
+}
 NDBT_TESTSUITE_END(testBasic);
 
+#if 0
+TESTCASE("ReadConsistency",
+	 "Check that a read within a transaction returns the " \
+	 "same result no matter"){
+  STEP(runInsertOne);
+  STEP(runReadOne);
+  FINALIZER(runClearTable2);
+}
+#endif
+
 int main(int argc, const char** argv){
   ndb_init();
   return testBasic.execute(argc, argv);
-- 
cgit v1.2.1