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

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

MySQL数据库

开发平台：

Visual C++

Ctx.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 <common/common.hpp>
  19. #include "DiagArea.hpp"
  21. // ctor
  23. Ctx::Ctx() :
  24.     m_diagArea(0) // create on demand
  25. {
  26.     const char* p;
  27.     if ((p = getenv("NDB_ODBC_TRACE")) != 0)
  28. m_logLevel = atoi(p);
  29.     if ((p = getenv("NDB_ODBC_TRACE_FILE")) != 0 && *p != 0)
  30. strcpy(m_szTraceFile, p);
  31. }
  33. Ctx::~Ctx()
  34. {
  35.     delete m_diagArea;
  36.     m_diagArea = 0;
  37. }
  39. // handle exceptions
  41. CtxAssert::CtxAssert(const char* file, int line) :
  42.     m_file(file),
  43.     m_line(line)
  44. {
  45.     const char* p;
  46.     if ((p = getenv("NDB_ODBC_DEBUG")) != 0 && atoi(p) != 0) {
  47. char buf[200];
  48. snprintf(buf, sizeof(buf), "%s, line %d: assert failedn", m_file, m_line);
  49. if ((p = getenv("NDB_ODBC_TRACE_FILE")) != 0 && *p != 0) {
  50.     FILE* pFile = fopen(p, "a");
  51.     fprintf(pFile, buf);
  52.     fflush(pFile);
  53.     fclose(pFile);
  54. } else {
  55.     fprintf(stderr, buf);
  56.     fflush(stderr);
  57. }
  58. abort();
  59. exit(1);
  60.     }
  61. }
  63. void
  64. Ctx::handleEx(CtxAssert& ctxAssert)
  65. {
  66.     pushStatus(Sqlstate::_IM001, Error::Gen, "exception at %s line %d", ctxAssert.m_file, ctxAssert.m_line);
  67. }
  69. // logging methods
  71. int Ctx::m_logLevel = 0;
  72. char Ctx::m_szTraceFile[MAX_PATH];
  74. void
  75. Ctx::log(const char* fmt, ...)
  76. {
  77.     va_list ap;
  78.     va_start(ap, fmt);
  79.     if (m_szTraceFile[0]) {
  80. FILE* pFile = fopen(m_szTraceFile, "a");
  81. fprintf(pFile, "[NdbOdbc] ");
  82. vfprintf(pFile, fmt, ap);
  83. fprintf(pFile, "n");
  84. fflush(pFile);
  85. fclose(pFile);
  86.     } else {
  87. printf("[NdbOdbc] ");
  88. vprintf(fmt, ap);
  89. printf("n");
  90. fflush(stdout);
  91.     }
  92.     va_end(ap);
  93. }
  95. void
  96. Ctx::logSqlEnter(const char* sqlFunction)
  97. {
  98.     Ctx& ctx = *this;
  99.     snprintf(m_sqlFunction, sizeof(m_sqlFunction), "%s", sqlFunction);
  100.     ctx_log3(("%s", m_sqlFunction));
  101. }
  103. void
  104. Ctx::logSqlExit()
  105. {
  106.     Ctx& ctx = *this;
  107.     if (m_diagArea == 0) {
  108. ctx_log3(("%s ret=%d", m_sqlFunction, getCode()));
  109. return;
  110.     }
  111.     int logLevel = diagArea().numStatus() != 0 ? 2 : 3;
  112.     ctx_logN(logLevel, ("%s ret=%d diag=%d", m_sqlFunction, diagArea().getCode(), diagArea().numStatus()));
  113.     for (unsigned i = 1; i <= diagArea().numStatus(); i++) {
  114. OdbcData state;
  115. OdbcData message;
  116. diagArea().getRecord(ctx, i, SQL_DIAG_SQLSTATE, state);
  117. diagArea().getRecord(ctx, i, SQL_DIAG_MESSAGE_TEXT, message);
  118. ctx_logN(logLevel, ("diag %u: %s - %s", i, state.sqlstate().state(), message.sqlchar()));
  119.     }
  120. }
  122. void
  123. Ctx::print(const char* fmt, ...)
  124. {
  125.     va_list ap;
  126.     va_start(ap, fmt);
  127.     if (m_szTraceFile[0]) {
  128. FILE* pFile = fopen(m_szTraceFile, "a");
  129. vfprintf(pFile, fmt, ap);
  130. unsigned n = strlen(fmt);
  131. if (n > 0 && fmt[n-1] == 'n')
  132.     fflush(pFile);
  133. fclose(pFile);
  134.     } else {
  135. vprintf(fmt, ap);
  136. unsigned n = strlen(fmt);
  137. if (n > 0 && fmt[n-1] == 'n')
  138.     fflush(stdout);
  139.     }
  140.     va_end(ap);
  141. }
  143. void
  144. Ctx::print(int level, const char* fmt, ...)
  145. {
  146.     if (level > m_logLevel)
  147. return;
  148.     va_list ap;
  149.     va_start(ap, fmt);
  150.     if (m_szTraceFile[0]) {
  151. FILE* pFile = fopen(m_szTraceFile, "a");
  152. vfprintf(pFile, fmt, ap);
  153. unsigned n = strlen(fmt);
  154. if (n > 0 && fmt[n-1] == 'n')
  155.     fflush(pFile);
  156. fclose(pFile);
  157.     } else {
  158. vprintf(fmt, ap);
  159. unsigned n = strlen(fmt);
  160. if (n > 0 && fmt[n-1] == 'n')
  161.     fflush(stdout);
  162.     }
  163.     va_end(ap);
  164. }
  166. // diagnostics
  168. static const unsigned MessageSize = 512;
  170. DiagArea&
  171. Ctx::diagArea() const
  172. {
  173.     ctx_assert(m_diagArea != 0);
  174.     return *m_diagArea;
  175. }
  177. DiagArea&
  178. Ctx::diagArea()
  179. {
  180.     if (m_diagArea == 0)
  181. m_diagArea = new DiagArea;
  182.     return *m_diagArea;
  183. }
  185. SQLRETURN
  186. Ctx::getCode() const
  187. {
  188.     if (m_diagArea == 0)
  189. return SQL_SUCCESS;
  190.     return diagArea().getCode();
  191. }
  193. void
  194. Ctx::setCode(SQLRETURN ret)
  195. {
  196.     diagArea().setCode(ret);
  197. }
  199. void
  200. Ctx::pushStatus(const Sqlstate& state, SQLINTEGER code, const char* fmt, ...)
  201. {
  202.     char message[MessageSize];
  203.     va_list ap;
  204.     va_start(ap, fmt);
  205.     vsnprintf(message, sizeof(message), fmt, ap);
  206.     va_end(ap);
  207.     Error error(state);
  208.     error.m_status = NdbError::PermanentError;
  209.     error.m_classification = NdbError::ApplicationError;
  210.     error.m_code = code;
  211.     error.m_message = message;
  212.     error.m_sqlFunction = m_sqlFunction;
  213.     diagArea().pushStatus(error);
  214. }
  216. void
  217. Ctx::pushStatus(SQLINTEGER code, const char* fmt, ...)
  218. {
  219.     char message[MessageSize];
  220.     va_list ap;
  221.     va_start(ap, fmt);
  222.     vsnprintf(message, sizeof(message), fmt, ap);
  223.     va_end(ap);
  224.     Error error(Sqlstate::_IM000);
  225.     error.m_status = NdbError::PermanentError;
  226.     error.m_classification = NdbError::ApplicationError;
  227.     error.m_code = code;
  228.     error.m_message = message;
  229.     error.m_sqlFunction = m_sqlFunction;
  230.     diagArea().pushStatus(error);
  231. }
  233. void
  234. Ctx::pushStatus(const NdbError& ndbError, const char* fmt, ...)
  235. {
  236.     char message[MessageSize];
  237.     va_list ap;
  238.     va_start(ap, fmt);
  239.     snprintf(message, sizeof(message), "%s", ndbError.message);
  240.     snprintf(message + strlen(message), sizeof(message) - strlen(message), "%s", " - at ");
  241.     vsnprintf(message + strlen(message), sizeof(message) - strlen(message), fmt, ap);
  242.     va_end(ap);
  243.     Error error(Sqlstate::_IM000);
  244.     error.m_status = ndbError.status;
  245.     error.m_classification = ndbError.classification;
  246.     error.m_code = ndbError.code;
  247.     error.m_message = message;
  248.     error.m_sqlFunction = m_sqlFunction;
  249.     diagArea().pushStatus(error);
  250. }
  252. void
  253. Ctx::pushStatus(const Ndb* ndb, const char* fmt, ...)
  254. {
  255.     char message[MessageSize];
  256.     va_list ap;
  257.     va_start(ap, fmt);
  258.     vsnprintf(message, sizeof(message), fmt, ap);
  259.     va_end(ap);
  260.     bool found = false;
  261.     if (ndb != 0) {
  262. const NdbError& ndbError = ndb->getNdbError();
  263. if (ndbError.code != 0) {
  264.     pushStatus(ndbError, "%s", message);
  265.     found = true;
  266. }
  267.     }
  268.     if (! found) {
  269. pushStatus(Error::Gen, "unknown NDB error");
  270.     }
  271. }
  273. void
  274. Ctx::pushStatus(const Ndb* ndb, const NdbConnection* tcon, const NdbOperation* op, const char* fmt, ...)
  275. {
  276.     char message[MessageSize];
  277.     va_list ap;
  278.     va_start(ap, fmt);
  279.     vsnprintf(message, sizeof(message), fmt, ap);
  280.     va_end(ap);
  281.     bool found = false;
  282.     if (op != 0) {
  283. const NdbError& ndbError = op->getNdbError();
  284. if (ndbError.code != 0) {
  285.     pushStatus(ndbError, "%s", message);
  286.     found = true;
  287. }
  288.     }
  289.     if (tcon != 0) {
  290. const NdbError& ndbError = tcon->getNdbError();
  291. if (ndbError.code != 0) {
  292.     pushStatus(ndbError, "%s", message);
  293.     found = true;
  294. }
  295.     }
  296.     if (ndb != 0) {
  297. const NdbError& ndbError = ndb->getNdbError();
  298. if (ndbError.code != 0) {
  299.     pushStatus(ndbError, "%s", message);
  300.     found = true;
  301. }
  302.     }
  303.     if (! found) {
  304. pushStatus(Error::Gen, "unknown NDB error");
  305.     }
  306. }
  308. void
  309. Ctx::pushStatus(const Ndb* ndb, const NdbSchemaCon* scon, const NdbSchemaOp* op, const char* fmt, ...)
  310. {
  311.     char message[MessageSize];
  312.     va_list ap;
  313.     va_start(ap, fmt);
  314.     vsnprintf(message, sizeof(message), fmt, ap);
  315.     va_end(ap);
  316.     bool found = false;
  317.     if (op != 0) {
  318. const NdbError& ndbError = op->getNdbError();
  319. if (ndbError.code != 0) {
  320.     pushStatus(ndbError, "%s", message);
  321.     found = true;
  322. }
  323.     }
  324.     if (scon != 0) {
  325. const NdbError& ndbError = scon->getNdbError();
  326. if (ndbError.code != 0) {
  327.     pushStatus(ndbError, "%s", message);
  328.     found = true;
  329. }
  330.     }
  331.     if (ndb != 0) {
  332. const NdbError& ndbError = ndb->getNdbError();
  333. if (ndbError.code != 0) {
  334.     pushStatus(ndbError, "%s", message);
  335.     found = true;
  336. }
  337.     }
  338.     if (! found) {
  339. pushStatus(Error::Gen, "unknown NDB error");
  340.     }
  341. }
  343. // check for error
  345. bool
  346. Ctx::ok()
  347. {
  348.     if (m_diagArea == 0)
  349. return true;
  350.     if (diagArea().getCode() == SQL_SUCCESS)
  351. return true;
  352.     if (diagArea().getCode() == SQL_SUCCESS_WITH_INFO)
  353. return true;
  354.     return false;
  355. }