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

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

MySQL数据库

开发平台：

Visual C++

TraceNdbApi.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 */
  17. #include <NdbApi.hpp>
  18. #include <NdbOut.hpp>
  19. #include <NdbMutex.h>
  21. #include "TraceNdbApi.hpp"
  24. int g_nParamTrace;
  25. NdbMutex* g_pNdbMutexTrace = 0;
  28. void TraceBegin(void)
  29. {
  30.   if(!g_pNdbMutexTrace)
  31.   {
  32.     g_pNdbMutexTrace = NdbMutex_Create();
  33.   }
  34.   NdbMutex_Lock(g_pNdbMutexTrace);
  35.   g_nParamTrace = 0;
  36. }
  38. void TraceEnd(void)
  39. {
  40.   ndbout << endl;
  41.   g_nParamTrace = 0;
  42.   NdbMutex_Unlock(g_pNdbMutexTrace);
  43. }
  45. void TraceMethod(const char* szMethod)
  46. {
  47.   ndbout << "->" << szMethod << "(";
  48.   g_nParamTrace = 0;
  49. }
  51. void TraceParamComma(void)
  52. {
  53.   if(g_nParamTrace)
  54.   {
  55.     ndbout << ", ";
  56.   }
  57.   ++g_nParamTrace;
  58. }
  60. void TraceNdb(Ndb* pNdb)
  61. {
  62.   TraceParamComma();
  63.   ndbout << "((Ndb*)" << hex << (Uint32)pNdb << ")";
  64. }
  66. void TraceNdbSchemaCon(NdbSchemaCon* pNdbSchemaCon)
  67. {
  68.   TraceParamComma();
  69.   ndbout << "((NdbSchemaCon*)" << hex << (Uint32)pNdbSchemaCon << ")";
  70. }
  72. void TraceNdbSchemaOp(NdbSchemaOp* pNdbSchemaOp)
  73. {
  74.   TraceParamComma();
  75.   ndbout << "((NdbSchemaOp*)" << hex << (Uint32)pNdbSchemaOp << ")";
  76. }
  78. void TraceNdbConnection(const NdbConnection* pNdbConnection)
  79. {
  80.   TraceParamComma();
  81.   ndbout << "((NdbConnection*)" << hex << (Uint32)pNdbConnection << ")";
  82. }
  84. void TraceNdbOperation(NdbOperation* pNdbOperation)
  85. {
  86.   TraceParamComma();
  87.   ndbout << "((NdbOperation*)" << hex << (Uint32)pNdbOperation << ")";
  88. }
  90. void TraceNdbIndexOperation(NdbIndexOperation* pNdbIndexOperation)
  91. {
  92.   TraceParamComma();
  93.   ndbout << "((NdbIndexOperation*)" << hex << (Uint32)pNdbIndexOperation << ")";
  94. }
  96. void TraceNdbRecAttr(NdbRecAttr* pNdbRecAttr)
  97. {
  98.   TraceParamComma();
  99.   ndbout << "((NdbRecAttr*)" << hex << (Uint32)pNdbRecAttr << ")";
  100. }
  102. void TraceTable(Table* pTable)
  103. {
  104.   TraceParamComma();
  105.   ndbout << "((Table*)" << hex << (Uint32)pTable << ")";
  106. }
  108. void TraceString(const char* szParam)
  109. {
  110.   TraceParamComma();
  111.   ndbout << """ << szParam << """;
  112. }
  114. void TraceInt(const int i)
  115. {
  116.   TraceParamComma();
  117.   ndbout << "(int)" << dec << i;
  118. }
  120. void TraceUint32(const Uint32 n)
  121. {
  122.   TraceParamComma();
  123.   ndbout << "(Uint32)" << dec << n;
  124. }
  126. void TraceKeyType(const KeyType aKeyType)
  127. {
  128.   TraceParamComma();
  129.   switch(aKeyType)
  130.   {
  131.   case Undefined: ndbout << "Undefined"; break;
  132.   case NoKey: ndbout << "NoKey"; break;
  133.   case TupleKey: ndbout << "TupleKey"; break;
  134.   case TupleId: ndbout << "TupleId"; break;
  135.   default:  ndbout << "(KeyType)" << aKeyType; break;
  136.   }
  137. }
  139. void TraceExecType(const ExecType aExecType)
  140. {
  141.   switch(aExecType)
  142.   {
  143.   case NoExecTypeDef: ndbout << "NoExecTypeDef"; break;
  144.   case Prepare: ndbout << "Prepare"; break;
  145.   case NoCommit: ndbout << "NoCommit"; break;
  146.   case Commit: ndbout << "Commit"; break;
  147.   case Rollback: ndbout << "Rollback"; break;
  148.   default: ndbout << "(ExecType)" << aExecType; break;
  149.   }
  150. }
  153. void TraceNdbError(const NdbError& err)
  154. {
  155.   TraceParamComma();
  156.   ndbout << "(NdbError)" << err;
  157. }
  161. void TraceVoid(void)
  162. {
  163.   ndbout << "void";
  164. }
  166. void TraceReturn(void)
  167. {
  168.   ndbout << "); // return ";
  169.   g_nParamTrace = 0;
  170. }
  173. // TraceNdbSchemaOp
  175. int CTraceNdbSchemaOp::createTable(const char* aTableName)
  176. {
  177.   int i = NdbSchemaOp::createTable(aTableName);
  178.   TraceBegin();
  179.   TraceNdbSchemaOp(this);
  180.   TraceMethod("createTable");
  181.   TraceString(aTableName);
  182.   TraceReturn();
  183.   TraceInt(i);
  184.   TraceEnd();
  185.   return i;
  186. }
  188. int CTraceNdbSchemaOp::createAttribute(const char* aAttrName, KeyType aTupleyKey)
  189. {
  190.   int i = NdbSchemaOp::createAttribute(aAttrName, aTupleyKey);
  191.   TraceBegin();
  192.   TraceNdbSchemaOp(this);
  193.   TraceMethod("createAttribute");
  194.   TraceString(aAttrName);
  195.   TraceKeyType(aTupleyKey);
  196.   TraceReturn();
  197.   TraceInt(i);
  198.   TraceEnd();
  199.   return i;
  200. }
  204. // TraceNdbSchemaCon
  206. CTraceNdbSchemaOp* CTraceNdbSchemaCon::getNdbSchemaOp()
  207. { 
  208.   NdbSchemaOp* pNdbSchemaOp = NdbSchemaCon::getNdbSchemaOp();
  209.   TraceBegin();
  210.   TraceNdbSchemaCon(this);
  211.   TraceMethod("getNdbSchemaOp");
  212.   TraceReturn();
  213.   TraceNdbSchemaOp(pNdbSchemaOp);
  214.   TraceEnd();
  215.   return (CTraceNdbSchemaOp*)pNdbSchemaOp; 
  216. }
  218. int CTraceNdbSchemaCon::execute()
  219. {
  220.   int i = NdbSchemaCon::execute();
  221.   TraceBegin();
  222.   TraceNdbSchemaCon(this);
  223.   TraceMethod("execute");
  224.   TraceReturn();
  225.   TraceInt(i);
  226.   TraceEnd();
  227.   return i;
  228. }
  232. // TraceNdbRecAttr
  234. Uint32 CTraceNdbRecAttr::u_32_value()
  235. {
  236.   Uint32 n = NdbRecAttr::u_32_value();
  237.   TraceBegin();
  238.   TraceNdbRecAttr(this);
  239.   TraceMethod("u_32_value");
  240.   TraceReturn();
  241.   TraceUint32(n);
  242.   TraceEnd();
  243.   return n;
  244. }
  248. // TraceNdbOperation
  250. int CTraceNdbOperation::insertTuple()
  251. {
  252.   int i = NdbOperation::insertTuple();
  253.   TraceBegin();
  254.   TraceNdbOperation(this);
  255.   TraceMethod("insertTuple");
  256.   TraceReturn();
  257.   TraceInt(i);
  258.   TraceEnd();
  259.   return i;
  260. }
  262. int CTraceNdbOperation::updateTuple()
  263. {
  264.   int i = NdbOperation::updateTuple();
  265.   TraceBegin();
  266.   TraceNdbOperation(this);
  267.   TraceMethod("updateTuple");
  268.   TraceReturn();
  269.   TraceInt(i);
  270.   TraceEnd();
  271.   return i;
  272. }
  274. int CTraceNdbOperation::interpretedUpdateTuple()
  275. {
  276.   int i = NdbOperation::interpretedUpdateTuple();
  277.   TraceBegin();
  278.   TraceNdbOperation(this);
  279.   TraceMethod("interpretedUpdateTuple");
  280.   TraceReturn();
  281.   TraceInt(i);
  282.   TraceEnd();
  283.   return i;
  284. }
  286. int CTraceNdbOperation::readTuple()
  287. {
  288.   int i = NdbOperation::readTuple();
  289.   TraceBegin();
  290.   TraceNdbOperation(this);
  291.   TraceMethod("readTuple");
  292.   TraceReturn();
  293.   TraceInt(i);
  294.   TraceEnd();
  295.   return i;
  296. }
  299. int CTraceNdbOperation::readTupleExclusive()
  300. {
  301.   int i = NdbOperation::readTupleExclusive();
  302.   TraceBegin();
  303.   TraceNdbOperation(this);
  304.   TraceMethod("readTupleExclusive");
  305.   TraceReturn();
  306.   TraceInt(i);
  307.   TraceEnd();
  308.   return i;
  309. }
  312. int CTraceNdbOperation::deleteTuple()
  313. {
  314.   int i = NdbOperation::deleteTuple();
  315.   TraceBegin();
  316.   TraceNdbOperation(this);
  317.   TraceMethod("deleteTuple");
  318.   TraceReturn();
  319.   TraceInt(i);
  320.   TraceEnd();
  321.   return i;
  322. }
  324. int CTraceNdbOperation::equal(const char* anAttrName, Uint32 aValue)
  325. {
  326.   int i = NdbOperation::equal(anAttrName, aValue);
  327.   TraceBegin();
  328.   TraceNdbOperation(this);
  329.   TraceMethod("equal");
  330.   TraceString(anAttrName);
  331.   TraceUint32(aValue);
  332.   TraceReturn();
  333.   TraceInt(i);
  334.   TraceEnd();
  335.   return i;
  336. }
  338. int CTraceNdbOperation::setValue(const char* anAttrName, Uint32 aValue)
  339. {
  340.   int i = NdbOperation::setValue(anAttrName, aValue);
  341.   TraceBegin();
  342.   TraceNdbOperation(this);
  343.   TraceMethod("setValue");
  344.   TraceString(anAttrName);
  345.   TraceUint32(aValue);
  346.   TraceReturn();
  347.   TraceInt(i);
  348.   TraceEnd();
  349.   return i;
  350. }
  352. int CTraceNdbOperation::incValue(const char* anAttrName, Uint32 aValue)
  353. {
  354.   int i = NdbOperation::incValue(anAttrName, aValue);
  355.   TraceBegin();
  356.   TraceNdbOperation(this);
  357.   TraceMethod("incValue");
  358.   TraceString(anAttrName);
  359.   TraceUint32(aValue);
  360.   TraceReturn();
  361.   TraceInt(i);
  362.   TraceEnd();
  363.   return i;
  364. }
  366. CTraceNdbRecAttr* CTraceNdbOperation::getValue(const char* anAttrName)
  367. {
  368.   NdbRecAttr* pNdbRecAttr = NdbOperation::getValue(anAttrName);
  369.   TraceBegin();
  370.   TraceNdbOperation(this);
  371.   TraceMethod("getValue");
  372.   TraceString(anAttrName);
  373.   TraceReturn();
  374.   TraceNdbRecAttr(pNdbRecAttr);
  375.   TraceEnd();
  376.   return (CTraceNdbRecAttr*)pNdbRecAttr;
  377. }
  380. // TraceNdbIndexOperation
  382. int CTraceNdbIndexOperation::equal(const char* anAttrName, Uint32 aValue)
  383. {
  384.   int i = NdbIndexOperation::equal(anAttrName, aValue);
  385.   TraceBegin();
  386.   TraceNdbIndexOperation(this);
  387.   TraceMethod("equal");
  388.   TraceString(anAttrName);
  389.   TraceUint32(aValue);
  390.   TraceReturn();
  391.   TraceInt(i);
  392.   TraceEnd();
  393.   return i;
  394. }
  397. int CTraceNdbIndexOperation::incValue(const char* anAttrName, Uint32 aValue)
  398. {
  399.   int i = NdbIndexOperation::incValue(anAttrName, aValue);
  400.   TraceBegin();
  401.   TraceNdbIndexOperation(this);
  402.   TraceMethod("incValue");
  403.   TraceString(anAttrName);
  404.   TraceUint32(aValue);
  405.   TraceReturn();
  406.   TraceInt(i);
  407.   TraceEnd();
  408.   return i;
  409. }
  412. CTraceNdbRecAttr* CTraceNdbIndexOperation::getValue(const char* anAttrName)
  413. {
  414.   NdbRecAttr* pNdbRecAttr = NdbIndexOperation::getValue(anAttrName);
  415.   TraceBegin();
  416.   TraceNdbIndexOperation(this);
  417.   TraceMethod("getValue");
  418.   TraceString(anAttrName);
  419.   TraceReturn();
  420.   TraceNdbRecAttr(pNdbRecAttr);
  421.   TraceEnd();
  422.   return (CTraceNdbRecAttr*)pNdbRecAttr;
  423. }
  426. // TraceNdbConnection
  428. CTraceNdbOperation* CTraceNdbConnection::getNdbOperation(const char* aTableName)
  429. {
  430.   NdbOperation* pNdbOperation = NdbConnection::getNdbOperation(aTableName);
  431.   TraceBegin();
  432.   TraceNdbConnection(this);
  433.   TraceMethod("getNdbOperation");
  434.   TraceString(aTableName);
  435.   TraceReturn();
  436.   TraceNdbOperation(pNdbOperation);
  437.   TraceEnd();
  438.   return (CTraceNdbOperation*)pNdbOperation; 
  439. }
  441. CTraceNdbIndexOperation* CTraceNdbConnection::getNdbIndexOperation(const char* anIndexName, const char* aTableName)
  442. {
  443.   NdbIndexOperation* pNdbIndexOperation = NdbConnection::getNdbIndexOperation(anIndexName, aTableName);
  444.   TraceBegin();
  445.   TraceNdbConnection(this);
  446.   TraceMethod("getNdbIndexOperation");
  447.   TraceString(anIndexName);
  448.   TraceString(aTableName);
  449.   TraceReturn();
  450.   TraceNdbIndexOperation(pNdbIndexOperation);
  451.   TraceEnd();
  452.   return (CTraceNdbIndexOperation*)pNdbIndexOperation; 
  453. }
  455. int CTraceNdbConnection::execute(ExecType aTypeOfExec)
  456. {
  457.   int i = NdbConnection::execute(aTypeOfExec);
  458.   TraceBegin();
  459.   TraceNdbConnection(this);
  460.   TraceMethod("execute");
  461.   TraceExecType(aTypeOfExec);
  462.   TraceReturn();
  463.   TraceInt(i);
  464.   TraceEnd();
  465.   return i;
  466. }
  468. const NdbError & CTraceNdbConnection::getNdbError(void) const
  469. {
  470.   const NdbError& err = NdbConnection::getNdbError();
  471.   TraceBegin();
  472.   TraceNdbConnection(this);
  473.   TraceMethod("getNdbError");
  474.   TraceReturn();
  475.   TraceNdbError(err);
  476.   TraceEnd();
  477.   return err;
  478. }
  482. // TraceNdb
  484. CTraceNdb::CTraceNdb(const char* aDataBase)
  485. : Ndb(aDataBase) 
  486. {
  487.   TraceBegin();
  488.   TraceNdb(this);
  489.   TraceMethod("Ndb");
  490.   TraceString(aDataBase);
  491.   TraceReturn();
  492.   TraceVoid();
  493.   TraceEnd();
  494. }
  496. CTraceNdbSchemaCon* CTraceNdb::startSchemaTransaction() 
  497. { 
  498.   NdbSchemaCon* pNdbSchemaCon = Ndb::startSchemaTransaction();
  499.   TraceBegin();
  500.   TraceNdb(this);
  501.   TraceMethod("startSchemaTransaction");
  502.   TraceReturn();
  503.   TraceNdbSchemaCon(pNdbSchemaCon);
  504.   TraceEnd();
  505.   return (CTraceNdbSchemaCon*)pNdbSchemaCon;
  506. }
  508. void CTraceNdb::closeSchemaTransaction(CTraceNdbSchemaCon* aSchemaCon)
  509. {
  510.   Ndb::closeSchemaTransaction(aSchemaCon);
  511.   TraceBegin();
  512.   TraceNdb(this);
  513.   TraceMethod("closeSchemaTransaction");
  514.   TraceReturn();
  515.   TraceVoid();
  516.   TraceEnd();
  517. }
  519. CTraceNdbConnection* CTraceNdb::startTransaction()
  520. { 
  521.   NdbConnection* pNdbConnection = Ndb::startTransaction();
  522.   TraceBegin();
  523.   TraceNdb(this);
  524.   TraceMethod("startTransaction");
  525.   TraceReturn();
  526.   TraceNdbConnection(pNdbConnection);
  527.   TraceEnd();
  528.   return (CTraceNdbConnection*)pNdbConnection;
  529. }
  531. void CTraceNdb::closeTransaction(CTraceNdbConnection* aConnection)
  532. {
  533.   Ndb::closeTransaction(aConnection);
  534.   TraceBegin();
  535.   TraceNdb(this);
  536.   TraceMethod("closeTransaction");
  537.   TraceNdbConnection(aConnection);
  538.   TraceReturn();
  539.   TraceVoid();
  540.   TraceEnd();
  541. }