The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/storage/ndb/ndbapi-examples/ndbapi_scan/ndbapi_scan.cpp File Reference

mysql/src/5.1-dbg/storage/ndb/ndbapi-examples/ndbapi_scan/ndbapi_scan.cpp File Reference

#include <mysql.h>
#include <mysqld_error.h>
#include <NdbApi.hpp>
#include <iostream>
#include <stdio.h>

Include dependency graph for ndbapi_scan.cpp:


Classes
struct	Car
Defines
#define	PRINT_ERROR(code, msg)
#define	MYSQLERROR(mysql)
#define	APIERROR(error)
Functions
static void	milliSleep (int milliseconds)
int	create_table (MYSQL &mysql)
int	populate (Ndb *myNdb)
int	scan_delete (Ndb myNdb, int column, const char color)
int	scan_update (Ndb myNdb, int update_column, const char before_color, const char *after_color)
int	scan_print (Ndb *myNdb)
int	main ()

Define Documentation

#define APIERROR ( error )

Value:

{ \
  PRINT_ERROR(error.code,error.message); \
  exit(-1); }

Definition at line 99 of file ndbapi_scan.cpp.

#define MYSQLERROR ( mysql )

Value:

{ \
  PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
  exit(-1); }

Definition at line 96 of file ndbapi_scan.cpp.

#define PRINT_ERROR	(	code,
		msg		)

Value:

std::cout << "Error in " << __FILE__ << ", line: " << __LINE__ \
            << ", code: " << code \
            << ", msg: " << msg << "." << std::endl

Helper sleep function

Definition at line 92 of file ndbapi_scan.cpp.

Function Documentation

int create_table ( MYSQL & mysql )

Function to create table

Definition at line 119 of file ndbapi_scan.cpp.

References ER_TABLE_EXISTS_ERROR, mysql, mysql_errno(), mysql_query(), and MYSQLERROR.

00120 {
00121   while (mysql_query(&mysql, 
00122                   "CREATE TABLE"
00123                   "  GARAGE"
00124                   "    (REG_NO INT UNSIGNED NOT NULL,"
00125                   "     BRAND CHAR(20) NOT NULL,"
00126                   "     COLOR CHAR(20) NOT NULL,"
00127                   "     PRIMARY KEY USING HASH (REG_NO))"
00128                   "  ENGINE=NDB"))
00129   {
00130     if (mysql_errno(&mysql) != ER_TABLE_EXISTS_ERROR)
00131       MYSQLERROR(mysql);
00132     std::cout << "MySQL Cluster already has example table: GARAGE. "
00133               << "Dropping it..." << std::endl; 
00134     /**************
00135      * Drop table *
00136      **************/
00137     if (mysql_query(&mysql, "DROP TABLE GARAGE"))
00138       MYSQLERROR(mysql);
00139   }
00140   return 1;
00141 }

Here is the call graph for this function:

int main ( void )

Definition at line 724 of file ndbapi_scan.cpp.

References APIERROR, Car::brand, Car::color, Ndb_cluster_connection::connect(), create_table(), exit, NdbDictionary::Table::getColumn(), Ndb::getDictionary(), Ndb::getNdbError(), NdbDictionary::Dictionary::getTable(), Ndb::init(), mysql, mysql_init(), mysql_query(), mysql_real_connect(), MYSQLERROR, ndb_init(), populate(), scan_delete(), scan_print(), scan_update(), and Ndb_cluster_connection::wait_until_ready().

00725 {
00726   ndb_init();
00727   MYSQL mysql;
00728 
00729   /**************************************************************
00730    * Connect to mysql server and create table                   *
00731    **************************************************************/
00732   {
00733     if ( !mysql_init(&mysql) ) {
00734       std::cout << "mysql_init failed\n";
00735       exit(-1);
00736     }
00737     if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
00738                              3306, "/tmp/mysql.sock", 0) )
00739       MYSQLERROR(mysql);
00740 
00741     mysql_query(&mysql, "CREATE DATABASE TEST_DB");
00742     if (mysql_query(&mysql, "USE TEST_DB") != 0) MYSQLERROR(mysql);
00743 
00744     create_table(mysql);
00745   }
00746 
00747   /**************************************************************
00748    * Connect to ndb cluster                                     *
00749    **************************************************************/
00750 
00751   Ndb_cluster_connection cluster_connection;
00752   if (cluster_connection.connect(4, 5, 1))
00753   {
00754     std::cout << "Unable to connect to cluster within 30 secs." << std::endl;
00755     exit(-1);
00756   }
00757   // Optionally connect and wait for the storage nodes (ndbd's)
00758   if (cluster_connection.wait_until_ready(30,0) < 0)
00759   {
00760     std::cout << "Cluster was not ready within 30 secs.\n";
00761     exit(-1);
00762   }
00763 
00764   Ndb myNdb(&cluster_connection,"TEST_DB");
00765   if (myNdb.init(1024) == -1) {      // Set max 1024  parallel transactions
00766     APIERROR(myNdb.getNdbError());
00767     exit(-1);
00768   }
00769 
00770   /*******************************************
00771    * Check table definition                  *
00772    *******************************************/
00773   int column_color;
00774   {
00775     const NdbDictionary::Dictionary* myDict= myNdb.getDictionary();
00776     const NdbDictionary::Table *t= myDict->getTable("GARAGE");
00777 
00778     Car car;
00779     if (t->getColumn("COLOR")->getLength() != sizeof(car.color) ||
00780         t->getColumn("BRAND")->getLength() != sizeof(car.brand))
00781     {
00782       std::cout << "Wrong table definition" << std::endl;
00783       exit(-1);
00784     }
00785     column_color= t->getColumn("COLOR")->getColumnNo();
00786   }
00787 
00788   if(populate(&myNdb) > 0)
00789     std::cout << "populate: Success!" << std::endl;
00790   
00791   if(scan_print(&myNdb) > 0)
00792     std::cout << "scan_print: Success!" << std::endl  << std::endl;
00793   
00794   std::cout << "Going to delete all pink cars!" << std::endl;
00795   
00796   {
00800     Car tmp;
00801     sprintf(tmp.color, "Pink");
00802     if(scan_delete(&myNdb, column_color, tmp.color) > 0)
00803       std::cout << "scan_delete: Success!" << std::endl  << std::endl;
00804   }
00805 
00806   if(scan_print(&myNdb) > 0)
00807     std::cout << "scan_print: Success!" << std::endl  << std::endl;
00808   
00809   {
00813     Car tmp1, tmp2;
00814     sprintf(tmp1.color, "Blue");
00815     sprintf(tmp2.color, "Black");
00816     std::cout << "Going to update all " << tmp1.color 
00817               << " cars to " << tmp2.color << " cars!" << std::endl;
00818     if(scan_update(&myNdb, column_color, tmp1.color, tmp2.color) > 0) 
00819       std::cout << "scan_update: Success!" << std::endl  << std::endl;
00820   }
00821   if(scan_print(&myNdb) > 0)
00822     std::cout << "scan_print: Success!" << std::endl  << std::endl;
00823 
00824   return 0;
00825 }

Here is the call graph for this function:

static void milliSleep ( int milliseconds ) [static]

Helper sleep function

Definition at line 81 of file ndbapi_scan.cpp.

00081                             {
00082   struct timeval sleeptime;
00083   sleeptime.tv_sec = milliseconds / 1000;
00084   sleeptime.tv_usec = (milliseconds - (sleeptime.tv_sec * 1000)) * 1000000;
00085   select(0, 0, 0, 0, &sleeptime);
00086 }

int populate ( Ndb * myNdb )

Definition at line 144 of file ndbapi_scan.cpp.

References APIERROR, check(), NdbTransaction::close(), NdbTransaction::Commit, NdbTransaction::execute(), Ndb::getDictionary(), NdbTransaction::getNdbError(), Ndb::getNdbError(), NdbDictionary::Dictionary::getNdbError(), NdbTransaction::getNdbOperation(), NdbDictionary::Dictionary::getTable(), NULL, and Ndb::startTransaction().

00145 {
00146   int i;
00147   Car cars[15];
00148 
00149   const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
00150   const NdbDictionary::Table *myTable= myDict->getTable("GARAGE");
00151 
00152   if (myTable == NULL) 
00153     APIERROR(myDict->getNdbError());
00154 
00158   for (i = 0; i < 5; i++)
00159   {
00160     cars[i].reg_no = i;
00161     sprintf(cars[i].brand, "Mercedes");
00162     sprintf(cars[i].color, "Blue");
00163   }
00164 
00168   for (i = 5; i < 10; i++)
00169   {
00170     cars[i].reg_no = i;
00171     sprintf(cars[i].brand, "BMW");
00172     sprintf(cars[i].color, "Black");
00173   }
00174 
00178   for (i = 10; i < 15; i++)
00179   {
00180     cars[i].reg_no = i;
00181     sprintf(cars[i].brand, "Toyota");
00182     sprintf(cars[i].color, "Pink");
00183   }
00184   
00185   NdbTransaction* myTrans = myNdb->startTransaction();
00186   if (myTrans == NULL)
00187     APIERROR(myNdb->getNdbError());
00188 
00189   for (i = 0; i < 15; i++) 
00190   {
00191     NdbOperation* myNdbOperation = myTrans->getNdbOperation(myTable);
00192     if (myNdbOperation == NULL) 
00193       APIERROR(myTrans->getNdbError());
00194     myNdbOperation->insertTuple();
00195     myNdbOperation->equal("REG_NO", cars[i].reg_no);
00196     myNdbOperation->setValue("BRAND", cars[i].brand);
00197     myNdbOperation->setValue("COLOR", cars[i].color);
00198   }
00199 
00200   int check = myTrans->execute(NdbTransaction::Commit);
00201 
00202   myTrans->close();
00203 
00204   return check != -1;
00205 }

Here is the call graph for this function:

int scan_delete	(	Ndb *	myNdb,
		int	column,
		const char *	color
	)

Definition at line 207 of file ndbapi_scan.cpp.

References NdbScanFilter::AND, APIERROR, NdbScanFilter::begin(), check(), Ndb::closeTransaction(), NdbScanFilter::cmp(), NdbError::code, NdbTransaction::Commit, NdbScanFilter::COND_EQ, NdbScanOperation::deleteCurrentTuple(), NdbScanFilter::end(), err, NdbTransaction::execute(), Ndb::getDictionary(), NdbTransaction::getNdbError(), Ndb::getNdbError(), NdbDictionary::Dictionary::getNdbError(), NdbTransaction::getNdbScanOperation(), NdbDictionary::Dictionary::getTable(), NdbOperation::LM_Exclusive, NdbError::message, milliSleep(), NdbScanOperation::nextResult(), NdbTransaction::NoCommit, NULL, NdbScanOperation::readTuples(), NdbTransaction::restart(), Ndb::startTransaction(), NdbError::status, and NdbError::TemporaryError.

Referenced by main().

00211 {
00212   
00213   // Scan all records exclusive and delete 
00214   // them one by one
00215   int                  retryAttempt = 0;
00216   const int            retryMax = 10;
00217   int deletedRows = 0;
00218   int check;
00219   NdbError              err;
00220   NdbTransaction        *myTrans;
00221   NdbScanOperation      *myScanOp;
00222 
00223   const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
00224   const NdbDictionary::Table *myTable= myDict->getTable("GARAGE");
00225 
00226   if (myTable == NULL) 
00227     APIERROR(myDict->getNdbError());
00228 
00238   while (true)
00239   {
00240     if (retryAttempt >= retryMax)
00241     {
00242       std::cout << "ERROR: has retried this operation " << retryAttempt 
00243                 << " times, failing!" << std::endl;
00244       return -1;
00245     }
00246 
00247     myTrans = myNdb->startTransaction();
00248     if (myTrans == NULL) 
00249     {
00250       const NdbError err = myNdb->getNdbError();
00251 
00252       if (err.status == NdbError::TemporaryError)
00253       {
00254         milliSleep(50);
00255         retryAttempt++;
00256         continue;
00257       }
00258       std::cout <<  err.message << std::endl;
00259       return -1;
00260     }
00261 
00265     myScanOp = myTrans->getNdbScanOperation(myTable);   
00266     if (myScanOp == NULL) 
00267     {
00268       std::cout << myTrans->getNdbError().message << std::endl;
00269       myNdb->closeTransaction(myTrans);
00270       return -1;
00271     }
00272 
00276     if(myScanOp->readTuples(NdbOperation::LM_Exclusive) != 0)
00277     {
00278       std::cout << myTrans->getNdbError().message << std::endl;
00279       myNdb->closeTransaction(myTrans);
00280       return -1;
00281     } 
00282     
00286     NdbScanFilter filter(myScanOp) ;   
00287     if(filter.begin(NdbScanFilter::AND) < 0  || 
00288        filter.cmp(NdbScanFilter::COND_EQ, column, color) < 0 ||
00289        filter.end() < 0)
00290     {
00291       std::cout <<  myTrans->getNdbError().message << std::endl;
00292       myNdb->closeTransaction(myTrans);
00293       return -1;
00294     }    
00295     
00299     if(myTrans->execute(NdbTransaction::NoCommit) != 0){      
00300       err = myTrans->getNdbError();    
00301       if(err.status == NdbError::TemporaryError){
00302         std::cout << myTrans->getNdbError().message << std::endl;
00303         myNdb->closeTransaction(myTrans);
00304         milliSleep(50);
00305         continue;
00306       }
00307       std::cout << err.code << std::endl;
00308       std::cout << myTrans->getNdbError().code << std::endl;
00309       myNdb->closeTransaction(myTrans);
00310       return -1;
00311     }
00312 
00313 
00318     while((check = myScanOp->nextResult(true)) == 0){
00319       do 
00320       {
00321         if (myScanOp->deleteCurrentTuple() != 0)
00322         {
00323           std::cout << myTrans->getNdbError().message << std::endl;
00324           myNdb->closeTransaction(myTrans);
00325           return -1;
00326         }
00327         deletedRows++;
00328         
00334       } while((check = myScanOp->nextResult(false)) == 0);
00335       
00339       if(check != -1)
00340       {
00341         check = myTrans->execute(NdbTransaction::Commit);   
00342       }
00343 
00344       if(check == -1)
00345       {
00349         check = myTrans->restart();
00350       }
00351 
00355       err = myTrans->getNdbError();    
00356       if(check == -1)
00357       {
00358         if(err.status == NdbError::TemporaryError)
00359         {
00360           std::cout << myTrans->getNdbError().message << std::endl;
00361           myNdb->closeTransaction(myTrans);
00362           milliSleep(50);
00363           continue;
00364         }       
00365       }
00369     }
00370     std::cout << myTrans->getNdbError().message << std::endl;
00371     myNdb->closeTransaction(myTrans);
00372     return 0;
00373   }
00374   
00375   if(myTrans!=0) 
00376   {
00377     std::cout << myTrans->getNdbError().message << std::endl;
00378     myNdb->closeTransaction(myTrans);
00379   }
00380   return -1;
00381 }

Here is the call graph for this function:

Here is the caller graph for this function:

int scan_print ( Ndb * myNdb )

Definition at line 576 of file ndbapi_scan.cpp.

References APIERROR, NdbRecAttr::aRef(), check(), Ndb::closeTransaction(), NdbError::code, err, NdbTransaction::execute(), Ndb::getDictionary(), NdbTransaction::getNdbError(), Ndb::getNdbError(), NdbDictionary::Dictionary::getNdbError(), NdbTransaction::getNdbScanOperation(), NdbDictionary::Dictionary::getTable(), NdbOperation::getValue(), NdbOperation::LM_CommittedRead, NdbError::message, milliSleep(), NdbScanOperation::nextResult(), NdbTransaction::NoCommit, NULL, NdbScanOperation::readTuples(), Ndb::startTransaction(), NdbError::status, NdbError::TemporaryError, and NdbRecAttr::u_32_value().

Referenced by main().

00577 {
00578 // Scan all records exclusive and update
00579   // them one by one
00580   int                  retryAttempt = 0;
00581   const int            retryMax = 10;
00582   int fetchedRows = 0;
00583   int check;
00584   NdbError              err;
00585   NdbTransaction        *myTrans;
00586   NdbScanOperation      *myScanOp;
00587   /* Result of reading attribute value, three columns:
00588      REG_NO, BRAND, and COLOR
00589    */
00590   NdbRecAttr *          myRecAttr[3];   
00591 
00592   const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
00593   const NdbDictionary::Table *myTable= myDict->getTable("GARAGE");
00594 
00595   if (myTable == NULL) 
00596     APIERROR(myDict->getNdbError());
00597 
00607   while (true)
00608   {
00609 
00610     if (retryAttempt >= retryMax)
00611     {
00612       std::cout << "ERROR: has retried this operation " << retryAttempt 
00613                 << " times, failing!" << std::endl;
00614       return -1;
00615     }
00616 
00617     myTrans = myNdb->startTransaction();
00618     if (myTrans == NULL) 
00619     {
00620       const NdbError err = myNdb->getNdbError();
00621 
00622       if (err.status == NdbError::TemporaryError)
00623       {
00624         milliSleep(50);
00625         retryAttempt++;
00626         continue;
00627       }
00628      std::cout << err.message << std::endl;
00629       return -1;
00630     }
00631     /*
00632      * Define a scan operation. 
00633      * NDBAPI.
00634      */
00635     myScanOp = myTrans->getNdbScanOperation(myTable);   
00636     if (myScanOp == NULL) 
00637     {
00638       std::cout << myTrans->getNdbError().message << std::endl;
00639       myNdb->closeTransaction(myTrans);
00640       return -1;
00641     }
00642 
00646     if( myScanOp->readTuples(NdbOperation::LM_CommittedRead) == -1)
00647     {
00648       std::cout << myTrans->getNdbError().message << std::endl;
00649       myNdb->closeTransaction(myTrans);
00650       return -1;
00651     } 
00652 
00659     myRecAttr[0] = myScanOp->getValue("REG_NO");
00660     myRecAttr[1] = myScanOp->getValue("BRAND");
00661     myRecAttr[2] = myScanOp->getValue("COLOR");
00662     if(myRecAttr[0] ==NULL || myRecAttr[1] == NULL || myRecAttr[2]==NULL) 
00663     {
00664         std::cout << myTrans->getNdbError().message << std::endl;
00665         myNdb->closeTransaction(myTrans);
00666         return -1;
00667     }
00671     if(myTrans->execute(NdbTransaction::NoCommit) != 0){      
00672       err = myTrans->getNdbError();    
00673       if(err.status == NdbError::TemporaryError){
00674         std::cout << myTrans->getNdbError().message << std::endl;
00675         myNdb->closeTransaction(myTrans);
00676         milliSleep(50);
00677         continue;
00678       }
00679       std::cout << err.code << std::endl;
00680       std::cout << myTrans->getNdbError().code << std::endl;
00681       myNdb->closeTransaction(myTrans);
00682       return -1;
00683     }
00684     
00689     while((check = myScanOp->nextResult(true)) == 0){
00690       do {
00691         
00692         fetchedRows++;
00696         std::cout << myRecAttr[0]->u_32_value() << "\t";
00697 
00701         std::cout << myRecAttr[1]->aRef() << "\t";
00702 
00706         std::cout << myRecAttr[2]->aRef() << std::endl;
00707 
00713       } while((check = myScanOp->nextResult(false)) == 0);
00714 
00715     }    
00716     myNdb->closeTransaction(myTrans);
00717     return 1;
00718   }
00719   return -1;
00720 
00721 }

Here is the call graph for this function:

Here is the caller graph for this function:

int scan_update	(	Ndb *	myNdb,
		int	update_column,
		const char *	before_color,
		const char *	after_color
	)

Definition at line 384 of file ndbapi_scan.cpp.

References NdbScanFilter::AND, APIERROR, NdbScanFilter::begin(), check(), Ndb::closeTransaction(), NdbScanFilter::cmp(), NdbError::code, NdbTransaction::Commit, NdbScanFilter::COND_EQ, NdbScanFilter::end(), err, NdbTransaction::execute(), Ndb::getDictionary(), NdbTransaction::getNdbError(), Ndb::getNdbError(), NdbDictionary::Dictionary::getNdbError(), NdbTransaction::getNdbScanOperation(), NdbDictionary::Dictionary::getTable(), NdbOperation::LM_Exclusive, NdbError::message, milliSleep(), NdbScanOperation::nextResult(), NdbTransaction::NoCommit, NULL, NdbScanOperation::readTuples(), NdbOperation::setValue(), Ndb::startTransaction(), NdbError::status, NdbError::TemporaryError, and NdbScanOperation::updateCurrentTuple().

Referenced by main().

00389 {
00390   
00391   // Scan all records exclusive and update
00392   // them one by one
00393   int                  retryAttempt = 0;
00394   const int            retryMax = 10;
00395   int updatedRows = 0;
00396   int check;
00397   NdbError              err;
00398   NdbTransaction        *myTrans;
00399   NdbScanOperation      *myScanOp;
00400 
00401   const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
00402   const NdbDictionary::Table *myTable= myDict->getTable("GARAGE");
00403 
00404   if (myTable == NULL) 
00405     APIERROR(myDict->getNdbError());
00406 
00416   while (true)
00417   {
00418 
00419     if (retryAttempt >= retryMax)
00420     {
00421       std::cout << "ERROR: has retried this operation " << retryAttempt 
00422                 << " times, failing!" << std::endl;
00423       return -1;
00424     }
00425 
00426     myTrans = myNdb->startTransaction();
00427     if (myTrans == NULL) 
00428     {
00429       const NdbError err = myNdb->getNdbError();
00430 
00431       if (err.status == NdbError::TemporaryError)
00432       {
00433         milliSleep(50);
00434         retryAttempt++;
00435         continue;
00436       }
00437       std::cout <<  err.message << std::endl;
00438       return -1;
00439     }
00440 
00444     myScanOp = myTrans->getNdbScanOperation(myTable);   
00445     if (myScanOp == NULL) 
00446     {
00447       std::cout << myTrans->getNdbError().message << std::endl;
00448       myNdb->closeTransaction(myTrans);
00449       return -1;
00450     }
00451 
00455     if( myScanOp->readTuples(NdbOperation::LM_Exclusive) ) 
00456     {
00457       std::cout << myTrans->getNdbError().message << std::endl;
00458       myNdb->closeTransaction(myTrans);
00459       return -1;
00460     } 
00461 
00465     NdbScanFilter filter(myScanOp) ;   
00466     if(filter.begin(NdbScanFilter::AND) < 0  || 
00467        filter.cmp(NdbScanFilter::COND_EQ, update_column, before_color) <0||
00468        filter.end() <0)
00469     {
00470       std::cout <<  myTrans->getNdbError().message << std::endl;
00471       myNdb->closeTransaction(myTrans);
00472       return -1;
00473     }    
00474     
00478     if(myTrans->execute(NdbTransaction::NoCommit) != 0)
00479     {      
00480       err = myTrans->getNdbError();    
00481       if(err.status == NdbError::TemporaryError){
00482         std::cout << myTrans->getNdbError().message << std::endl;
00483         myNdb->closeTransaction(myTrans);
00484         milliSleep(50);
00485         continue;
00486       }
00487       std::cout << myTrans->getNdbError().code << std::endl;
00488       myNdb->closeTransaction(myTrans);
00489       return -1;
00490     }
00491 
00496     while((check = myScanOp->nextResult(true)) == 0){
00497       do {
00501         NdbOperation * myUpdateOp = myScanOp->updateCurrentTuple();
00502         if (myUpdateOp == 0)
00503         {
00504           std::cout << myTrans->getNdbError().message << std::endl;
00505           myNdb->closeTransaction(myTrans);
00506           return -1;
00507         }
00508         updatedRows++;
00509 
00513         myUpdateOp->setValue(update_column, after_color);
00519       } while((check = myScanOp->nextResult(false)) == 0);
00520       
00524       if(check != -1)
00525       {
00526         check = myTrans->execute(NdbTransaction::NoCommit);   
00527       }
00528 
00532       err = myTrans->getNdbError();    
00533       if(check == -1)
00534       {
00535         if(err.status == NdbError::TemporaryError){
00536           std::cout << myTrans->getNdbError().message << std::endl;
00537           myNdb->closeTransaction(myTrans);
00538           milliSleep(50);
00539           continue;
00540         }       
00541       }
00545     }
00546 
00550     if(myTrans->execute(NdbTransaction::Commit) == -1)
00551     {
00552       if(err.status == NdbError::TemporaryError){
00553         std::cout << myTrans->getNdbError().message << std::endl;
00554         myNdb->closeTransaction(myTrans);
00555         milliSleep(50);
00556         continue;
00557       } 
00558     }
00559 
00560     std::cout << myTrans->getNdbError().message << std::endl;
00561     myNdb->closeTransaction(myTrans);
00562     return 0;    
00563   }
00564 
00565 
00566   if(myTrans!=0) 
00567   {
00568     std::cout << myTrans->getNdbError().message << std::endl;
00569     myNdb->closeTransaction(myTrans);
00570   }
00571   return -1;
00572 }

Here is the call graph for this function:

Here is the caller graph for this function:

Generated on Sat Sep 9 18:45:34 2006 for MySQL 5.1 by

1.4.7

The world's most popular open source database

mysql/src/5.1-dbg/storage/ndb/ndbapi-examples/ndbapi_scan/ndbapi_scan.cpp File Reference

Classes

Defines

Functions

Define Documentation

Function Documentation