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

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

MySQL数据库

开发平台：

Visual C++

basic.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 */
  19. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  20. extern "C" {
  21. #include <dba.h>
  22. }
  24. #include "common.hpp"
  26. #include <NdbOut.hpp>
  27. #include <NdbSleep.h>
  28. #include <NdbMain.h>
  30. static const
  31. DBA_ColumnDesc_t EmpColDesc[] = {
  32.   { "emp_no",     DBA_INT,  PCN_SIZE_OF( Employee, EmpNo ),     PCN_TRUE },
  33.   { "first_name", DBA_CHAR, PCN_SIZE_OF( Employee, FirstName ), PCN_FALSE },
  34.   { "last_name",  DBA_CHAR, PCN_SIZE_OF( Employee, LastName ),  PCN_FALSE }
  35. };
  37. static const
  38. DBA_ColumnDesc_t AddColDesc[] = {
  39.   { "emp_no",      DBA_INT,  PCN_SIZE_OF( Address, EmpNo ),      PCN_TRUE },
  40.   { "street_name", DBA_CHAR, PCN_SIZE_OF( Address, StreetName ), PCN_FALSE},
  41.   { "street_no",   DBA_INT,  PCN_SIZE_OF( Address, StreetNo ),   PCN_FALSE},
  42.   { "city",        DBA_CHAR, PCN_SIZE_OF( Address, City ),       PCN_FALSE}
  43. } ;
  45. static const
  46. DBA_ColumnBinding_t EmpBindings[] = {
  47.   DBA_BINDING( "emp_no",     DBA_INT,  Employee, EmpNo ),
  48.   DBA_BINDING( "last_name",  DBA_CHAR, Employee, LastName ),
  49.   DBA_BINDING( "first_name", DBA_CHAR, Employee, FirstName)
  50. };
  52. static const
  53. DBA_ColumnBinding_t AddBindings[] = {
  54.   DBA_BINDING( "emp_no",      DBA_INT,  Address, EmpNo ),
  55.   DBA_BINDING( "street_name", DBA_CHAR, Address, StreetName ),
  56.   DBA_BINDING( "street_no",   DBA_INT,  Address, StreetNo ),  
  57.   DBA_BINDING( "city",        DBA_CHAR, Address, City )
  58. };
  60. static DBA_Binding_t * EmpB;
  61. static DBA_Binding_t * AddB;
  63. static const int Rows = 6;
  65. static
  66. Employee_t EMP_TABLE_DATA[] = {
  67.   { 1242, "Joe",     "Dalton" },
  68.   { 123,  "Lucky",   "Luke" },
  69.   { 456,  "Averell", "Dalton" },
  70.   { 8976, "Gaston",  "Lagaffe" },
  71.   { 1122, "Jolly",   "Jumper" },
  72.   { 3211, "Leffe",   "Pagrotsky" }
  73. };
  75. static
  76. Employee_t EMP_TABLE_DATA_READ[] = {
  77.   { 1242, "", "" },
  78.   { 123,  "", "" },
  79.   { 456,  "", "" },
  80.   { 8976, "", "" },
  81.   { 1122, "", "" },
  82.   { 3211, "", "" }
  83. };
  85. static
  86. Address_t ADD_TABLE_DATA[] = {
  87.   { 1242, "Lonesome Street", 12, "Crime Town" },
  88.   { 123,  "Pistol Road",     13, "Fort Mount" },
  89.   { 456,  "Banking Blv.",    43, "Las Vegas"  },
  90.   { 8976, "ChancylleZee",    54, "Paris" },
  91.   { 1122, "Lucky",          111, "Wild West"  },
  92.   { 3211, "Parlament St.",   11, "Stockholm" }
  93. };
  95. static
  96. Address_t ADD_TABLE_DATA_READ[] = {
  97.   { 1242, "", 0, "" },
  98.   { 123,  "", 0, "" },
  99.   { 456,  "", 0, "" },
  100.   { 8976, "", 0, "" },
  101.   { 1122, "", 0, "" },
  102.   { 3211, "", 0, "" }
  103. };
  105. static const char EMP_TABLE[] = "employees";
  106. static const char ADD_TABLE[] = "addresses";
  108. static const int EmpNbCol = 3;
  109. static const int AddNbCol = 4;
  111. static
  112. void 
  113. DbCreate(void){
  115.   ndbout << "Opening database" << endl;
  116.   require( DBA_Open() == DBA_NO_ERROR );
  117.   
  118.   ndbout << "Creating tables" << endl;
  119.   require( DBA_CreateTable( EMP_TABLE, EmpNbCol, EmpColDesc ) == DBA_NO_ERROR );
  120.   require( DBA_CreateTable( ADD_TABLE, AddNbCol, AddColDesc ) == DBA_NO_ERROR );
  121.   
  122.   ndbout << "Checking for table existance" << endl;
  123.   require( DBA_TableExists( EMP_TABLE ) );
  124.   require( DBA_TableExists( ADD_TABLE ) );
  125. } 
  127. static
  128. void
  129. CreateBindings(void){
  130.   ndbout << "Creating bindings" << endl;
  132.   EmpB = DBA_CreateBinding(EMP_TABLE, 
  133.    EmpNbCol,
  134.    EmpBindings,
  135.    sizeof(Employee_t) );
  136.   require(EmpB != 0);
  138.   AddB = DBA_CreateBinding(ADD_TABLE, 
  139.    AddNbCol,
  140.    AddBindings,
  141.    sizeof(Address_t) );
  142.   require(AddB != 0);
  143. }
  145. extern "C" {
  146.   static void insertCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  147.   static void deleteCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  148.   static void updateCallback( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  149.   static void readCallback  ( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  150.   static void writeCallback ( DBA_ReqId_t, DBA_Error_t, DBA_ErrorCode_t );
  151. }
  153. static
  154. void BasicArray(){
  155.   ndbout << "Testing basic array operations" << endl;
  156.   
  157.   // Basic insert
  158.   DBA_ArrayInsertRows(EmpB, EMP_TABLE_DATA, Rows-2, insertCallback);
  159.   NdbSleep_SecSleep(1);
  160.   DBA_ArrayReadRows(EmpB, EMP_TABLE_DATA_READ, Rows-2, readCallback);
  161.   NdbSleep_SecSleep(1);
  162.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  163.   
  164.   // Basic update
  165.   AlterRows(EMP_TABLE_DATA, Rows-2);
  166.   DBA_ArrayUpdateRows(EmpB, EMP_TABLE_DATA, Rows-2, updateCallback);
  167.   NdbSleep_SecSleep(1);
  168.   DBA_ArrayReadRows(EmpB, EMP_TABLE_DATA_READ, Rows-2, readCallback);
  169.   NdbSleep_SecSleep(1);
  170.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  171.   
  172.   // Basic write
  173.   AlterRows(EMP_TABLE_DATA, Rows);
  174.   DBA_ArrayWriteRows(EmpB, EMP_TABLE_DATA, Rows, writeCallback);
  175.   NdbSleep_SecSleep(1);
  176.   DBA_ArrayReadRows(EmpB, EMP_TABLE_DATA_READ, Rows, readCallback);
  177.   NdbSleep_SecSleep(1);
  178.   CompareRows(EMP_TABLE_DATA, Rows, EMP_TABLE_DATA_READ);
  179.   
  180.   // Basic delete
  181.   DBA_ArrayDeleteRows(EmpB, EMP_TABLE_DATA, Rows, deleteCallback);
  182.   NdbSleep_SecSleep(1);
  183. }
  185. static
  186. void Multi(){
  187.   ndbout << "Testing multi operations" << endl;
  188.   
  189.   const int R2 = Rows + Rows;
  191.   DBA_Binding_t * Bindings[R2];
  192.   void * DATA[R2];
  193.   void * DATA_READ[R2];
  194.   for(int i = 0; i<Rows; i++){
  195.     Bindings[2*i]   = EmpB;
  196.     Bindings[2*i+1] = AddB;
  197.     
  198.     DATA[2*i]   = &EMP_TABLE_DATA[i];
  199.     DATA[2*i+1] = &ADD_TABLE_DATA[i];
  201.     DATA_READ[2*i]   = &EMP_TABLE_DATA_READ[i];
  202.     DATA_READ[2*i+1] = &ADD_TABLE_DATA_READ[i];
  203.   }
  204.   
  205.   // Basic insert
  206.   DBA_MultiInsertRow(Bindings, DATA, R2-4, insertCallback);
  207.   NdbSleep_SecSleep(1);
  208.   DBA_MultiReadRow  (Bindings, DATA_READ, R2-4, readCallback);
  209.   NdbSleep_SecSleep(1);
  211.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  212.   CompareRows(ADD_TABLE_DATA, Rows-2, ADD_TABLE_DATA_READ);
  213.   
  214.   // Basic update
  215.   AlterRows(EMP_TABLE_DATA, Rows-2);
  216.   AlterRows(ADD_TABLE_DATA, Rows-2);
  217.   DBA_MultiUpdateRow(Bindings, DATA, R2-4, updateCallback);
  218.   NdbSleep_SecSleep(1);
  219.   DBA_MultiReadRow  (Bindings, DATA_READ, R2-4, readCallback);
  220.   NdbSleep_SecSleep(1);
  221.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  222.   CompareRows(ADD_TABLE_DATA, Rows-2, ADD_TABLE_DATA_READ);
  223.   
  224.   // Basic write
  225.   AlterRows(EMP_TABLE_DATA, Rows);
  226.   AlterRows(ADD_TABLE_DATA, Rows);
  227.   DBA_MultiWriteRow(Bindings, DATA, R2, writeCallback);
  228.   NdbSleep_SecSleep(1);
  229.   DBA_MultiReadRow (Bindings, DATA_READ, R2, readCallback);
  230.   NdbSleep_SecSleep(1);
  231.   CompareRows(EMP_TABLE_DATA, Rows, EMP_TABLE_DATA_READ);
  232.   CompareRows(ADD_TABLE_DATA, Rows, ADD_TABLE_DATA_READ);
  233.   
  234.   // Basic delete
  235.   DBA_MultiDeleteRow(Bindings, DATA, R2, deleteCallback);
  236.   NdbSleep_SecSleep(1);
  237. }
  239. static
  240. void BasicPtr(){
  241.   ndbout << "Testing array of pointer operations" << endl;
  242.   Employee_t * EmpData[Rows];
  243.   Employee_t * EmpDataRead[Rows];
  244.   for(int i = 0; i<Rows; i++){
  245.     EmpData[i]     = &EMP_TABLE_DATA[i];
  246.     EmpDataRead[i] = &EMP_TABLE_DATA_READ[i];
  247.   }
  248.     
  249.   void * const * EMP_TABLE_DATA2      = (void * const *)EmpData;
  250.   void * const * EMP_TABLE_DATA_READ2 = (void * const *)EmpDataRead;
  251.     
  252.   // Basic insert
  253.   DBA_InsertRows(EmpB, EMP_TABLE_DATA2, Rows-2, insertCallback);
  254.   NdbSleep_SecSleep(1);
  255.   DBA_ReadRows  (EmpB, EMP_TABLE_DATA_READ2, Rows-2, readCallback);
  256.   NdbSleep_SecSleep(1);
  257.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  258.     
  259.   // Basic update
  260.   AlterRows(EMP_TABLE_DATA, Rows-2);
  261.   DBA_UpdateRows(EmpB, EMP_TABLE_DATA2, Rows-2, updateCallback);
  262.   NdbSleep_SecSleep(1);
  263.   DBA_ReadRows  (EmpB, EMP_TABLE_DATA_READ2, Rows-2, readCallback);
  264.   NdbSleep_SecSleep(1);
  265.   CompareRows(EMP_TABLE_DATA, Rows-2, EMP_TABLE_DATA_READ);
  266.     
  267.     // Basic write
  268.   AlterRows  (EMP_TABLE_DATA, Rows);
  269.   DBA_WriteRows(EmpB, EMP_TABLE_DATA2, Rows, writeCallback);
  270.   NdbSleep_SecSleep(1);
  271.   DBA_ReadRows (EmpB, EMP_TABLE_DATA_READ2, Rows, readCallback);
  272.   NdbSleep_SecSleep(1);
  273.   CompareRows(EMP_TABLE_DATA, Rows, EMP_TABLE_DATA_READ);
  274.     
  275.     // Basic delete
  276.   DBA_DeleteRows(EmpB, EMP_TABLE_DATA2, Rows, deleteCallback);
  277.   NdbSleep_SecSleep(1);
  278. }
  280. /*---------------------------------------------------------------------------*/
  281. NDB_COMMAND(newton_basic, "newton_basic", 
  282.     "newton_basic", "newton_basic", 65535){
  284.   DbCreate();
  285.   CreateBindings();
  287.   BasicArray();
  288.   BasicPtr();
  289.   Multi();
  290.   
  291.   DBA_Close();
  293.   return 0;
  294. }
  298. /**
  299.  *  callbackStatusCheck  checks whether or not the operation succeeded
  300.  */
  301. void
  302. callbackStatusCheck( DBA_Error_t status, const char* operation) {
  303.   ndbout_c("%s: %d", operation, status);
  304. }
  306. void insertCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  307.   callbackStatusCheck(s, "insert");
  308. }
  309. void deleteCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  310.   callbackStatusCheck(s, "delete");
  311. }
  312. void updateCallback( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  313.   callbackStatusCheck(s, "update");
  314. }
  315. void readCallback  ( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  316.   callbackStatusCheck(s, "read");
  317. }
  318. void writeCallback  ( DBA_ReqId_t, DBA_Error_t s, DBA_ErrorCode_t ){
  319.   callbackStatusCheck(s, "write");
  320. }