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

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

MySQL数据库

开发平台：

Visual C++

dba_dac.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 "dba_internal.hpp"
  19. #include <NdbSleep.h>
  21. static void
  22. DBA__ErrorMapping(const NdbError & err, DBA_Error_t * status){
  23.   switch(err.classification){
  24.   case NdbError::ConstraintViolation:
  25.     * status = DBA_CONSTRAINT_VIOLATION;
  26.     break;
  27.     
  28.   case NdbError::NoDataFound:
  29.     * status = DBA_NO_DATA;
  30.     break;
  31.     
  32.   case NdbError::TemporaryResourceError:
  33.   case NdbError::NodeRecoveryError:
  34.     * status = DBA_TEMPORARY_ERROR;
  35.     break;
  36.     
  37.   case NdbError::InsufficientSpace:
  38.     * status = DBA_INSUFFICIENT_SPACE;
  39.     break;
  40.     
  41.   case NdbError::UnknownResultError:
  42.     * status = DBA_UNKNOWN_RESULT;
  43.     break;
  44.     
  45.   case NdbError::OverloadError:
  46.     * status = DBA_OVERLOAD;
  47.     break;
  48.     
  49.   case NdbError::TimeoutExpired:
  50.     * status = DBA_TIMEOUT;
  51.     break;
  53.   case NdbError::SchemaError:
  54.     * status = DBA_SCHEMA_ERROR;
  55.     break;
  57.   case NdbError::ApplicationError:
  58.     * status = DBA_APPLICATION_ERROR;
  59.     break;
  61.   case NdbError::InternalError:
  62.   default:
  63.     * status = DBA_NDB_ERROR;
  64.     break;
  65.   }
  66. }
  68. /**
  69.  * Map between NDB error codes and DBA error codes
  70.  */
  71. static
  72. void
  73. DBA__CallbackErrorCodeMapping(int errorCode, 
  74.       NdbConnection * connection,
  75.       DBA_Error_t * status,
  76.       DBA_ErrorCode_t * errCode) {
  77.   if(errorCode == 0){
  78.     * status  = DBA_NO_ERROR;
  79.     * errCode = 0;
  80.     return;
  81.   }
  82.   const NdbError & err = connection->getNdbError();
  83.   DBA__ErrorMapping(err, status);
  84.   * errCode = err.code;
  85. }
  87. /**
  88.  * When startTransaction fails
  89.  */
  90. static
  91. void
  92. DBA__ConnectionErrorMapping(Ndb * theNdb){
  93.   const NdbError & err = theNdb->getNdbError();
  95.   DBA_Error_t status;
  96.   DBA__ErrorMapping(err, &status);
  97.   
  98.   DBA__SetLatestError(status, err.code,
  99.       err.message);
  100. }
  102. /**
  103.  * When getNdbOperation fails
  104.  */
  105. static
  106. void
  107. DBA__OperationErrorMapping(Ndb * theNdb, NdbConnection * con){
  108.   const NdbError & err = theNdb->getNdbError();
  110.   DBA_Error_t status;
  111.   DBA__ErrorMapping(err, &status);
  112.   
  113.   DBA__SetLatestError(status, err.code,
  114.       err.message);
  115. }
  117. /**
  118.  * When equal/get/set value fails
  119.  */
  120. static
  121. void
  122. DBA__EqualErrorMapping(Ndb * theNdb, NdbConnection * con, NdbOperation * op){
  123.   const NdbError & err = theNdb->getNdbError();
  125.   DBA_Error_t status;
  126.   DBA__ErrorMapping(err, &status);
  127.   
  128.   DBA__SetLatestError(status, err.code,
  129.       err.message);
  130. }
  132. static
  133. void 
  134. NewtonCallback(int errorCode,
  135.        NdbConnection * connection,
  136.        void * anyObject){
  137.   
  138.   DBA_AsyncCallbackFn_t CbFunc = (DBA_AsyncCallbackFn_t)anyObject;
  139.   DBA_ReqId_t  ReqId = (DBA_ReqId_t) connection;
  140.   
  141.   DBA_Error_t     Status = (DBA_Error_t) errorCode;
  142.   DBA_ErrorCode_t Impl_Status ;
  143.   
  144.   DBA__CallbackErrorCodeMapping(errorCode, connection, &Status, &Impl_Status);
  145.   
  146.   DBA__TheNdb->closeTransaction(connection);
  147.   
  148.   DBA__RecvTransactions++;
  150.   CbFunc(ReqId, Status, Impl_Status);
  151. }
  153. /**
  154.  * Start transaction
  155.  */
  156. NdbConnection *
  157. startTransaction(){
  158.   NdbConnection * con = DBA__TheNdb->startTransaction();
  159.   if(con != 0)
  160.     return con;
  162.   const int _t = (DBA__SentTransactions - DBA__RecvTransactions);
  163.   const int t = (_t>0?_t:-_t);
  164.   
  165.   if(!(DBA__TheNdb->getNdbError().code == 4006 && t > 1000)){
  166.     DBA_DEBUG("DBA__TheNdb->getNdbError() = " << 
  167.       DBA__TheNdb->getNdbError());
  168.   }
  169.   
  170.   int sum = 0;
  171.   int sleepTime = 10;
  172.   for(; con == 0 && sum < DBA__StartTransactionTimout; ){
  173.     NdbMutex_Unlock(DBA__TheNewtonMutex);
  174.     NdbSleep_MilliSleep(sleepTime);
  175.     NdbMutex_Lock(DBA__TheNewtonMutex);
  176.     con = DBA__TheNdb->startTransaction();
  177.     
  178.     sum       += sleepTime;
  179.     sleepTime += 10;
  180.   }
  181.   
  182.   return con;
  183. }
  185. #define CHECK_BINDINGS(Bindings) 
  186.   if(!DBA__ValidBinding(Bindings)){ 
  187.     DBA__SetLatestError(DBA_APPLICATION_ERROR, 0, "Invalid bindings"); 
  188.     return DBA_INVALID_REQID; 
  189.   } 
  191. #define CHECK_BINDINGS2(Bindings, NbBindings) 
  192.   if(!DBA__ValidBindings(Bindings, NbBindings)){ 
  193.     DBA__SetLatestError(DBA_APPLICATION_ERROR, 0, "Invalid bindings"); 
  194.     return DBA_INVALID_REQID; 
  195.   }
  197. #define CHECK_CONNECTION(Connection) 
  198.   if(Connection == 0){ 
  199.     DBA__ConnectionErrorMapping(DBA__TheNdb); 
  200.     NdbMutex_Unlock(DBA__TheNewtonMutex); 
  201.     return DBA_INVALID_REQID; 
  202.   }
  204. #define CHECK_OPERATION(Connection, Operation) 
  205.   if(Operation == 0){ 
  206.     DBA__OperationErrorMapping(DBA__TheNdb, Connection); 
  207.     DBA__TheNdb->closeTransaction(Connection); 
  208.     NdbMutex_Unlock(DBA__TheNewtonMutex); 
  209.     return DBA_INVALID_REQID; 
  210.   }
  212. #define EQUAL_ERROR(Connection, Operation) { 
  213.     DBA__EqualErrorMapping(DBA__TheNdb, Connection, Operation); 
  214.     DBA__TheNdb->closeTransaction(Connection); 
  215.     NdbMutex_Unlock(DBA__TheNewtonMutex); 
  216.     return DBA_INVALID_REQID; 
  217.   }
  219. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  221. extern "C" 
  222. DBA_ReqId_t
  223. DBA_ReadRows( const DBA_Binding_t* pBindings, void* const * _pData,
  224.       int NbRows,
  225.       DBA_AsyncCallbackFn_t CbFunc ) {
  226.   
  227.   CHECK_BINDINGS(pBindings);
  228.   
  229.   NdbMutex_Lock(DBA__TheNewtonMutex);
  230.   NdbConnection * con = startTransaction();
  231.   
  232.   CHECK_CONNECTION(con);
  233.   
  234.   for(int i = 0; i<NbRows; i++){
  235.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  236.     
  237.     CHECK_OPERATION(con, op);
  238.     
  239.     op->simpleRead();
  240.     
  241.     void * pData = _pData[i];
  242.     
  243.     if(!DBA__EqualGetValue(op, pBindings, pData)){
  244.       EQUAL_ERROR(con, op);
  245.     }
  246.   }
  248.   con->executeAsynchPrepare(Commit,
  249.     NewtonCallback,
  250.     (void*)CbFunc);
  251.   
  252.   DBA__SentTransactions++;
  253.   
  254.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  255.   return (DBA_ReqId_t) con;
  256. }
  258. extern "C"
  259. DBA_ReqId_t
  260. DBA_ArrayReadRows( const DBA_Binding_t* pBindings, void * pData,
  261.    int NbRows,
  262.    DBA_AsyncCallbackFn_t CbFunc ){
  263.   CHECK_BINDINGS(pBindings);
  265.   NdbMutex_Lock(DBA__TheNewtonMutex);
  266.   NdbConnection * con = startTransaction();
  268.   CHECK_CONNECTION(con);
  269.   
  270.   for(int i = 0; i<NbRows; i++){
  271.     NdbOperation * op  = con->getNdbOperation(pBindings->tableName);
  273.     CHECK_OPERATION(con, op);
  274.     
  275.     op->simpleRead();
  276.     
  277.     if(!DBA__EqualGetValue(op, pBindings, 
  278.    ((char*)pData)+i*pBindings->structSz)){
  279.       EQUAL_ERROR(con, op);
  280.     }
  281.   }
  283.   con->executeAsynchPrepare(Commit,
  284.     NewtonCallback,
  285.     (void*)CbFunc);
  286.   
  287.   DBA__SentTransactions++;
  289.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  290.   return (DBA_ReqId_t) con;
  291. }
  293. extern "C"
  294. DBA_ReqId_t
  295. DBA_MultiReadRow(const DBA_Binding_t * const * pBindings,
  296.  void * const * pData,
  297.  int NbBindings,
  298.  DBA_AsyncCallbackFn_t CbFunc ) {
  299.   CHECK_BINDINGS2(pBindings, NbBindings);
  300.     
  301.   NdbMutex_Lock(DBA__TheNewtonMutex);
  302.   NdbConnection * con = startTransaction();
  303.   
  304.   CHECK_CONNECTION(con);
  305.   
  306.   for(int i = 0; i<NbBindings; i++){
  307.     NdbOperation * op  = con->getNdbOperation(pBindings[i]->tableName);
  308.     
  309.     CHECK_OPERATION(con, op);
  311.     op->simpleRead();
  312.     
  313.     if(!DBA__EqualGetValue(op, pBindings[i], pData[i])){
  314.       EQUAL_ERROR(con, op);
  315.     }
  316.   }
  317.   
  318.   con->executeAsynchPrepare(Commit,
  319.     NewtonCallback,
  320.     (void*)CbFunc);
  322.   DBA__SentTransactions++;
  323.   
  324.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  325.   return (DBA_ReqId_t) con;
  326. }
  328. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  330. extern "C" 
  331. DBA_ReqId_t
  332. DBA_InsertRows( const DBA_Binding_t* pBindings, const void * const * _pData,
  333. int NbRows,
  334. DBA_AsyncCallbackFn_t CbFunc ) {
  335.   CHECK_BINDINGS(pBindings);
  337.   NdbMutex_Lock(DBA__TheNewtonMutex);
  338.   NdbConnection * con = startTransaction();
  340.   CHECK_CONNECTION(con);
  341.   
  342.   for(int i = 0; i<NbRows; i++){
  343.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  345.     CHECK_OPERATION(con, op);
  347.     op->insertTuple();
  348.     
  349.     const void * pData = _pData[i];
  351.     if(!DBA__EqualSetValue(op, pBindings, pData)){
  352.       EQUAL_ERROR(con, op);
  353.     }
  354.   }
  356.   con->executeAsynchPrepare(Commit,
  357.     NewtonCallback,
  358.     (void*)CbFunc);
  359.   
  360.   
  361.   DBA__SentTransactions++;
  363.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  364.   return (DBA_ReqId_t) con;
  365. }
  367. extern "C"
  368. DBA_ReqId_t
  369. DBA_ArrayInsertRows( const DBA_Binding_t* pBindings, const void * pData,
  370.      int NbRows,
  371.      DBA_AsyncCallbackFn_t CbFunc ){
  372.   CHECK_BINDINGS(pBindings);
  374.   NdbMutex_Lock(DBA__TheNewtonMutex);
  375.   NdbConnection * con = startTransaction();
  377.   CHECK_CONNECTION(con);
  378.   
  379.   for(int i = 0; i<NbRows; i++){
  380.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  382.     CHECK_OPERATION(con, op);
  384.     op->insertTuple();
  385.     
  386.     if(!DBA__EqualSetValue(op, pBindings, 
  387.    ((char*)pData)+i*pBindings->structSz)){
  388.       EQUAL_ERROR(con, op);
  389.     }
  390.   }
  392.   con->executeAsynchPrepare(Commit,
  393.     NewtonCallback,
  394.     (void*)CbFunc);
  395.   
  396.   DBA__SentTransactions++;
  398.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  399.   return (DBA_ReqId_t) con;
  400. }
  402. extern "C"
  403. DBA_ReqId_t
  404. DBA_MultiInsertRow(const DBA_Binding_t * const * pBindings,
  405.    const void * const * pData,
  406.    int NbBindings,
  407.    DBA_AsyncCallbackFn_t CbFunc ) {
  408.   CHECK_BINDINGS2(pBindings, NbBindings);
  410.   NdbMutex_Lock(DBA__TheNewtonMutex);
  411.   NdbConnection * con = startTransaction();
  413.   CHECK_CONNECTION(con);
  414.   
  415.   for(int i = 0; i<NbBindings; i++){
  416.     NdbOperation  * op  = con->getNdbOperation(pBindings[i]->tableName);
  418.     CHECK_OPERATION(con, op);
  420.     op->insertTuple();
  422.     if(!DBA__EqualSetValue(op, pBindings[i], pData[i])){
  423.       EQUAL_ERROR(con, op);
  424.     }
  425.   }
  426.   
  427.   con->executeAsynchPrepare(Commit,
  428.     NewtonCallback,
  429.     (void*)CbFunc);
  430.   
  431.   DBA__SentTransactions++;
  433.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  434.   return (DBA_ReqId_t) con;
  435. }
  437. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  439. extern "C" 
  440. DBA_ReqId_t
  441. DBA_UpdateRows( const DBA_Binding_t* pBindings, const void * const * _pData,
  442. int NbRows,
  443. DBA_AsyncCallbackFn_t CbFunc ) {
  444.   CHECK_BINDINGS(pBindings);
  446.   NdbMutex_Lock(DBA__TheNewtonMutex);
  447.   NdbConnection * con = startTransaction();
  449.   CHECK_CONNECTION(con);
  450.   
  451.   for(int i = 0; i<NbRows; i++){
  452.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  454.     CHECK_OPERATION(con, op);
  456.     op->updateTuple();
  457.     
  458.     const void * pData = _pData[i];
  460.     if(!DBA__EqualSetValue(op, pBindings, pData)){
  461.       EQUAL_ERROR(con, op);
  462.     }
  463.   }
  465.   con->executeAsynchPrepare(Commit,
  466.     NewtonCallback,
  467.     (void*)CbFunc);
  468.   
  469.   
  470.   DBA__SentTransactions++;
  472.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  473.   return (DBA_ReqId_t) con;
  474. }
  476. extern "C"
  477. DBA_ReqId_t
  478. DBA_ArrayUpdateRows( const DBA_Binding_t* pBindings, const void * pData,
  479.      int NbRows,
  480.      DBA_AsyncCallbackFn_t CbFunc ){
  481.   CHECK_BINDINGS(pBindings);
  483.   NdbMutex_Lock(DBA__TheNewtonMutex);
  484.   NdbConnection * con = startTransaction();
  486.   CHECK_CONNECTION(con);
  487.   
  488.   for(int i = 0; i<NbRows; i++){
  489.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  491.     CHECK_OPERATION(con, op);
  493.     op->updateTuple();
  494.     
  495.     if(!DBA__EqualSetValue(op, pBindings, 
  496.    ((char*)pData)+i*pBindings->structSz)){
  497.       EQUAL_ERROR(con, op);
  498.     }
  499.   }
  501.   con->executeAsynchPrepare(Commit,
  502.     NewtonCallback,
  503.     (void*)CbFunc);
  504.   
  505.   DBA__SentTransactions++;
  507.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  508.   return (DBA_ReqId_t) con;
  509. }
  511. extern "C"
  512. DBA_ReqId_t
  513. DBA_MultiUpdateRow(const DBA_Binding_t * const * pBindings,
  514.    const void * const * pData,
  515.    int NbBindings,
  516.    DBA_AsyncCallbackFn_t CbFunc ) {
  517.   CHECK_BINDINGS2(pBindings, NbBindings);
  519.   NdbMutex_Lock(DBA__TheNewtonMutex);
  520.   NdbConnection * con = startTransaction();
  522.   CHECK_CONNECTION(con);
  523.   
  524.   for(int i = 0; i<NbBindings; i++){
  525.     NdbOperation  * op  = con->getNdbOperation(pBindings[i]->tableName);
  527.     CHECK_OPERATION(con, op);
  529.     op->updateTuple();
  530.     
  531.     if(!DBA__EqualSetValue(op, pBindings[i], pData[i])){
  532.       EQUAL_ERROR(con, op);
  533.     }
  534.   }
  535.   
  536.   con->executeAsynchPrepare(Commit,
  537.     NewtonCallback,
  538.     (void*)CbFunc);
  539.   
  540.   DBA__SentTransactions++;
  542.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  543.   return (DBA_ReqId_t) con;
  544. }
  546. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  548. extern "C" 
  549. DBA_ReqId_t
  550. DBA_WriteRows( const DBA_Binding_t* pBindings, const void * const * _pData,
  551.        int NbRows,
  552.        DBA_AsyncCallbackFn_t CbFunc ) {
  553.   CHECK_BINDINGS(pBindings);
  555.   NdbMutex_Lock(DBA__TheNewtonMutex);
  556.   NdbConnection * con = startTransaction();
  558.   CHECK_CONNECTION(con);
  559.   
  560.   for(int i = 0; i<NbRows; i++){
  561.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  563.     CHECK_OPERATION(con, op);
  565.     op->writeTuple();
  566.     
  567.     const void * pData = _pData[i];
  569.     if(!DBA__EqualSetValue(op, pBindings, pData)){
  570.       EQUAL_ERROR(con, op);
  571.     }
  572.   }
  574.   con->executeAsynchPrepare(Commit,
  575.     NewtonCallback,
  576.     (void*)CbFunc);
  577.   
  578.   
  579.   DBA__SentTransactions++;
  581.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  582.   return (DBA_ReqId_t) con;
  583. }
  585. extern "C"
  586. DBA_ReqId_t
  587. DBA_ArrayWriteRows( const DBA_Binding_t* pBindings, const void * pData,
  588.     int NbRows,
  589.     DBA_AsyncCallbackFn_t CbFunc ){
  590.   CHECK_BINDINGS(pBindings);
  592.   NdbMutex_Lock(DBA__TheNewtonMutex);
  593.   NdbConnection * con = startTransaction();
  595.   CHECK_CONNECTION(con);
  596.   
  597.   for(int i = 0; i<NbRows; i++){
  598.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  600.     CHECK_OPERATION(con, op);
  602.     op->writeTuple();
  603.     
  604.     if(!DBA__EqualSetValue(op, pBindings, 
  605.    ((char*)pData)+i*pBindings->structSz)){
  606.       EQUAL_ERROR(con, op);
  607.     }
  608.   }
  610.   con->executeAsynchPrepare(Commit,
  611.     NewtonCallback,
  612.     (void*)CbFunc);
  613.   
  614.   DBA__SentTransactions++;
  616.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  617.   return (DBA_ReqId_t) con;
  618. }
  620. extern "C"
  621. DBA_ReqId_t
  622. DBA_MultiWriteRow(const DBA_Binding_t * const * pBindings,
  623.   const void * const * pData,
  624.   int NbBindings,
  625.   DBA_AsyncCallbackFn_t CbFunc ) {
  626.   CHECK_BINDINGS2(pBindings, NbBindings);
  627.   
  628.   NdbMutex_Lock(DBA__TheNewtonMutex);
  629.   NdbConnection * con = startTransaction();
  630.   
  631.   CHECK_CONNECTION(con);
  633.   for(int i = 0; i<NbBindings; i++){
  634.     NdbOperation  * op  = con->getNdbOperation(pBindings[i]->tableName);
  636.     CHECK_OPERATION(con, op);
  638.     op->writeTuple();
  639.     
  640.     if(!DBA__EqualSetValue(op, pBindings[i], pData[i])){
  641.       EQUAL_ERROR(con, op);
  642.     }
  643.   }
  644.   
  645.   con->executeAsynchPrepare(Commit,
  646.     NewtonCallback,
  647.     (void*)CbFunc);
  648.   
  649.   DBA__SentTransactions++;
  651.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  652.   return (DBA_ReqId_t) con;
  653. }
  655. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  657. extern "C" 
  658. DBA_ReqId_t
  659. DBA_DeleteRows( const DBA_Binding_t* pBindings, const void * const * _pData,
  660. int NbRows,
  661. DBA_AsyncCallbackFn_t CbFunc ) {
  662.   CHECK_BINDINGS(pBindings);
  664.   NdbMutex_Lock(DBA__TheNewtonMutex);
  665.   NdbConnection * con = startTransaction();
  667.   CHECK_CONNECTION(con);
  669.   for(int i = 0; i<NbRows; i++){
  670.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  672.     CHECK_OPERATION(con, op);
  674.     op->deleteTuple();
  675.     
  676.     const void * pData = _pData[i];
  677.     
  678.     if(!DBA__Equal(op, pBindings, pData)){
  679.       EQUAL_ERROR(con, op);
  680.     }
  681.   }
  683.   con->executeAsynchPrepare(Commit,
  684.     NewtonCallback,
  685.     (void*)CbFunc);
  686.   
  687.   DBA__SentTransactions++;
  688.   
  689.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  690.   return (DBA_ReqId_t) con;
  691. }
  693. extern "C"
  694. DBA_ReqId_t
  695. DBA_ArrayDeleteRows( const DBA_Binding_t* pBindings, const void * pData,
  696.      int NbRows,
  697.      DBA_AsyncCallbackFn_t CbFunc ){
  698.   CHECK_BINDINGS(pBindings);
  700.   NdbMutex_Lock(DBA__TheNewtonMutex);
  701.   NdbConnection * con = startTransaction();
  703.   CHECK_CONNECTION(con);
  705.   for(int i = 0; i<NbRows; i++){
  706.     NdbOperation  * op  = con->getNdbOperation(pBindings->tableName);
  708.     CHECK_OPERATION(con, op);
  710.     op->deleteTuple();
  711.     
  712.     if(!DBA__Equal(op, pBindings, 
  713.    ((char*)pData)+i*pBindings->structSz)){
  714.       EQUAL_ERROR(con, op);
  715.     }
  716.   }
  718.   con->executeAsynchPrepare(Commit,
  719.     NewtonCallback,
  720.     (void*)CbFunc);
  721.   
  722.   DBA__SentTransactions++;
  724.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  725.   return (DBA_ReqId_t) con;
  726. }
  728. extern "C"
  729. DBA_ReqId_t
  730. DBA_MultiDeleteRow(const DBA_Binding_t * const * pBindings,
  731.    const void * const * pData,
  732.    int NbBindings,
  733.    DBA_AsyncCallbackFn_t CbFunc ) {
  734.   CHECK_BINDINGS2(pBindings, NbBindings);
  736.   NdbMutex_Lock(DBA__TheNewtonMutex);
  737.   NdbConnection * con = startTransaction();
  739.   CHECK_CONNECTION(con);
  740.   
  741.   for(int i = 0; i<NbBindings; i++){
  742.     NdbOperation  * op  = con->getNdbOperation(pBindings[i]->tableName);
  744.     CHECK_OPERATION(con, op);
  746.     op->deleteTuple();
  747.     
  748.     if(!DBA__Equal(op, pBindings[i], pData[i])){
  749.       EQUAL_ERROR(con, op);
  750.     }
  751.   }
  752.   
  753.   con->executeAsynchPrepare(Commit,
  754.     NewtonCallback,
  755.     (void*)CbFunc);
  756.   
  757.   DBA__SentTransactions++;
  759.   NdbMutex_Unlock(DBA__TheNewtonMutex);
  760.   return (DBA_ReqId_t) con;
  761. }
  763. /****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/
  765. bool
  766. DBA__EqualGetValue(NdbOperation * op,
  767.    const DBA_Binding_t* pBindings,
  768.    void * pData){
  769.   for(int i = 0; i<pBindings->noOfKeys; i++){
  770.     if(op->equal(pBindings->keyIds[i], 
  771.  (const char*)pData+pBindings->keyOffsets[i]) == -1){
  772.       return false;
  773.     }
  774.   }
  775.   
  776.   for(int i = 0; i<pBindings->noOfColumns; i++){
  777.     if(op->getValue(pBindings->columnIds[i], 
  778.     (char*)pData+pBindings->columnOffsets[i]) == 0){
  779.       return false;
  780.     }
  781.   }
  783.   for(int i = 0; i<pBindings->noOfSubBindings; i++){
  784.     void * tData = *(void**)((char *)pData+pBindings->subBindingOffsets[i]);
  785.     const DBA_Binding_t * tBinding = pBindings->subBindings[i];
  786.     if(!DBA__EqualGetValue(op, tBinding, tData))
  787.       return false;
  788.   }
  789.   
  790.   return true;
  791. }
  793. bool
  794. DBA__EqualSetValue(NdbOperation * op,
  795.    const DBA_Binding_t* pBindings,
  796.    const void * pData){
  797.   
  798.   for(int i = 0; i<pBindings->noOfKeys; i++){
  799.     if(op->equal(pBindings->keyIds[i], 
  800.  (const char*)pData+pBindings->keyOffsets[i]) == -1){
  801.       return false;
  802.     }
  803.   }
  804.   
  805.   for(int i = 0; i<pBindings->noOfColumns; i++){
  806.     if(op->setValue(pBindings->columnIds[i], 
  807.     (char*)pData+pBindings->columnOffsets[i]) == -1){
  808.       return false;
  809.     }
  810.   }
  812.   for(int i = 0; i<pBindings->noOfSubBindings; i++){
  813.     void * tData = * (void**)((char *)pData+pBindings->subBindingOffsets[i]);
  814.     const DBA_Binding_t * tBinding = pBindings->subBindings[i];
  815.     if(!DBA__EqualSetValue(op, tBinding, tData))
  816.       return false;
  817.   }
  818.   
  819.   return true;
  820. }
  822. bool
  823. DBA__Equal(NdbOperation * op,
  824.    const DBA_Binding_t* pBindings,
  825.    const void * pData){
  826.   
  827.   for(int i = 0; i<pBindings->noOfKeys; i++)
  828.     if(op->equal(pBindings->keyIds[i], 
  829.  (const char*)pData+pBindings->keyOffsets[i]) == -1){
  830.       return false;
  831.     }
  832.   
  833.   for(int i = 0; i<pBindings->noOfSubBindings; i++){
  834.     void * tData = *(void**)((char *)pData+pBindings->subBindingOffsets[i]);
  835.     const DBA_Binding_t * tBinding = pBindings->subBindings[i];
  836.     if(!DBA__Equal(op, tBinding, tData))
  837.       return false;
  838.   }
  839.   
  840.   return true;
  841. }