开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
select_all.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：9k
源码类别：

MySQL数据库

开发平台：

Visual C++

select_all.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #include <ndb_global.h>
  19. #include <ndb_opts.h>
  21. #include <NdbOut.hpp>
  23. #include <NdbApi.hpp>
  24. #include <NdbMain.h>
  25. #include <NDBT.hpp> 
  26. #include <NdbSleep.h>
  27. #include <NdbScanFilter.hpp>
  28.  
  29. int scanReadRecords(Ndb*, 
  30.     const NdbDictionary::Table*, 
  31.     const NdbDictionary::Index*,
  32.     int parallel,
  33.     int lockType,
  34.     bool headers,
  35.     bool useHexFormat,
  36.     char delim,
  37.     bool orderby);
  39. NDB_STD_OPTS_VARS;
  41. static const char* _dbname = "TEST_DB";
  42. static const char* _delimiter = "t";
  43. static int _unqualified, _header, _parallelism, _useHexFormat, _lock,
  44.   _order;
  46. static struct my_option my_long_options[] =
  47. {
  48.   NDB_STD_OPTS("ndb_desc"),
  49.   { "database", 'd', "Name of database table is in",
  50.     (gptr*) &_dbname, (gptr*) &_dbname, 0,
  51.     GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  52.   { "parallelism", 'p', "parallelism",
  53.     (gptr*) &_parallelism, (gptr*) &_parallelism, 0,
  54.     GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 }, 
  55.   { "lock", 'l', "Read(0), Read-hold(1), Exclusive(2)",
  56.     (gptr*) &_lock, (gptr*) &_lock, 0,
  57.     GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 }, 
  58.   { "order", 'o', "Sort resultset according to index",
  59.     (gptr*) &_order, (gptr*) &_order, 0,
  60.     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
  61.   { "header", 'h', "Print header",
  62.     (gptr*) &_header, (gptr*) &_header, 0,
  63.     GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0 }, 
  64.   { "useHexFormat", 'x', "Output numbers in hexadecimal format",
  65.     (gptr*) &_useHexFormat, (gptr*) &_useHexFormat, 0,
  66.     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
  67.   { "delimiter", 'D', "Column delimiter",
  68.     (gptr*) &_delimiter, (gptr*) &_delimiter, 0,
  69.     GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  70.   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  71. };
  72. static void usage()
  73. {
  74.   char desc[] = 
  75.     "tabnamen"
  76.     "This program reads all records from one table in NDB Clustern"
  77.     "and print them to stdout.  This is performed using a scan read.n"
  78.     "(It only print error messages if it encounters a permanent error.)n"
  79.     "It can also be used to dump the content of a table to file n"
  80.     "  ex: select_all --no-header --delimiter=';' T4 > T4.datan";
  81.   ndb_std_print_version();
  82.   my_print_help(my_long_options);
  83.   my_print_variables(my_long_options);
  84. }
  85. static my_bool
  86. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  87.        char *argument)
  88. {
  89.   return ndb_std_get_one_option(optid, opt, argument ? argument :
  90. "d:t:O,/tmp/ndb_select_all.trace");
  91. }
  93. int main(int argc, char** argv){
  94.   NDB_INIT(argv[0]);
  95.   const char *load_default_groups[]= { "mysql_cluster",0 };
  96.   load_defaults("my",load_default_groups,&argc,&argv);
  97.   const char* _tabname;
  98.   int ho_error;
  99.   if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
  100.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  101.   if ((_tabname = argv[0]) == 0) {
  102.     usage();
  103.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  104.   }
  106.   Ndb::setConnectString(opt_connect_str);
  107.   // Connect to Ndb
  108.   Ndb MyNdb(_dbname);
  110.   if(MyNdb.init() != 0){
  111.     ERR(MyNdb.getNdbError());
  112.     return NDBT_ProgramExit(NDBT_FAILED);
  113.   }
  115.   // Connect to Ndb and wait for it to become ready
  116.   while(MyNdb.waitUntilReady() != 0)
  117.     ndbout << "Waiting for ndb to become ready..." << endl;
  118.    
  119.   // Check if table exists in db
  120.   const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(&MyNdb, _tabname);
  121.   const NdbDictionary::Index * pIdx = 0;
  122.   if(argc > 1){
  123.     pIdx = MyNdb.getDictionary()->getIndex(argv[1], _tabname);
  124.   }
  126.   if(pTab == NULL){
  127.     ndbout << " Table " << _tabname << " does not exist!" << endl;
  128.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  129.   }
  131.   if(argc > 1 && pIdx == 0)
  132.   {
  133.     ndbout << " Index " << argv[1] << " does not exists" << endl;
  134.   }
  135.   
  136.   if(_order && pIdx == NULL){
  137.     ndbout << " Order flag given without an index" << endl;
  138.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  139.   }
  141.   if (scanReadRecords(&MyNdb, 
  142.       pTab, 
  143.       pIdx,
  144.       _parallelism, 
  145.       _lock,
  146.       _header, 
  147.       _useHexFormat, 
  148.       (char)*_delimiter, _order) != 0){
  149.     return NDBT_ProgramExit(NDBT_FAILED);
  150.   }
  152.   return NDBT_ProgramExit(NDBT_OK);
  154. }
  156. int scanReadRecords(Ndb* pNdb, 
  157.     const NdbDictionary::Table* pTab, 
  158.     const NdbDictionary::Index* pIdx,
  159.     int parallel,
  160.     int _lock,
  161.     bool headers,
  162.     bool useHexFormat,
  163.     char delimiter, bool order){
  165.   int                  retryAttempt = 0;
  166.   const int            retryMax = 100;
  167.   int                  check;
  168.   NdbConnection        *pTrans;
  169.   NdbScanOperation        *pOp;
  170.   NdbIndexScanOperation * pIOp= 0;
  172.   NDBT_ResultRow * row = new NDBT_ResultRow(*pTab, delimiter);
  174.   while (true){
  176.     if (retryAttempt >= retryMax){
  177.       ndbout << "ERROR: has retried this operation " << retryAttempt 
  178.      << " times, failing!" << endl;
  179.       return -1;
  180.     }
  182.     pTrans = pNdb->startTransaction();
  183.     if (pTrans == NULL) {
  184.       const NdbError err = pNdb->getNdbError();
  186.       if (err.status == NdbError::TemporaryError){
  187. NdbSleep_MilliSleep(50);
  188. retryAttempt++;
  189. continue;
  190.       }
  191.       ERR(err);
  192.       return -1;
  193.     }
  195.     
  196.     pOp = (!pIdx) ? pTrans->getNdbScanOperation(pTab->getName()) : 
  197.       pIOp=pTrans->getNdbIndexScanOperation(pIdx->getName(), pTab->getName());
  198.     
  199.     if (pOp == NULL) {
  200.       ERR(pTrans->getNdbError());
  201.       pNdb->closeTransaction(pTrans);
  202.       return -1;
  203.     }
  205.     NdbResultSet * rs;
  206.     switch(_lock + (3 * order)){
  207.     case 1:
  208.       rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallel);
  209.       break;
  210.     case 2:
  211.       rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallel);
  212.       break;
  213.     case 3:
  214.       rs = pIOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallel, 
  215.     true);
  216.       break;
  217.     case 4:
  218.       rs = pIOp->readTuples(NdbScanOperation::LM_Read, 0, parallel, true);
  219.       break;
  220.     case 5:
  221.       rs = pIOp->readTuples(NdbScanOperation::LM_Exclusive, 0, parallel, true);
  222.       break;
  223.     case 0:
  224.     default:
  225.       rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallel);
  226.       break;
  227.     }
  228.     if( rs == 0 ){
  229.       ERR(pTrans->getNdbError());
  230.       pNdb->closeTransaction(pTrans);
  231.       return -1;
  232.     }
  233.     
  234.     if(0){
  235.       NdbScanFilter sf(pOp);
  236. #if 0
  237.       sf.begin(NdbScanFilter::AND);
  238.       sf.le(0, (Uint32)10);
  239.       
  240.       sf.end();
  241. #elif 0
  242.       sf.begin(NdbScanFilter::OR);
  243.       sf.begin(NdbScanFilter::AND);
  244.       sf.ge(0, (Uint32)10);
  245.       sf.lt(0, (Uint32)20);
  246.       sf.end();
  247.       sf.begin(NdbScanFilter::AND);
  248.       sf.ge(0, (Uint32)30);
  249.       sf.lt(0, (Uint32)40);
  250.       sf.end();
  251.       sf.end();
  252. #elif 1
  253.       sf.begin(NdbScanFilter::AND);
  254.       sf.begin(NdbScanFilter::OR);
  255.       sf.begin(NdbScanFilter::AND);
  256.       sf.ge(0, (Uint32)10);
  257.       sf.lt(0, (Uint32)20);
  258.       sf.end();
  259.       sf.begin(NdbScanFilter::AND);
  260.       sf.ge(0, (Uint32)30);
  261.       sf.lt(0, (Uint32)40);
  262.       sf.end();
  263.       sf.end();
  264.       sf.begin(NdbScanFilter::OR);
  265.       sf.begin(NdbScanFilter::AND);
  266.       sf.ge(0, (Uint32)0);
  267.       sf.lt(0, (Uint32)50);
  268.       sf.end();
  269.       sf.begin(NdbScanFilter::AND);
  270.       sf.ge(0, (Uint32)100);
  271.       sf.lt(0, (Uint32)200);
  272.       sf.end();
  273.       sf.end();
  274.       sf.end();
  275. #endif
  276.     } else {
  277.       check = pOp->interpret_exit_ok();
  278.       if( check == -1 ) {
  279. ERR(pTrans->getNdbError());
  280. pNdb->closeTransaction(pTrans);
  281. return -1;
  282.       }
  283.     }
  284.     
  285.     for(int a = 0; a<pTab->getNoOfColumns(); a++){
  286.       if((row->attributeStore(a) = 
  287.   pOp->getValue(pTab->getColumn(a)->getName())) == 0) {
  288. ERR(pTrans->getNdbError());
  289. pNdb->closeTransaction(pTrans);
  290. return -1;
  291.       }
  292.     }
  294.     check = pTrans->execute(NoCommit);   
  295.     if( check == -1 ) {
  296.       const NdbError err = pTrans->getNdbError();
  297.       
  298.       if (err.status == NdbError::TemporaryError){
  299. pNdb->closeTransaction(pTrans);
  300. NdbSleep_MilliSleep(50);
  301. retryAttempt++;
  302. continue;
  303.       }
  304.       ERR(err);
  305.       pNdb->closeTransaction(pTrans);
  306.       return -1;
  307.     }
  309.     if (headers)
  310.       row->header(ndbout) << endl;
  311.     
  312.     int eof;
  313.     int rows = 0;
  314.     eof = rs->nextResult();
  315.     
  316.     while(eof == 0){
  317.       rows++;
  319.       if (useHexFormat) {
  320. ndbout.setHexFormat(1) << (*row) << endl;
  321.       } else {
  322. ndbout << (*row) << endl;
  323.       }
  325.       eof = rs->nextResult();
  326.     }
  327.     if (eof == -1) {
  328.       const NdbError err = pTrans->getNdbError();
  330.       if (err.status == NdbError::TemporaryError){
  331. pNdb->closeTransaction(pTrans);
  332. NdbSleep_MilliSleep(50);
  333. retryAttempt++;
  334. continue;
  335.       }
  336.       ERR(err);
  337.       pNdb->closeTransaction(pTrans);
  338.       return -1;
  339.     }
  341.     pNdb->closeTransaction(pTrans);
  343.     ndbout << rows << " rows returned" << endl;
  345.     return 0;
  346.   }
  347.   return -1;
  348. }