br_test.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  14. extern "C" {
  15. #include <dba.h>
  16. }
  17. #include "common.hpp"
  18. #include <NdbOut.hpp>
  19. #include <NdbSleep.h>
  20. #include <NdbMain.h>
  21. static const
  22. DBA_ColumnDesc_t EmpColDesc[] = {
  23.   { "emp_no",     DBA_INT,  PCN_SIZE_OF( Employee, EmpNo ),     PCN_TRUE },
  24.   { "first_name", DBA_CHAR, PCN_SIZE_OF( Employee, FirstName ), PCN_FALSE },
  25.   { "last_name",  DBA_CHAR, PCN_SIZE_OF( Employee, LastName ),  PCN_FALSE }
  26. };
  27. static const
  28. DBA_ColumnDesc_t AddColDesc[] = {
  29.   { "emp_no",      DBA_INT,  PCN_SIZE_OF( Address, EmpNo ),      PCN_TRUE },
  30.   { "street_name", DBA_CHAR, PCN_SIZE_OF( Address, StreetName ), PCN_FALSE},
  31.   { "street_no",   DBA_INT,  PCN_SIZE_OF( Address, StreetNo ),   PCN_FALSE},
  32.   { "city",        DBA_CHAR, PCN_SIZE_OF( Address, City ),       PCN_FALSE}
  33. } ;
  34. static const
  35. DBA_ColumnBinding_t EmpBindings[] = {
  36.   DBA_BINDING( "emp_no",     DBA_INT,  Employee, EmpNo ),
  37.   DBA_BINDING( "last_name",  DBA_CHAR, Employee, LastName ),
  38.   DBA_BINDING( "first_name", DBA_CHAR, Employee, FirstName)
  39. };
  40. static const
  41. DBA_ColumnBinding_t AddBindings[] = {
  42.   DBA_BINDING( "emp_no",      DBA_INT,  Address, EmpNo ),
  43.   DBA_BINDING( "street_name", DBA_CHAR, Address, StreetName ),
  44.   DBA_BINDING( "street_no",   DBA_INT,  Address, StreetNo ),  
  45.   DBA_BINDING( "city",        DBA_CHAR, Address, City )
  46. };
  47. static DBA_Binding_t * EmpB;
  48. static DBA_Binding_t * AddB;
  49. static const int Rows = 6;
  50. static
  51. Employee_t EMP_TABLE_DATA[] = {
  52.   { 1242, "Joe",     "Dalton" },
  53.   { 123,  "Lucky",   "Luke" },
  54.   { 456,  "Averell", "Dalton" },
  55.   { 8976, "Gaston",  "Lagaffe" },
  56.   { 1122, "Jolly",   "Jumper" },
  57.   { 3211, "Leffe",   "Pagrotsky" }
  58. };
  59. static
  60. Employee_t EMP_TABLE_DATA_READ[] = {
  61.   { 1242, "", "" },
  62.   { 123,  "", "" },
  63.   { 456,  "", "" },
  64.   { 8976, "", "" },
  65.   { 1122, "", "" },
  66.   { 3211, "", "" }
  67. };
  68. static
  69. Address_t ADD_TABLE_DATA[] = {
  70.   { 1242, "Lonesome Street", 12, "Crime Town" },
  71.   { 123,  "Pistol Road",     13, "Fort Mount" },
  72.   { 456,  "Banking Blv.",    43, "Las Vegas"  },
  73.   { 8976, "ChancylleZee",    54, "Paris" },
  74.   { 1122, "Lucky",          111, "Wild West"  },
  75.   { 3211, "Parlament St.",   11, "Stockholm" }
  76. };
  77. static
  78. Address_t ADD_TABLE_DATA_READ[] = {
  79.   { 1242, "", 0, "" },
  80.   { 123,  "", 0, "" },
  81.   { 456,  "", 0, "" },
  82.   { 8976, "", 0, "" },
  83.   { 1122, "", 0, "" },
  84.   { 3211, "", 0, "" }
  85. };
  86. static const char EMP_TABLE[] = "employees";
  87. static const char ADD_TABLE[] = "addresses";
  88. static const int EmpNbCol = 3;
  89. static const int AddNbCol = 4;
  90. static
  91. void 
  92. DbCreate(void){
  93.   ndbout << "Opening database" << endl;
  94.   require( DBA_Open() == DBA_NO_ERROR );
  95.   
  96.   ndbout << "Creating tables" << endl;
  97.   require( DBA_CreateTable( EMP_TABLE, EmpNbCol, EmpColDesc ) == DBA_NO_ERROR );
  98.   require( DBA_CreateTable( ADD_TABLE, AddNbCol, AddColDesc ) == DBA_NO_ERROR );
  99.   
  100.   ndbout << "Checking for table existance" << endl;
  101.   require( DBA_TableExists( EMP_TABLE ) );
  102.   require( DBA_TableExists( ADD_TABLE ) );
  103. static
  104. void
  105. CreateBindings(void){
  106.   ndbout << "Creating bindings" << endl;
  107.   EmpB = DBA_CreateBinding(EMP_TABLE, 
  108.     EmpNbCol,
  109.     EmpBindings,
  110.     sizeof(Employee_t) );
  111.   require(EmpB != 0);
  112.   AddB = DBA_CreateBinding(ADD_TABLE, 
  113.    AddNbCol,
  114.    AddBindings,
  115.    sizeof(Address_t) );
  116.   require(AddB != 0);
  117. }
  118. int
  119. CountRows(DBA_BulkReadResultSet_t * rs, int count){
  120.   int res = 0;
  121.   for(int i = 0; i<count; i++)
  122.     if(rs[i].RowFoundIndicator)
  123.       res++;
  124.   return res;
  125. }
  126. extern "C" {
  127.   static void insertCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  128.   static void deleteCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  129.   static void updateCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  130.   static void readCallback  ( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  131.   static void writeCallback ( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  132. }
  133. static
  134. void Multi(){
  135.   ndbout << "Testing multi operations" << endl;
  136.   DBA_ArrayInsertRows(EmpB, EMP_TABLE_DATA, Rows-2, insertCallback);
  137.   DBA_ArrayInsertRows(AddB, ADD_TABLE_DATA, Rows-2, insertCallback);
  138.   NdbSleep_SecSleep(1);
  139.   
  140.   const int R2 = Rows + Rows;
  141.   
  142.   DBA_Binding_t * Bindings[2];
  143.   DBA_BulkReadResultSet_t DataRead[R2];
  144.   
  145.   Bindings[0] = EmpB;
  146.   Bindings[1] = AddB;
  147.   
  148.   for(int i = 0; i<Rows; i++)
  149.     DataRead[i].DataPtr = &EMP_TABLE_DATA_READ[i];
  150.   
  151.   for(int i = 0; i<Rows; i++)
  152.     DataRead[i+Rows].DataPtr = &ADD_TABLE_DATA_READ[i];
  153.   
  154.   NdbSleep_SecSleep(1);
  155.   DBA_BulkMultiReadRows(Bindings, DataRead, 2, Rows, readCallback);
  156.   NdbSleep_SecSleep(1);
  157.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  158.   CompareRows(ADD_TABLE_DATA, Rows-2, ADD_TABLE_DATA_READ);
  159.   
  160.   require(CountRows(DataRead, R2) == (R2-4));
  161.   // Basic delete
  162.   DBA_ArrayDeleteRows(EmpB, EMP_TABLE_DATA, Rows-2, deleteCallback);
  163.   DBA_ArrayDeleteRows(AddB, ADD_TABLE_DATA, Rows-2, deleteCallback);
  164.   NdbSleep_SecSleep(1);
  165. }
  166. static
  167. void BasicPtr(){
  168.   ndbout << "Testing array of pointer operations" << endl;
  169.   
  170.   // Basic insert
  171.   DBA_ArrayInsertRows(EmpB, EMP_TABLE_DATA, Rows-2, insertCallback);
  172.   NdbSleep_SecSleep(1);
  173.   DBA_BulkReadResultSet_t EmpDataRead[Rows];
  174.   for(int i = 0; i<Rows; i++){
  175.     EmpDataRead[i].DataPtr = &EMP_TABLE_DATA_READ[i];
  176.   }
  177.   
  178.   DBA_BulkReadRows(EmpB, EmpDataRead, Rows, readCallback);
  179.   NdbSleep_SecSleep(1);
  180.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  181.   require(CountRows(EmpDataRead, Rows) == (Rows-2));
  182.   
  183.   // Basic delete
  184.   DBA_ArrayDeleteRows(EmpB, EMP_TABLE_DATA, Rows-2, deleteCallback);
  185.   NdbSleep_SecSleep(1);
  186. }
  187. /*---------------------------------------------------------------------------*/
  188. NDB_COMMAND(newton_br, "newton_br", 
  189.     "newton_br", "newton_br", 65535){
  190.   DbCreate();
  191.   CreateBindings();
  192.   BasicPtr();
  193.   Multi();
  194.   
  195.   DBA_Close();
  196.   return 0;
  197. }
  198. /**
  199.  *  callbackStatusCheck  checks whether or not the operation succeeded
  200.  */
  201. void
  202. callbackStatusCheck( DBA_Error_t status, const char* operation) {
  203.   ndbout_c("%s: %d", operation, status);
  204. }
  205. void insertCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  206.   callbackStatusCheck(s, "insert");
  207. }
  208. void deleteCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  209.   callbackStatusCheck(s, "delete");
  210. }
  211. void updateCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  212.   callbackStatusCheck(s, "update");
  213. }
  214. void readCallback  ( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  215.   callbackStatusCheck(s, "read");
  216. }
  217. void writeCallback  ( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  218.   callbackStatusCheck(s, "write");
  219. }