/* Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License, version 2.0, as published by the Free Software Foundation. This program is also distributed with certain software (including but not limited to OpenSSL) that is licensed under separate terms, as designated in a particular file or component or in included license documentation. The authors of MySQL hereby grant you an additional permission to link the program and your derivative works with the separately licensed software that they have included with MySQL. 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, version 2.0, 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include #include #include struct OperationTestCase { const char * name; bool preCond; // start transaction | insert | commit // start transaction 1 const char * op1; const int val1; // no commit // start transaction 2 const char * op2; const int res2; const int val2; // no commit // commit transaction 1 // commit transaction 2 // start transaction // op3 = READ const int res3; const int val3; // commit transaction }; #define X -1 /** * //XX1 - SimpleRead can read either of primary/backup replicas * but uses locks. * This means that combination of S-READ and ReadEx/ScanEx * will yield different result depending on which TC-node the S-READ * is started... * * NOTE: S-READ vs DML is not unpredictable as DML locks both replicas * * Therefor those combinations are removed from the matrix */ OperationTestCase matrix[] = { { "ReadRead", true, "READ", 1, "READ", 0, 1, 0, 1 }, { "ReadReadEx", true, "READ", 1, "READ-EX", 266, X, 0, 1 }, { "ReadSimpleRead", true, "READ", 1, "S-READ", 0, 1, 0, 1 }, { "ReadDirtyRead", true, "READ", 1, "D-READ", 0, 1, 0, 1 }, { "ReadInsert", true, "READ", 1, "INSERT", 266, X, 0, 1 }, { "ReadUpdate", true, "READ", 1, "UPDATE", 266, X, 0, 1 }, { "ReadDelete", true, "READ", 1, "DELETE", 266, X, 0, 1 }, { "ReadScan", true, "READ", 1, "SCAN", 0, 1, 0, 1 }, { "ReadScanHl", true, "READ", 1, "SCAN-HL", 0, 1, 0, 1 }, { "ReadScanEx", true, "READ", 1, "SCAN-EX", 274, X, 0, 1 }, #if 0 { "ReadScanUp", true, "READ", 1, "SCAN-UP", 266, X, 0, 1 }, { "ReadScanDe", true, "READ", 1, "SCAN-DE", 266, X, 0, 1 }, #endif { "ScanRead", true, "SCAN", 1, "READ", 0, 1, 0, 1 }, { "ScanReadEx", true, "SCAN", 1, "READ-EX", 0, 1, 0, 1 }, { "ScanSimpleRead", true, "SCAN", 1, "S-READ", 0, 1, 0, 1 }, { "ScanDirtyRead", true, "SCAN", 1, "D-READ", 0, 1, 0, 1 }, { "ScanInsert", true, "SCAN", 1, "INSERT", 630, X, 0, 1 }, { "ScanUpdate", true, "SCAN", 1, "UPDATE", 0, 2, 0, 2 }, { "ScanDelete", true, "SCAN", 1, "DELETE", 0, X, 626, X }, { "ScanScan", true, "SCAN", 1, "SCAN", 0, 1, 0, 1 }, { "ScanScanHl", true, "SCAN", 1, "SCAN-HL", 0, 1, 0, 1 }, { "ScanScanEx", true, "SCAN", 1, "SCAN-EX", 0, 1, 0, 1 }, #if 0 { "ScanScanUp", true, "SCAN", 1, "SCAN-UP", 266, X, 0, 1 }, { "ScanScanDe", true, "SCAN", 1, "SCAN-DE", 266, X, 0, 1 }, #endif { "ScanHlRead", true, "SCAN-HL",1, "READ", 0, 1, 0, 1 }, { "ScanHlReadEx", true, "SCAN-HL",1, "READ-EX", 266, 1, 0, 1 }, { "ScanHlSimpleRead", true, "SCAN-HL",1, "S-READ", 0, 1, 0, 1 }, { "ScanHlDirtyRead", true, "SCAN-HL",1, "D-READ", 0, 1, 0, 1 }, { "ScanHlInsert", true, "SCAN-HL",1, "INSERT", 266, X, 0, 1 }, { "ScanHlUpdate", true, "SCAN-HL",1, "UPDATE", 266, 2, 0, 1 }, { "ScanHlDelete", true, "SCAN-HL",1, "DELETE", 266, X, 0, 1 }, { "ScanHlScan", true, "SCAN-HL",1, "SCAN", 0, 1, 0, 1 }, { "ScanHlScanHl", true, "SCAN-HL",1, "SCAN-HL", 0, 1, 0, 1 }, { "ScanHlScanEx", true, "SCAN-HL",1, "SCAN-EX", 274, X, 0, 1 }, #if 0 { "ScanHlScanUp", true, "SCAN-HL",1, "SCAN-UP", 266, X, 0, 1 }, { "ScanHlScanDe", true, "SCAN-HL",1, "SCAN-DE", 266, X, 0, 1 }, #endif { "ScanExRead", true, "SCAN-EX",1, "READ", 266, 1, 0, 1 }, { "ScanExReadEx", true, "SCAN-EX",1, "READ-EX", 266, 1, 0, 1 }, //XX1 { "ScanExSimpleRead", true, "SCAN-EX",1, "S-READ", 266, 1, 0, 1 }, { "ScanExDirtyRead", true, "SCAN-EX",1, "D-READ", 0, 1, 0, 1 }, { "ScanExInsert", true, "SCAN-EX",1, "INSERT", 266, X, 0, 1 }, { "ScanExUpdate", true, "SCAN-EX",1, "UPDATE", 266, 2, 0, 1 }, { "ScanExDelete", true, "SCAN-EX",1, "DELETE", 266, X, 0, 1 }, { "ScanExScan", true, "SCAN-EX",1, "SCAN", 0, 1, 0, 1 }, { "ScanExScanHl", true, "SCAN-EX",1, "SCAN-HL", 274, X, 0, 1 }, { "ScanExScanEx", true, "SCAN-EX",1, "SCAN-EX", 274, X, 0, 1 }, #if 0 { "ScanExScanUp", true, "SCAN-EX",1, "SCAN-UP", 266, X, 0, 1 }, { "ScanExScanDe", true, "SCAN-EX",1, "SCAN-DE", 266, X, 0, 1 }, #endif { "SimpleReadRead", true, "S-READ", 1, "READ", 0, 1, 0, 1 }, { "SimpleReadReadEx", true, "S-READ", 1, "READ-EX", 0, 1, 0, 1 }, // no lock held { "SimpleReadSimpleRead", true, "S-READ", 1, "S-READ", 0, 1, 0, 1 }, { "SimpleReadDirtyRead", true, "S-READ", 1, "D-READ", 0, 1, 0, 1 }, { "SimpleReadInsert", true, "S-READ", 1, "INSERT", 630, X, 0, 1 }, // no lock held { "SimpleReadUpdate", true, "S-READ", 1, "UPDATE", 0, 2, 0, 2 }, // no lock held { "SimpleReadDelete", true, "S-READ", 1, "DELETE", 0, X, 626, X }, // no lock held { "SimpleReadScan", true, "S-READ", 1, "SCAN", 0, 1, 0, 1 }, { "SimpleReadScanHl", true, "S-READ", 1, "SCAN-HL", 0, 1, 0, 1 }, { "SimpleReadScanEx", true, "S-READ", 1, "SCAN-EX", 0, 1, 0, 1 }, // no lock held #if 0 { "SimpleReadScanUp", true, "S-READ", 1, "SCAN-UP", 0, 1, 0, 2 }, // no lock held { "SimpleReadScanDe", true, "S-READ", 1, "SCAN-DE", 0, X, 626, X }, // no lock held #endif { "ReadExRead", true, "READ-EX",1, "READ", 266, X, 0, 1 }, { "ReadExReadEx", true, "READ-EX",1, "READ-EX", 266, X, 0, 1 }, //XX1 { "ReadExSimpleRead", true, "READ-EX",1, "S-READ", 266, X, 0, 1 }, { "ReadExDirtyRead", true, "READ-EX",1, "D-READ", 0, 1, 0, 1 }, { "ReadExInsert", true, "READ-EX",1, "INSERT", 266, X, 0, 1 }, { "ReadExUpdate", true, "READ-EX",1, "UPDATE", 266, X, 0, 1 }, { "ReadExDelete", true, "READ-EX",1, "DELETE", 266, X, 0, 1 }, { "ReadExScan", true, "READ-EX",1, "SCAN", 0, 1, 0, 1 }, { "ReadExScanHl", true, "READ-EX",1, "SCAN-HL", 274, X, 0, 1 }, { "ReadExScanEx", true, "READ-EX",1, "SCAN-EX", 274, X, 0, 1 }, #if 0 { "ReadExScanUp", true, "READ-EX",1, "SCAN-UP", 266, X, 0, 1 }, { "ReadExScanDe", true, "READ-EX",1, "SCAN-DE", 266, X, 0, 1 }, #endif { "InsertRead", false, "INSERT", 1, "READ", 266, X, 0, 1 }, { "InsertReadEx", false, "INSERT", 1, "READ-EX", 266, X, 0, 1 }, { "InsertSimpleRead",false, "INSERT", 1, "S-READ", 266, X, 0, 1 }, { "InsertDirtyRead", false, "INSERT", 1, "D-READ", 626, X, 0, 1 }, { "InsertInsert", false, "INSERT", 1, "INSERT", 266, X, 0, 1 }, { "InsertUpdate", false, "INSERT", 1, "UPDATE", 266, X, 0, 1 }, { "InsertDelete", false, "INSERT", 1, "DELETE", 266, X, 0, 1 }, { "InsertScan", false, "INSERT", 1, "SCAN", 626, X, 0, 1 }, { "InsertScanHl", false, "INSERT", 1, "SCAN-HL", 274, X, 0, 1 }, { "InsertScanEx", false, "INSERT", 1, "SCAN-EX", 274, X, 0, 1 }, #if 0 { "InsertScanUp", false, "INSERT", 1, "SCAN-UP", 266, X, 0, 1 }, { "InsertScanDe", false, "INSERT", 1, "SCAN-DE", 266, X, 0, 1 }, #endif { "UpdateRead", true, "UPDATE", 2, "READ", 266, X, 0, 2 }, { "UpdateReadEx", true, "UPDATE", 2, "READ-EX", 266, X, 0, 2 }, { "UpdateSimpleRead", true, "UPDATE", 2, "S-READ", 266, X, 0, 2 }, { "UpdateDirtyRead", true, "UPDATE", 2, "D-READ", 0, 1, 0, 2 }, { "UpdateInsert", true, "UPDATE", 2, "INSERT", 266, X, 0, 2 }, { "UpdateUpdate", true, "UPDATE", 2, "UPDATE", 266, X, 0, 2 }, { "UpdateDelete", true, "UPDATE", 2, "DELETE", 266, X, 0, 2 }, { "UpdateScan", true, "UPDATE", 2, "SCAN", 0, 1, 0, 2 }, { "UpdateScanHl", true, "UPDATE", 2, "SCAN-HL", 274, X, 0, 2 }, { "UpdateScanEx", true, "UPDATE", 2, "SCAN-EX", 274, X, 0, 2 }, #if 0 { "UpdateScanUp", true, "UPDATE", 2, "SCAN-UP", 266, X, 0, 2 }, { "UpdateScanDe", true, "UPDATE", 2, "SCAN-DE", 266, X, 0, 2 }, #endif { "DeleteRead", true, "DELETE", X, "READ", 266, X, 626, X }, { "DeleteReadEx", true, "DELETE", X, "READ-EX", 266, X, 626, X }, { "DeleteSimpleRead", true, "DELETE", X, "S-READ", 266, X, 626, X }, { "DeleteDirtyRead", true, "DELETE", X, "D-READ", 0, 1, 626, X }, { "DeleteInsert", true, "DELETE", X, "INSERT", 266, X, 626, X }, { "DeleteUpdate", true, "DELETE", X, "UPDATE", 266, X, 626, X }, { "DeleteDelete", true, "DELETE", X, "DELETE", 266, X, 626, X }, { "DeleteScan", true, "DELETE", X, "SCAN", 0, 1, 626, X }, { "DeleteScanHl", true, "DELETE", X, "SCAN-HL", 274, X, 626, X }, { "DeleteScanEx", true, "DELETE", X, "SCAN-EX", 274, X, 626, X }, #if 0 { "DeleteScanUp", true, "DELETE", X, "SCAN-UP", 266, X, 626, X }, { "DeleteScanDe", true, "DELETE", X, "SCAN-DE", 266, X, 626, X } #endif }; #define CHECK(a, b) { int x = a; int y = b; if (x != y) { \ g_err << "ERR: "<< step->getName() \ << " failed on line " << __LINE__ << endl << " " \ << x << " != " << y << endl;\ result = NDBT_FAILED; \ break; } } int runOp(HugoOperations & hugoOps, Ndb * pNdb, const char * op, int value){ #define C2(x) if(!(x)) {\ g_err << "ERR: failed on line " << __LINE__ << endl; \ return NDBT_FAILED; } if(strcmp(op, "READ") == 0){ C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0); } else if(strcmp(op, "READ-EX") == 0){ C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); } else if(strcmp(op, "S-READ") == 0){ C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_SimpleRead) == 0); } else if(strcmp(op, "D-READ") == 0){ C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_CommittedRead) == 0); } else if(strcmp(op, "INSERT") == 0){ C2(hugoOps.pkInsertRecord(pNdb, 1, 1, value) == 0); } else if(strcmp(op, "UPDATE") == 0){ C2(hugoOps.pkUpdateRecord(pNdb, 1, 1, value) == 0); } else if(strcmp(op, "DELETE") == 0){ C2(hugoOps.pkDeleteRecord(pNdb, 1, 1) == 0); } else if(strcmp(op, "SCAN") == 0){ C2(hugoOps.scanReadRecords(pNdb) == 0); } else if(strcmp(op, "SCAN-HL") == 0){ C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Read)== 0); } else if(strcmp(op, "SCAN-EX") == 0){ C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Exclusive)== 0); } else { g_err << __FILE__ << " - " << __LINE__ << ": Unknown operation" << op << endl; return NDBT_FAILED; } return NDBT_OK; } int checkVal(HugoOperations & hugoOps, const char * op, int value, int result){ if(result != 0) return NDBT_OK; if(strcmp(op, "READ") == 0){ } else if(strcmp(op, "READ-EX") == 0){ } else if(strcmp(op, "S-READ") == 0){ } else if(strcmp(op, "D-READ") == 0){ } else if(strcmp(op, "SCAN") == 0){ } else if(strcmp(op, "SCAN-HL") == 0){ } else if(strcmp(op, "SCAN-EX") == 0){ } else { return NDBT_OK; } return hugoOps.verifyUpdatesValue(value); } #define SHORT_TIMEOUT (Uint32)100 #define DEFAULT_TIMEOUT (Uint32)3000 int setShortTransactionTimeout(NDBT_Context* ctx, NDBT_Step* step){ NdbRestarter restarter; int val[] = { DumpStateOrd::TcSetTransactionTimeout, SHORT_TIMEOUT }; if(restarter.dumpStateAllNodes(val, 2) != 0){ return NDBT_FAILED; } return NDBT_OK; } int setDefaultTransactionTimeout(NDBT_Context* ctx, NDBT_Step* step){ NdbRestarter restarter; int val[] = { DumpStateOrd::TcSetTransactionTimeout, DEFAULT_TIMEOUT }; if(restarter.dumpStateAllNodes(val, 2) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runTwoTrans1(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations T1(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const char * op1 = ctx->getProperty("op1", "NONE"); int val1 = ctx->getProperty("val1", ~0); do { // Insert, read CHECK(T1.startTransaction(pNdb), 0); CHECK(runOp(T1, pNdb, op1, val1), 0); CHECK(T1.execute_NoCommit(pNdb), 0); CHECK(checkVal(T1, op1, val1, 0), 0); ctx->setProperty("T1-1-Complete", 1); while(ctx->getProperty("T2-Complete", (Uint32)0) == 0){ T1.refresh(); NdbSleep_MilliSleep(10); } CHECK(T1.execute_Commit(pNdb), 0); } while(false); T1.closeTransaction(pNdb); if(result != NDBT_OK) return result; const int res3 = ctx->getProperty("res3", ~0); const int val3 = ctx->getProperty("val3", ~0); do { CHECK(T1.startTransaction(pNdb), 0); CHECK(runOp(T1, pNdb, "READ", 0), 0); CHECK(T1.execute_Commit(pNdb), res3); CHECK(checkVal(T1, "READ", val3, res3), 0); } while(false); T1.closeTransaction(pNdb); return result; } int runTwoTrans2(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations T2(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const char * op2 = ctx->getProperty("op2", "NONE"); const int res2 = ctx->getProperty("res2", ~0); const int val2 = ctx->getProperty("val2", ~0); while(ctx->getProperty("T1-1-Complete", (Uint32)0) == 0 && !ctx->isTestStopped()){ NdbSleep_MilliSleep(10); } if(!ctx->isTestStopped()){ do { if (res2==266 || res2==274){ //Expecting timeout CHECK(setShortTransactionTimeout(ctx, step), NDBT_OK); } CHECK(T2.startTransaction(pNdb), 0); CHECK(runOp(T2, pNdb, op2, val2), 0); CHECK(T2.execute_NoCommit(pNdb), res2); CHECK(checkVal(T2, op2, val2, res2), 0); if(res2 == 0){ CHECK(T2.execute_Commit(pNdb), res2); } } while(false); T2.closeTransaction(pNdb); if (res2==266 || res2==274){ //Restore default timeout setDefaultTransactionTimeout(ctx, step); } } ctx->setProperty("T2-Complete", 1); return result; } int runInsertRecord(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Insert, insert CHECK(hugoOps.startTransaction(pNdb), 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1, 1, 1), 0); CHECK(hugoOps.execute_Commit(pNdb), 0); } while(false); hugoOps.closeTransaction(pNdb); return result; } int runClearTable(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); UtilTransactions utilTrans(*ctx->getTab()); if (utilTrans.clearTable2(GETNDB(step), records, 240) != 0){ return NDBT_FAILED; } NdbRestarter r; int lcp = 7099; r.dumpStateAllNodes(&lcp, 1); return NDBT_OK; } int main(int argc, const char** argv){ ndb_init(); NDBT_TestSuite ts("testOperations"); ts.setTemporaryTables(true); for(Uint32 i = 0; iaddInitializer(new NDBT_Initializer(pt, "runClearTable", runClearTable)); if(matrix[i].preCond){ pt->addInitializer(new NDBT_Initializer(pt, "runInsertRecord", runInsertRecord)); } pt->setProperty("op1", matrix[i].op1); pt->setProperty("val1", matrix[i].val1); pt->setProperty("op2", matrix[i].op2); pt->setProperty("res2", matrix[i].res2); pt->setProperty("val2", matrix[i].val2); pt->setProperty("res3", matrix[i].res3); pt->setProperty("val3", matrix[i].val3); pt->addStep(new NDBT_ParallelStep(pt, matrix[i].name, runTwoTrans1)); pt->addStep(new NDBT_ParallelStep(pt, matrix[i].name, runTwoTrans2)); pt->addFinalizer(new NDBT_Finalizer(pt, "runClearTable", runClearTable)); ts.addTest(pt); } return ts.execute(argc, argv); }