SQLAllocHandleTest_bf.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include sqlcli.h;
  14. #include stdio.h;
  15. #define SQL_MAX_MESSAGE_LENGTH 200;
  16. SQLHDBC     hdbc;
  17. SQLHSTMT    hstmt;
  18. SQLHENV     henv;
  19. SQLHDESC    hdesc;
  20. SQLRETURN   retcode, SQLSTATEs;
  21. SQLCHAR       SqlState[6], SQLStmt[100], Msg[SQL_MAX_MESSAGE_LENGTH];
  22. SQLINTEGER    NativeError;
  23. SQLSMALLINT   i, MsgLen;
  24. struct handle_set
  25. {
  26. SQLHDBC     hdbc_varible;
  27. SQLHSTMT    hstmt_varible;
  28. SQLHENV     henv_varible;
  29. SQLHDESC    hdesc_varible;
  30. INTEGER     strangehandle;
  31. }
  32. static int
  33. check(
  34.     SQLSMALLINT HandleType,
  35.     SQLHANDLE inputhandle,
  36.     SQLHANDLE *outputhandle,
  37.     SQLRETURN wantret,
  38.     char *wantSqlstate)
  39. {
  40.     SQLRETURN ret;
  41.     SQLCHAR Sqlstate[20];
  42.     ret = SQLAllocHandle(handletype, inputhandle, outputhandle);
  43.     if (ret != wantret) {
  44. // report error
  45. return -1;
  46.     }
  47.     if (ret == SQL_INVALID_HANDLE) {
  48. // cannot get diag
  49. return 0;
  50.     }
  51.     // TODO
  52.     ret = SQLGetDiagRec(HandleType, InputHandle, 1, Sqlstate, &NativeError, Msg, sizeof(Msg), &MsgLen);
  53.     if (strcmp(Sqlstate, wantSqlstate) != 0) {
  54. // report error;
  55. return -1;
  56.     }
  57.     return 0;
  58. }
  59. int
  60. Test_SQLAllocHandle()
  61. {
  62.     SQLRETURN ret;
  63.     SQLHENV henv;
  64.     SQLDBC dbc;
  65.     int i;
  66.     // env
  67.     check(SQL_HANDLE_ENV, SQL_NULL_HANDLE, 0, SQL_ERROR, "HY009");
  68.     for (i = 0; i < 1000; i++) {
  69. if (i != SQL_NULL_HANDLE)
  70.     check(SQL_HANDLE_ENV, i, &henv, SQL_INVALID_HANDLE, 0);
  71.     }
  72.     if (check(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv, SQL_SUCCESS, "00000") < 0)
  73. return -1;
  74.     // dbc
  75.     check(SQL_HANDLE_DBC, henv, 0, SQL_ERROR, "HY009");
  76.     for (i = 0; i < 1000; i++) {
  77. if (i != henv)
  78.     check(SQL_HANDLE_DBC, i, &dbc, SQL_INVALID_HANDLE, 0);
  79.     }
  80.     if (check(SQL_HANDLE_DBC, henv, &dbc, SQL_SUCCESS, "00000") < 0)
  81. return -1;
  82.     //??
  83.     check(SQL_HANDLE_ENV, dbc, 0, SQL_ERROR, "HY092");
  84.     // TODO
  85.     // stmt
  86.     return 0;
  87. }
  88. handle_set handlevalue;
  89.  
  90. handlevalue.hdbc_varible = hdbc;
  91. handlevalue.hstmt_varible = hstmt;
  92. handlevalue.henv_varible = henv;
  93. handlevalue.hdesc_varible = hdesc;
  94. handlevalue.stranghandle = 67;
  95.       /*Allocate environment handle */
  96. //retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
  97. while (int j = 0; j++; j < 6) {
  98.    if ( j = 0 ) 
  99.       handle_deal_with(SQL_HANDLE_ENV, SQL_NULL_HANDLE, );
  100.           
  101.    else if ( j = 1 ) 
  102.       handle_deal_with(SQL_HANDLE_ENV, handlevalue.henv_varible, );
  103.                            
  104.    else if ( j = 2 ) 
  105.      handle_deal_with(SQL_HANDLE_ENV, handlevalue.hdbc_varible,  );
  106.    else if ( j = 3 ) 
  107.      handle_deal_with(SQL_HANDLE_ENV, handlevalue.hstmt_varible,  );
  108.            
  109.    else if ( j = 4 )  
  110.      handle_deal_with(SQL_HANDLE_ENV, handlevalue.hdesc_varible,  );
  111.      
  112.   else 
  113.      handle_deal_with(SQL_HANDLE_ENV, handlevalue.stranghandle,  );
  114.         
  115.                               }
  116.                            
  117.  while (int j = 0; j++; j < 6) {
  118.    if ( j = 0 ) 
  119.       handle_deal_with(SQL_HANDLE_DBC, SQL_NULL_HANDLE,  );
  120.           
  121.    else if ( j = 1 ) 
  122.       handle_deal_with(SQL_HANDLE_DBC, handlevalue.henv_varible,  );
  123.                            
  124.    else if ( j = 2 ) 
  125.       handle_deal_with(SQL_HANDLE_DBC, handlevalue.hdbc_varible,  );
  126.    else if ( j = 3 ) 
  127.       handle_deal_with(SQL_HANDLE_DBC, handlevalue.hstmt_varible,  );
  128.            
  129.    else if ( j = 4 )  
  130.       handle_deal_with(SQL_HANDLE_DBC, handlevalue.hdesc_varible,  );
  131.      
  132.   else 
  133.       handle_deal_with(SQL_HANDLE_DBC, handlevalue.stranghandle,  );
  134.          
  135.                               }
  136.  
  137.  while (int j = 0; j++; j < 6) {
  138.    if ( j = 0 ) 
  139.       handle_deal_with(SQL_HANDLE_STMT, SQL_NULL_HANDLE,  );
  140.           
  141.    else if ( j = 1 ) 
  142.       handle_deal_with(SQL_HANDLE_STMT, handlevalue.henv_varible,  );
  143.                            
  144.    else if ( j = 2 ) 
  145.       handle_deal_with(SQL_HANDLE_STMT, handlevalue.hdbc_varible,  );
  146.    else if ( j = 3 ) 
  147.       handle_deal_with(SQL_HANDLE_STMT, handlevalue.hstmt_varible,  );
  148.            
  149.    else if ( j = 4 )  
  150.       handle_deal_with(SQL_HANDLE_STMT, handlevalue.hdesc_varible,  );
  151.      
  152.   else 
  153.       handle_deal_with(SQL_HANDLE_STMT, handlevalue.stranghandle,  );
  154.         
  155.                               }
  156.   while (int j = 0; j++; j < 6) {
  157.    if ( j = 0 ) 
  158.       handle_deal_with(SQL_HANDLE_DESC, SQL_NULL_HANDLE,  );
  159.           
  160.    else if ( j = 1 ) 
  161.       handle_deal_with(SQL_HANDLE_DESC, handlevalue.henv_varible,  );
  162.                            
  163.    else if ( j = 2 ) 
  164.       handle_deal_with(SQL_HANDLE_DESC, handlevalue.hdbc_varible,  );
  165.    else if ( j = 3 ) 
  166.       handle_deal_with(SQL_HANDLE_DESC, handlevalue.hstmt_varible,  );
  167.            
  168.    else if ( j = 4 )  
  169.       handle_deal_with(SQL_HANDLE_DESC, handlevalue.hdesc_varible,  );
  170.      
  171.   else 
  172.       handle_deal_with(SQL_HANDLE_DESC, handlevalue.stranghandle,  );
  173.         
  174.                               }
  175.   while (int j = 0; j++; j < 6) {
  176.    if ( j = 0 ) 
  177.       handle_deal_with(handlevalue.stranghandle, SQL_NULL_HANDLE,  );
  178.           
  179.    else if ( j = 1 ) 
  180.       handle_deal_with(handlevalue.stranghandle, handlevalue.henv_varible,  );
  181.                            
  182.    else if ( j = 2 ) 
  183.       handle_deal_with(handlevalue.stranghandle, handlevalue.hdbc_varible,  );
  184.    else if ( j = 3 ) 
  185.       handle_deal_with(handlevalue.stranghandle, handlevalue.hstmt_varible,  );
  186.            
  187.    else if ( j = 4 )  
  188.       handle_deal_with(handlevalue.stranghandle  handlevalue.hdesc_varible,  );
  189.      
  190.   else 
  191.       handle_deal_with(handlevalue.stranghandle, handlevalue.stranghandle,  );
  192.         
  193.                               }
  194.    
  195. }
  196. void DisplayError(SQLCHAR SqlState[6], string SQLSTATE, string flag, SQLSMALLINT HandleType, SQLHANDLE InputHandle)
  197. {
  198. cout << "the operation is: " << flag << endl;
  199. cout << "the HandleType is:" << HandleType << endl;
  200. cout << "the InputHandle is :"<< InputHandle <<endl;
  201. cout << "the correct state is:" << SQLSTATE << endl;
  202. cout << "the output state is:" << Sqlstate << endl;
  203. }
  204. }
  205. void handle_deal_with(SQLSMALLINT HandleType, SQLHANDLE InputHandle, string SQLSTATE) 
  206. {
  207.      retcode = SQLAllocHandle(HandleType, InputHandle, OutputHandlePtr);
  208.      if (retcode == SQL_ERROR || retcode == SQL_SUCCESS_WITH_INFO) {
  209.      i = 1;
  210.      while ((SQLSTATEs = SQLGetDiagRec(HandleType, InputHandle, i, 
  211.              Sqlstate, &NativeError, Msg, sizeof(Msg), 
  212.              &MsgLen)) != SQL_NO_DATE)                   {
  213.   
  214.      if (SQLSTATE = Sqlstate )
  215.      DisplayError(SqlState, SQLSTATE, 'OK');
  216.   
  217.      else
  218.      DisplayError(SqlState, SQLSTATE, 'failure');
  219.   
  220.      i ++;
  221.                                                          }
  222.                                                                    }
  223.  }