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

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.  /**
  14.  * @file SQLprepareTest.cpp
  15.  */
  16. #include <common.hpp>
  17. #define pare_SQL_MAXIMUM_MESSAGE_LENGTH 200
  18. using namespace std;
  19. SQLHDBC     pare_hdbc;
  20. SQLHSTMT    pare_hstmt;
  21. SQLHENV     pare_henv;
  22. SQLHDESC    pare_hdesc;
  23. SQLRETURN   pare_retcode, pare_SQLSTATEs;
  24. SQLCHAR pare_Sqlstate[5];
  25. SQLINTEGER    pare_NativeError;
  26. SQLSMALLINT   pare_i, pare_MsgLen;
  27. SQLCHAR   pare_Msg[pare_SQL_MAXIMUM_MESSAGE_LENGTH];
  28.        
  29. void Prepare_DisplayError(SQLSMALLINT pare_HandleType, 
  30.   SQLHSTMT pare_InputHandle);
  31. /** 
  32.  * Test to prepare a statement with different handles
  33.  *
  34.  * -# Input correct hstmt handle
  35.  * -# Input incorrect henv handle
  36.  * -# Input incorrect hdbc handle
  37.  * -# Input incorrect handle hdesc
  38.  *
  39.  * @return Zero, if test succeeded
  40.  */
  41. int SQLPrepareTest()
  42. {
  43.   SQLCHAR SQLStmt [120];
  44.   ndbout << endl << "Start SQLPrepare Testing" << endl;
  45.   ndbout << endl << "Test 1" << endl;  
  46.   //*********************************
  47.   //** Test1                       **
  48.   //** Input correct hstmt handle  **
  49.   //*********************************
  50.   //************************************
  51.   //** Allocate An Environment Handle **
  52.   //************************************
  53.   pare_retcode = SQLAllocHandle(SQL_HANDLE_ENV, 
  54. SQL_NULL_HANDLE, 
  55. &pare_henv);
  56.   
  57.   if(pare_retcode == SQL_SUCCESS || pare_retcode == SQL_SUCCESS_WITH_INFO)
  58.     ndbout << "Allocated an environment Handle!" << endl;
  59.   
  60.   //*********************************************
  61.   //** Set the ODBC application Version to 3.x **
  62.   //*********************************************
  63.   pare_retcode = SQLSetEnvAttr(pare_henv, 
  64.        SQL_ATTR_ODBC_VERSION, 
  65.        (SQLPOINTER) SQL_OV_ODBC3, 
  66.        SQL_IS_UINTEGER);
  67.   
  68.   if (pare_retcode == SQL_SUCCESS || pare_retcode == SQL_SUCCESS_WITH_INFO)
  69.     ndbout << "Set the ODBC application Version to 3.x!" << endl;
  70.   //**********************************
  71.   //** Allocate A Connection Handle **
  72.   //**********************************
  73.   pare_retcode = SQLAllocHandle(SQL_HANDLE_DBC, pare_henv, &pare_hdbc);
  74.   if (pare_retcode == SQL_SUCCESS || pare_retcode == SQL_SUCCESS_WITH_INFO)
  75.     ndbout << "Allocated a connection Handle!" << endl;
  76.   
  77.   // *******************
  78.   // ** Connect to DB **
  79.   // *******************
  80.   pare_retcode = SQLConnect(pare_hdbc, 
  81.     (SQLCHAR *) connectString(), 
  82.     SQL_NTS, 
  83.     (SQLCHAR *) "", 
  84.     SQL_NTS, 
  85.     (SQLCHAR *) "", 
  86.     SQL_NTS);
  87.   
  88.   if (pare_retcode == SQL_SUCCESS || pare_retcode == SQL_SUCCESS_WITH_INFO)
  89.     ndbout << "Connected to DB : OK!" << endl;
  90.   else 
  91.     ndbout << "Failure to Connect DB!" << endl;
  92.   
  93.   //*******************************
  94.   //** Allocate statement handle **
  95.   //*******************************
  96.   pare_retcode = SQLAllocHandle(SQL_HANDLE_STMT, pare_hdbc, &pare_hstmt); 
  97.   if (pare_retcode == SQL_SUCCESS || pare_retcode == SQL_SUCCESS_WITH_INFO) 
  98.     ndbout << "Allocated a statement handle!" << endl;
  99.   
  100.   //************************
  101.   //** Define a statement **
  102.   //************************
  103.    strcpy( (char *) SQLStmt, "INSERT INTO Customers (CustID, Name, Address, Phone) VALUES(2, 'Hans  Peter', 'LM Vag8', '468719000')");
  104.   pare_retcode = SQLPrepare(pare_hstmt, 
  105.     SQLStmt, 
  106.     SQL_NTS);
  107.   
  108.   if (pare_retcode == SQL_INVALID_HANDLE)
  109.     {
  110.       ndbout << "pare_retcode = " << pare_retcode << endl;
  111.       ndbout << "HandleType is SQL_HANDLE_STMT, but SQL_INVALID_HANDLE" 
  112.      << endl;
  113.       ndbout << "appeared. Please check program!" << endl;
  114.     }
  115.   else if (pare_retcode == SQL_ERROR || pare_retcode == SQL_SUCCESS_WITH_INFO)
  116.     { 
  117.       Prepare_DisplayError(SQL_HANDLE_STMT, pare_hstmt);
  118.     } 
  119.   else 
  120.     { 
  121.       //***********************
  122.       //** Execute statement **
  123.       //***********************
  124.       pare_retcode = SQLExecute(pare_hstmt);
  125.       if (pare_retcode != SQL_SUCCESS) 
  126. {
  127.   ndbout << "pare_retcode = " << pare_retcode << endl;
  128.   Prepare_DisplayError(SQL_HANDLE_STMT, pare_hstmt);
  129. }
  130.       else
  131. ndbout << endl << "Test 1:Input correct HSTMT handle. OK!" << endl;
  132.     }
  133.   
  134.   //*********************************
  135.   //** Test2                       **
  136.   //** Input incorrect henv handle **
  137.   //*********************************
  138.   strcpy( (char *) SQLStmt, "INSERT INTO Customers (CustID, Name, Address, Phone) VALUES(3, 'Hans', 'LM8', '51888')");
  139.   pare_retcode = SQLPrepare(pare_henv, 
  140.     SQLStmt, 
  141.     SQL_NTS);
  142.   
  143.   ndbout << endl << "Test 2" << endl;
  144.   if (pare_retcode == SQL_SUCCESS_WITH_INFO || pare_retcode == SQL_SUCCESS)
  145.     { 
  146.       FAILURE("Wrong SQL_HANDLE_HENV, but success returned. Check it!");
  147.     }
  148.   else if (pare_retcode == SQL_INVALID_HANDLE) 
  149.    { 
  150.      ndbout << "Wrong SQL_HANDLE_HENV input and -2 appeared. OK!" << endl ;
  151.    }
  152.   else
  153.     ;
  154.   /*
  155.     {
  156.       ndbout << "Input wrong SQL_HANDLE_ENV, but SQL_SUCCESS_W_I" << endl;
  157.       ndbout << "and SQL_SUCCESS appeared. Please check program!" << endl;
  158.       return NDBT_FAILED;
  159.     }
  160.   */
  161.   //*********************************
  162.   //** Test3                       **
  163.   //** Input incorrect hdbc handle **
  164.   //*********************************
  165.   strcpy( (char *) SQLStmt, "INSERT INTO Customers (CustID, Name, Address, Phone) VALUES(4, 'HP', 'V腉8', '90888')");
  166.   pare_retcode = SQLPrepare(pare_hdbc, 
  167.     SQLStmt, 
  168.     SQL_NTS);
  169.   ndbout << endl << "Test 3" << endl;
  170.   if (pare_retcode == SQL_SUCCESS_WITH_INFO || pare_retcode == SQL_SUCCESS)
  171.     {
  172.       FAILURE("Wrong SQL_HANDLE_HDBC, but success returned. Check it!");
  173.     }
  174.   else if (pare_retcode == SQL_INVALID_HANDLE)
  175.     {
  176.      ndbout << "Wrong SQL_HANDLE_HDBC input and -2 appeared. OK!" << endl ;
  177.     }
  178.   else
  179.     ;
  180.     /*
  181.     {
  182.       ndbout << "Input wrong statement handle SQL_HANDLE_DBC" << endl;
  183.       ndbout << "but SQL_SUCCESS_WITH_INFO" << endl;
  184.       ndbout << "and SQL_SUCCESS still appeared. Please check program" << endl;
  185.       return NDBT_FAILED;
  186.     }
  187.    */
  188.   //**********************************
  189.   //** Test4                        **
  190.   //** Input incorrect handle hdesc **
  191.   //**********************************
  192.   strcpy( (char *) SQLStmt, "INSERT INTO Customers (CustID, Name, Address, Phone) VALUES(5, 'Richard', 'V腉8', '56888')");
  193.   pare_retcode = SQLPrepare(pare_hdesc, 
  194.     SQLStmt, 
  195.     SQL_NTS);
  196.   ndbout << endl << "Test 4" << endl;
  197.   if (pare_retcode == SQL_SUCCESS_WITH_INFO || pare_retcode == SQL_SUCCESS)
  198.     {
  199.       FAILURE("Wrong SQL_HANDLE_DESC, but success returned");
  200.     }
  201.   else if (pare_retcode == SQL_INVALID_HANDLE)
  202.     {
  203.      ndbout << "Wrong SQL_HANDLE_DESC input and -2 appeared. OK!" << endl ;
  204.     }
  205.   else 
  206.     ndbout << endl;
  207.     /*
  208.     {
  209.       ndbout << "TEST FAILURE: Input wrong SQL_HANDLE_DESC, " 
  210.      << "but SQL_SUCCESS_WITH_INFO or SQL_SUCCESS was returned." 
  211.      << endl;
  212.       return NDBT_FAILED;
  213.     }
  214.    */
  215.   //****************
  216.   // Free Handles **
  217.   //****************
  218.   SQLDisconnect(pare_hdbc);
  219.   SQLFreeHandle(SQL_HANDLE_STMT, pare_hstmt);
  220.   SQLFreeHandle(SQL_HANDLE_DBC, pare_hdbc);
  221.   SQLFreeHandle(SQL_HANDLE_ENV, pare_henv);
  222.   
  223.   return NDBT_OK;
  224.   
  225. }
  226. void Prepare_DisplayError(SQLSMALLINT pare_HandleType, 
  227.   SQLHSTMT pare_InputHandle)
  228. {
  229.   SQLSMALLINT pare_i = 1;
  230.   SQLRETURN pare_SQLSTATEs;
  231.   
  232.   ndbout << "-------------------------------------------------" << endl;
  233.   ndbout << "Error diagnostics:" << endl;
  234.   
  235.   while ((pare_SQLSTATEs = SQLGetDiagRec(pare_HandleType, 
  236.  pare_InputHandle, 
  237.  pare_i,
  238.  pare_Sqlstate, 
  239.  &pare_NativeError, 
  240.  pare_Msg, 
  241.  sizeof(pare_Msg), 
  242.  &pare_MsgLen)
  243.   ) != SQL_NO_DATA)
  244.     {
  245.       ndbout << "SQLSTATE = " << pare_SQLSTATEs << endl;   
  246.       ndbout << "the HandleType is:" << pare_HandleType << endl;
  247.       ndbout << "the Handle is :" << (long)pare_InputHandle << endl;
  248.       ndbout << "the conn_Msg is: " << (char *) pare_Msg << endl;
  249.       ndbout << "the output state is:" << (char *)pare_Sqlstate << endl; 
  250.       
  251.       pare_i ++;
  252.       break;
  253.     }
  254.   ndbout << "-------------------------------------------------" << endl;
  255. }