Linux(Unix)下MySQL数据库访问接口程序MCI (MySQL Call Interface)

oceania

郑重声明：本MCI程序已经过严格的，长时间的反复测试和使用！
可支持对char,varchar,varchar2,int,float等类型数据进行各种select,update,insert操作
欢迎C++高手,MySQL来指点
本接口程序用C++完成，尤其适合server端使用，可通行于Linux/Unix/Windows平台
包括:mci.h mci.cpp 以及测试用例test.h test.cpp和一个makefile文件,可直接在RedHat上编译运行
本接口功能相信可满足大部分朋友的需要,你只需在你的程序里面包含这两个文件即可
(当然相应的makefile文件也需修改)
作者：欧昕 中国-成都 欢迎大家改进之，让其功能更加强大，我的联系QQ：30991118，欢迎骚扰...
[mci.h]:

1. 
   
2. #ifndef  _MCI_H_
   
3. #define  _MCI_H_
   
4. #include <iostream>
   
5. #include <pthread.h>
   
6. #include <time.h>
   
7. #include <stdlib.h>
   
8. #include <stdio.h>
   
9. #include <memory.h>
   
10. #include "/usr/local/mysql/include/mysql.h"
    
11. const unsigned int MAX_FIELD_LEN = 1024*1;
    
12. class MCIException
    
13. {
    
14. public:
    
15.      int         ErrNo;
    
16.      char        ErrInfo[256];
    
17.      MCIException(const char *errinfo,int errno);
    
18.         char *getErrInfo();
    
19.         int   getErrNo(){return ErrNo;};
    
20.         //自定义错误类型
    
21.         //1    不支持的字段类型
    
22.         //2    字段越界
    
23.         //3    字段不存在
    
24.         //MySQL内部错误类型
    
25.         //2002 Can't connect to local MySQL server through socket
    
26.         //2003 Can't connect to MySQL server
    
27.         //2013 Lost connection to MySQL server during query
    
28.         //1045 Access denied for user
    
29. };
    
30. 
    
31. class MCIDatabase
    
32. {
    
33.         public:
    
34.         char DBIP[20];   //数据库IP地址
    
35.         char User[10];         //用户名
    
36.         char Pwd[10];         //密码
    
37.         char DBName[20]; //数据库名
    
38.         MYSQL *mysql;
    
39.         public:
    
40.                 MCIDatabase();
    
41.                 MYSQL* getMySQL(){return mysql;};
    
42.                 void setLogin(const char* dbip,const char* usr, const char* pwd, const char* dbname) ;
    
43.                 int  connect();
    
44.                 void disConnect();
    
45. };
    
46. 
    
47. class MCIField
    
48. {
    
49.         public:
    
50.         friend class MCIQuery;
    
51.         MCIQuery*        pParentQuery;                //指向该Field所属于的Query
    
52.         char             FieldName[30];         //字段名称(目前支持30长度)
    
53.         char                       StrBuf[255];                //用于保存转换为字符串后的值
    
54.         unsigned char*         DataBuf;                        //预绑定缓冲区
    
55.         enum_field_types FieldType;                        //MySQL内部数据类型
    
56.         unsigned int         FieldLength;                //数据长度
    
57.         public:
    
58.                 MCIField();                                       
    
59.                 ~MCIField();
    
60.                 void setFieldName(const char* s);
    
61.                 void setFieldType(enum_field_types n);
    
62.                 void setFieldLength(unsigned int n);
    
63.                
    
64.                 char* getFieldName();
    
65.                 char* getStrBuf();
    
66.                 enum_field_types getFieldType();
    
67.                 unsigned int getFieldLength();
    
68.                
    
69.                 MCIQuery* getParentQuery();
    
70.                 void setParentQuery(MCIQuery* pQry);
    
71.         static void  trimLeft(char* str);
    
72.         static void  trimRight(char* str);
    
73.         static char* allTrim(char* str);
    
74.                 char*        asString();
    
75.                 int          asInteger();
    
76.                 float        asFloat();
    
77.                 char         asChar(int pos = 0);
    
78.                
    
79. };
    
80. 
    
81. class MCIQuery
    
82. {
    
83.         public:
    
84.         MCIDatabase* pDB;
    
85.         MYSQL_RES*   pRes;
    
86.        
    
87.         int          FieldNum;       //字段个数               
    
88.         MYSQL_FIELD* pFields;             //得到的字段信息         
    
89.     MCIField*    pMCIFieldList;  //在内部保存的所有字段信息
    
90.                                     
    
91.         MYSQL_ROW    Row;
    
92.         int          RowNum;
    
93.         char         SqlStr[1024*3];
    
94.         int              CurrRow;
    
95.        
    
96.         /*
    
97.         //检查超时用
    
98.         int         ThreadExist;
    
99.         int         ThreadMode;
    
100.         pthread_t    QryID;
     
101.         int  ErrNo;
     
102.         char ErrInfo[256];
     
103.         */
     
104.        
     
105.         public:
     
106.                 MCIQuery();
     
107.                 void setDB(MCIDatabase *dblink);
     
108.                 ~MCIQuery();
     
109.                 void  setSql(char* sqlstr);
     
110.             void  open();                   //执行select型SQL语句
     
111.             int   getFieldsDef();           //获得字段信息,并为字段分配取值的缓冲区
     
112.             int   getRecordCount();                        //返回查询到的符合条件的记录的条数
     
113.             int   next();                        //移动到下一个记录,同时获取字段值
     
114.             MCIField* field(int i);         //取相应字段值
     
115.             MCIField* fieldByName(const char* s);
     
116.             int   exec();                                //执行insert,update型SQL语句,返回被此语句影响的记录条数
     
117.             void  close();                                        //关闭一个Query,为下次执行做准备
     
118.            
     
119.             /*
     
120.             //检查超时用
     
121.             int runSql();
     
122.             static void* QryThread(void* arg);
     
123.             */
     
124. };
     
125. #endif
     
126. [color=Red][b][mci.cpp]:[/b][/color]
     
127. #include "mci.h"
     
128. 
     
129. MCIException::MCIException(const char *errinfo,int errno)
     
130. {
     
131.         memset(ErrInfo,0,sizeof(ErrInfo));
     
132.         strncpy(ErrInfo,errinfo,sizeof(ErrInfo)-1);
     
133.         ErrNo = errno;
     
134. }
     
135. 
     
136. char* MCIException::getErrInfo()
     
137. {
     
138.         return ErrInfo;
     
139. }
     
140. 
     
141. MCIDatabase::MCIDatabase()
     
142. {
     
143.         memset(DBName,0,sizeof(DBName));
     
144.         memset(User,0,sizeof(User));
     
145.         memset(Pwd,0,sizeof(Pwd));
     
146.         mysql = NULL;
     
147. }
     
148. 
     
149. //设置登陆信息
     
150. void MCIDatabase::setLogin(const char* dbip,const char* usr, const char* pwd,const char* dbname)
     
151. {
     
152.         memset(DBIP,0,sizeof(DBIP));
     
153.         strcpy(DBIP,dbip);
     
154.         memset(User,0,sizeof(User));
     
155.         strcpy(User,usr);
     
156.         memset(Pwd,0,sizeof(Pwd));
     
157.         strcpy(Pwd,pwd);
     
158.         memset(DBName,0,sizeof(DBName));
     
159.         strcpy(DBName,dbname);
     
160. }
     
161. 
     
162. //连接到数据库
     
163. int MCIDatabase::connect()
     
164. {
     
165.         mysql = NULL;
     
166.         mysql = mysql_init(NULL);
     
167.         if (mysql == NULL)
     
168.         {
     
169.                 char errinfo[256];
     
170.                 memset(errinfo,0,sizeof(errinfo));
     
171.                 sprintf(errinfo, "%s\n",mysql_error(mysql));
     
172.                 int errno = mysql_errno(mysql);
     
173.                 throw MCIException(errinfo,errno);
     
174.                 return 0;
     
175.         }
     
176.         unsigned int timeout = 3;
     
177.         mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT,(char *) &timeout);//超时
     
178.         //mysql_options(mysql, MYSQL_OPT_COMPRESS,NULL);//与服务器的通信采用压缩协议
     
179.         //建立连接
     
180.         //DBIP如果设为"localhost"或NULL,则表示使用socket连接本地主机
     
181.         //DBIP如果设为字符串或IP数字形式的主机名,则表示使用TCP/IP连接本地主机
     
182.         if(mysql_real_connect(mysql,DBIP,User,Pwd,DBName,0,NULL,CLIENT_INTERACTIVE) == NULL)
     
183.         {
     
184.                 char errinfo[256];
     
185.                 memset(errinfo,0,sizeof(errinfo));
     
186.                 sprintf(errinfo, "%s\n",mysql_error(mysql));
     
187.                 int errno = mysql_errno(mysql);
     
188.                 throw MCIException(errinfo,errno);
     
189.                 return 0;
     
190.         }
     
191.         return 1;
     
192. }
     
193. 
     
194. //关闭连接
     
195. void MCIDatabase::disConnect()
     
196. {
     
197.         if (mysql != NULL) mysql_close(mysql);
     
198. }
     
199. 
     
200. MCIField::MCIField()
     
201. {
     
202.         pParentQuery = NULL;
     
203.         memset(FieldName,0,sizeof(FieldName));
     
204.         memset(StrBuf,0,sizeof(StrBuf));
     
205.         DataBuf = NULL;
     
206.         FieldType = FIELD_TYPE_STRING;
     
207. }
     
208. 
     
209. MCIField::~MCIField()
     
210. {
     
211.         if (DataBuf != NULL)
     
212.         {
     
213.                 delete[] DataBuf;
     
214.                 DataBuf = NULL;
     
215.         }
     
216. }
     
217. 
     
218. MCIQuery* MCIField::getParentQuery()
     
219. {
     
220.         return pParentQuery;
     
221. }
     
222. 
     
223. void MCIField::setParentQuery(MCIQuery* pQry)
     
224. {
     
225.         pParentQuery = pQry;
     
226. }
     
227. 
     
228. char* MCIField::getFieldName()
     
229. {
     
230.         return FieldName;
     
231. }
     
232. 
     
233. char* MCIField::getStrBuf()
     
234. {
     
235.         return StrBuf;
     
236. }
     
237. 
     
238. enum_field_types MCIField::getFieldType()
     
239. {
     
240.         return FieldType;
     
241. }
     
242. 
     
243. unsigned int MCIField::getFieldLength()
     
244. {
     
245.         return FieldLength;
     
246. }
     
247.                
     
248. void MCIField::setFieldName(const char* s)
     
249. {
     
250.         memset(FieldName,0,sizeof(FieldName));
     
251.         strncpy(FieldName,s,sizeof(FieldName)-1);
     
252. }
     
253. 
     
254. void MCIField::setFieldType(enum_field_types n)
     
255. {
     
256.         FieldType = n;
     
257. }
     
258. 
     
259. void MCIField::setFieldLength(unsigned int n)
     
260. {
     
261.         FieldLength = n;
     
262. }
     
263.                
     
264. MCIQuery::MCIQuery()
     
265. {
     
266.         pDB = NULL;
     
267.         pRes = NULL;
     
268.         FieldNum = 0;
     
269.         pFields = NULL;             
     
270.     pMCIFieldList = NULL;
     
271.         RowNum = 0;
     
272.         memset(SqlStr,0,sizeof(SqlStr));
     
273.         CurrRow = 0;
     
274.        
     
275.         /*
     
276.         //检查超时用
     
277.         ThreadExist = 0;
     
278.         ThreadMode = 0;
     
279.         QryID = 0;
     
280.         ErrNo = 0;
     
281.         memset(ErrInfo,0,sizeof(ErrInfo));
     
282.         */
     
283. }
     
284. 
     
285. //确定Qry指向的DataBase
     
286. void MCIQuery::setDB(MCIDatabase *dblink)
     
287. {
     
288.         pDB = dblink;
     
289. }
     
290. 
     
291. MCIQuery::~MCIQuery()
     
292. {
     
293.         if(pRes != NULL)
     
294.         {
     
295.                 mysql_free_result(pRes);
     
296.                 pRes = NULL;
     
297.                
     
298.         }
     
299.         if(pMCIFieldList != NULL)
     
300.         {
     
301.                 delete[] pMCIFieldList;
     
302.                 pMCIFieldList = NULL;
     
303.         }
     
304.         pFields = NULL;
     
305. }
     
306. 
     
307. //设置SQL语句
     
308. void MCIQuery::setSql(char* sqlstr)
     
309. {
     
310.         memset(SqlStr,0,sizeof(SqlStr));
     
311.         strcpy(SqlStr,sqlstr);
     
312. }
     
313. 
     
314. int MCIQuery::getRecordCount()
     
315. {
     
316.         return RowNum;
     
317. }
     
318. 
     
319. //获得字段信息,并为字段分配取值的缓冲区
     
320. int MCIQuery::getFieldsDef()
     
321. {
     
322.         pRes = mysql_store_result(pDB->getMySQL()); //获取结果集
     
323.         pFields =  mysql_fetch_fields(pRes);                 //获取MySQL字段信息
     
324.         FieldNum = mysql_num_fields(pRes);               //字段个数
     
325.         if (FieldNum > 0)
     
326.         {
     
327.                 pMCIFieldList = new MCIField[FieldNum];//建立自己的字段信息
     
328.                 MCIField *pCurrField = NULL;
     
329.                 for(int i = 0; i < FieldNum; i ++)
     
330.                 {
     
331.                         pCurrField = &pMCIFieldList[i];
     
332.                         //设置此字段名称-类型-字段宽度
     
333.                         pCurrField->setParentQuery(this);
     
334.                         pCurrField->setFieldName(pFields[i].name);
     
335.                         pCurrField->setFieldType(pFields[i].type);
     
336.                         pCurrField->setFieldLength(pFields[i].length);
     
337.                         if (pCurrField->getFieldLength() > MAX_FIELD_LEN)
     
338.                       {
     
339.                               //fprintf(stdout,"field:[%s]'s Length:[%d] More Than 1024\n",pCurrField->FieldName,pCurrField->FieldLength);fflush(stdout);
     
340.                               pCurrField->setFieldLength(MAX_FIELD_LEN);
     
341.                       }
     
342.                       //建立供输出数据的缓冲区
     
343.                 switch (pCurrField->getFieldType())
     
344.                 {
     
345.                                 case FIELD_TYPE_SET:
     
346.                                         throw MCIException("Not Supported Data Type:[FIELD_TYPE_SET]",1);
     
347.                                         break;
     
348.                                 case FIELD_TYPE_ENUM:
     
349.                                         throw MCIException("Not Supported Data Type:[FIELD_TYPE_ENUM]",1);
     
350.                                         break;
     
351.                                 case FIELD_TYPE_NULL:
     
352.                                         throw MCIException("Not Supported Data Type:[FIELD_TYPE_NULL]",1);
     
353.                                         break;
     
354.                                 default:
     
355.                                         pCurrField->DataBuf = new unsigned char[pCurrField->getFieldLength() + 1];
     
356.                                         memset(pCurrField->DataBuf,0,sizeof(pCurrField->DataBuf));
     
357.                         }
     
358.                 }
     
359.                 return 1;
     
360.         }
     
361.         return 0;
     
362. }
     
363. 
     
364. //移动到下一个记录,同时获取字段值
     
365. int MCIQuery::next()
     
366. {
     
367.         if (RowNum <= 0) return 0;
     
368.         if (CurrRow > RowNum) return 0;
     
369.         //将当前行的各个列的值写入MCIField中
     
370.         Row = mysql_fetch_row(pRes);
     
371.         if (Row == NULL) return 0;
     
372.         for(int i = 0; i < FieldNum; i ++)
     
373.         {
     
374.                 if( (Row[i] == NULL) || (pMCIFieldList[i].DataBuf == NULL) ) continue;
     
375.                 memcpy(pMCIFieldList[i].DataBuf,Row[i],pMCIFieldList[i].getFieldLength());
     
376.         }
     
377.         CurrRow++;
     
378.         return 1;
     
379. }
     
380. 
     
381. MCIField* MCIQuery::field(int i)
     
382. {
     
383.         if ( (i>=0) && (i<FieldNum) )
     
384.                 return &pMCIFieldList[i];
     
385.         else
     
386.         {
     
387.                 char errinfo[256];
     
388.                 memset(errinfo,0,sizeof(errinfo));
     
389.                 sprintf(errinfo, "Field:[%d] Out Of Bound",i);
     
390.                 int errno = 2;
     
391.                 throw MCIException(errinfo,errno);
     
392.         }
     
393. }
     
394. 
     
395. MCIField* MCIQuery::fieldByName(const char* s)
     
396. {
     
397.         for(int i = 0;i < FieldNum;i++)
     
398.         {
     
399.                 if (strcmp(pMCIFieldList[i].getFieldName(),s) == 0)
     
400.                         return &pMCIFieldList[i];
     
401.         }
     
402.         char errinfo[256];
     
403.         memset(errinfo,0,sizeof(errinfo));
     
404.         sprintf(errinfo, "Field:[%s] Not Find",s);
     
405.         int errno = 3;
     
406.         throw MCIException(errinfo,errno);
     
407. }
     
408. 
     
409. char* MCIField::allTrim(char *szString)
     
410. {
     
411.         trimLeft(szString);
     
412.         trimRight(szString);
     
413.         return szString;
     
414. }
     
415. 
     
416. void MCIField::trimLeft(char *str)
     
417. {
     
418.         int iStart=0;
     
419.         int iLen, iCount;
     
420. 
     
421.         iLen=strlen(str);
     
422.         while( (str[iStart] == ' ') || (str[iStart] == '\t') ) iStart++;
     
423.         for(iCount=iStart; iCount<=iLen; iCount++)
     
424.         {
     
425.                 str[iCount-iStart]=str[iCount];
     
426.         }
     
427. }
     
428. 
     
429. void MCIField::trimRight(char *str)
     
430. {
     
431.         int len=strlen(str);
     
432.         while(1)
     
433.         {
     
434.                 if (len<=0) break;
     
435.                 if( (str[len-1]==' ') || (str[len-1]=='\t') )
     
436.                 {
     
437.             str[len-1]=0;
     
438.             len--;
     
439.         }
     
440.                 else
     
441.                     break;
     
442.         }
     
443. }
     
444. 
     
445. char* MCIField::asString()
     
446. {
     
447.         static  char  nullstr[] = "";
     
448.         char* p = (char *)DataBuf;
     
449.         if ( (p == NULL) || (strlen(p) == 0) )
     
450.         {
     
451.                 return nullstr;
     
452.         }
     
453.         else
     
454.                 return allTrim(p);
     
455. }
     
456. int MCIField::asInteger()
     
457. {
     
458.         return(atoi((char *)DataBuf));
     
459. }
     
460. float MCIField::asFloat()
     
461. {
     
462.         return(atof((char *)DataBuf));
     
463. }
     
464. 
     
465. char MCIField::asChar(int pos)
     
466. {
     
467.         return DataBuf[pos];
     
468. }
     
469. 
     
470. 
     
471. void MCIQuery::close()
     
472. {
     
473.         memset(SqlStr,0,sizeof(SqlStr));
     
474.         if( (RowNum >0) && (pRes != NULL) )
     
475.         {
     
476.                 mysql_free_result(pRes);
     
477.                 pRes = NULL;
     
478.         }
     
479.         if (FieldNum >0)
     
480.         {
     
481.                 for(int i = 0; i < FieldNum; i ++)
     
482.                 {
     
483.                         MCIField *pCurrField = &pMCIFieldList[i];
     
484.                         delete[] pCurrField->DataBuf;
     
485.                         pCurrField->DataBuf = NULL;
     
486.                 }
     
487.         }
     
488.         if (pMCIFieldList != NULL)
     
489.         {
     
490.                 delete[] pMCIFieldList;
     
491.                 pMCIFieldList = NULL;
     
492.         }
     
493.         if (pFields != NULL)
     
494.         {
     
495.                 //delete pFields;
     
496.                 pFields = NULL;
     
497.         }
     
498.         FieldNum = 0;
     
499.         RowNum = 0;
     
500.         CurrRow = 0;
     
501. }
     
502. 
     
503. //执行需要返回结果集的SQL语句
     
504. void MCIQuery::open()
     
505. {
     
506.         if (pDB->getMySQL() == NULL) return;
     
507.         /*
     
508.         //fprintf(stdout,"mysql_ping\n");fflush(stdout);
     
509.         if (mysql_ping(pDB->getMySQL()) != 0)
     
510.         {
     
511.                 //fprintf(stdout,"mysql_ping failure\n");fflush(stdout);
     
512.                 int ErrNo = mysql_errno(pDB->getMySQL());
     
513.                 char ErrInfo[256];
     
514.                 memset(ErrInfo,0,sizeof(ErrInfo));
     
515.                 sprintf(ErrInfo, "%s\n",mysql_error(pDB->getMySQL()));
     
516.                 throw MCIException(ErrInfo,ErrNo);
     
517.         }
     
518.         */
     
519.         if (mysql_real_query(pDB->getMySQL(),SqlStr, strlen(SqlStr)) != 0)
     
520.         {
     
521.                 int ErrNo = mysql_errno(pDB->getMySQL());
     
522.                 char ErrInfo[256];
     
523.                 memset(ErrInfo,0,sizeof(ErrInfo));
     
524.                 sprintf(ErrInfo, "%s\n",mysql_error(pDB->getMySQL()));
     
525.                 throw MCIException(ErrInfo,ErrNo);
     
526.         }
     
527. 
     
528.         if (getFieldsDef() == 1)
     
529.         {
     
530.                 RowNum = mysql_num_rows(pRes);
     
531.                 CurrRow = 0;
     
532.         }
     
533. }
     
534. 
     
535. 
     
536. int MCIQuery::exec()
     
537. {
     
538.         if (pDB->getMySQL() == NULL) return 0;
     
539.         /*
     
540.         //fprintf(stdout,"mysql_ping\n");fflush(stdout);
     
541.         if (mysql_ping(pDB->getMySQL()) != 0)
     
542.         {
     
543.                 //fprintf(stdout,"mysql_ping failure\n");fflush(stdout);
     
544.                 int ErrNo = mysql_errno(pDB->getMySQL());
     
545.                 char ErrInfo[256];
     
546.                 memset(ErrInfo,0,sizeof(ErrInfo));
     
547.                 sprintf(ErrInfo, "%s\n",mysql_error(pDB->getMySQL()));
     
548.                 throw MCIException(ErrInfo,ErrNo);
     
549.         }
     
550.         */
     
551.         //fprintf(stdout,"mysql_real_query\n");fflush(stdout);
     
552.         if (mysql_real_query(pDB->getMySQL(),SqlStr, strlen(SqlStr)) != 0)
     
553.         {
     
554.                 //fprintf(stdout,"mysql_real_query failure\n");fflush(stdout);
     
555.                 int ErrNo = mysql_errno(pDB->getMySQL());
     
556.                 char ErrInfo[256];
     
557.                 memset(ErrInfo,0,sizeof(ErrInfo));
     
558.                 sprintf(ErrInfo, "%s\n",mysql_error(pDB->getMySQL()));
     
559.                 throw MCIException(ErrInfo,ErrNo);
     
560.         }
     
561.         //fprintf(stdout,"mysql_real_query success\n");fflush(stdout);
     
562.         return mysql_affected_rows(pDB->getMySQL());
     
563. }
     
564. [color=Red][b][test.h][/b][/color]//呵呵,test.h其实什么东西都没有，只是一个架子
     
565. #ifndef  _TEST_H_
     
566. #define  _TEST_H_
     
567. #include "mci.h"
     
568. #endif
     
569. [color=Red][b][test.cpp][/b][/color]
     
570. #include "test.h"
     
571. 
     
572. MCIDatabase   MCIDB;
     
573. 
     
574. int main(int argc,char* argv[])
     
575. {
     
576.         char SqlStr[256];
     
577.         try                                
     
578.         {               
     
579.                 //连接数据库                  
     
580.                 MCIDB.disConnect();            
     
581.                 MCIDB.setLogin("192.168.0.111", "sa", "abc","atcdb");
     
582.                 MCIDB.connect();
     
583.                 fprintf(stdout,"connect db success\n");fflush(stdout);
     
584.                 //创建一个Query
     
585.                 MCIQuery* q = new MCIQuery();
     
586.                 q->setDB(&MCIDB);               
     
587.                 //执行select语句
     
588.                 memset(SqlStr,0,sizeof(SqlStr));
     
589.                 strcpy(SqlStr,"select * from table1");//假设有表table1
     
590.                 q->close();
     
591.                 q->setSql(SqlStr);
     
592.                 q->open();
     
593.                 while(q->next())
     
594.                 {
     
595.                         fprintf(stdout,"%s\n",q->fieldByName("field1")->asString());fflush(stdout);//假设该表有varchar2型字段field1
     
596.                 }
     
597.                 //执行update或insert语句
     
598.                 q->close();
     
599.                 sprintf(sql, "delete from table1");
     
600.                 q->setSql(sql);
     
601.                 q->exec();
     
602.                 q->close();
     
603.                 //释放内存
     
604.                 delete q;
     
605.                 MCIDB.disConnect();
     
606.         }
     
607.         catch(MCIException &oe)            
     
608.         {                  
     
609.                 fprintf(stdout,"%s\n",oe.getErrInfo());
     
610.                 MCIDB.disConnect();
     
611.                 delete q;
     
612.         }
     
613. }
     

复制代码

[makefile]
CC                         = g++
CFLAGS                 = -Wall
SQLHOME         = -L/usr/lib64 -lmysqlclient

all:test
test: mci.o test.o
        $(CC) -s -o test -m64 *.o  $(SQLHOME)

mci.o: mci.cpp mci.h
        $(CC) $(CFLAGS) -c mci.cpp
test.o: test.cpp test.h
        $(CC) $(CFLAGS) -c test.cpp

clean::
         rm -f *.o

[ 本帖最后由 oceania 于 2006-9-3 22:19 编辑 ]

Bayweb

原帖由 oceania 于 2006-8-31 22:10 发表
郑重声明：本MCI程序已经过严格的，长时间的反复测试和使用！
可支持对char,varchar,varchar2,int,float等类型数据进行各种select,update,insert操作
欢迎C++高手,MySQL来指点
本接 ...

>>
>>
>>赞一个！
>>
>>

zhongfangqing

顶下

qzc

好文章该置顶

duanjigang

鼓励！提个建议，实现接口的时候，一定要反复斟酌，抽象出最普遍和常用的一些函数，比如connect, ExecuteSQL(char*)，getRows等

zkbucciarati

强烈感谢！！！