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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
environ.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：14k
源码类别：

数据库系统

开发平台：

Unix_Linux

environ.c：源码内容
  2. /* Module:          environ.c
  3.  *
  4.  * Description:     This module contains routines related to 
  5.  *                  the environment, such as storing connection handles,
  6.  *                  and returning errors.
  7.  *
  8.  * Classes:         EnvironmentClass (Functions prefix: "EN_")
  9.  *
  10.  * API functions:   SQLAllocEnv, SQLFreeEnv, SQLError
  11.  *
  12.  * Comments:        See "notice.txt" for copyright and license information.
  13.  *
  14.  */
  16. #include "environ.h"
  17. #include "connection.h"
  18. #include "statement.h"
  19. #include <stdlib.h>
  20. #include <malloc.h>
  22. /* The one instance of the handles */
  23. ConnectionClass *conns[MAX_CONNECTIONS];
  26. RETCODE SQL_API SQLAllocEnv(HENV FAR *phenv)
  27. {
  28. static char *func = "SQLAllocEnv";
  30. mylog("**** in SQLAllocEnv ** n");
  32. *phenv = (HENV) EN_Constructor();
  33. if ( ! *phenv) {
  34. *phenv = SQL_NULL_HENV;
  35. EN_log_error(func, "Error allocating environment", NULL);
  36. return SQL_ERROR;
  37. }
  38.  
  39. mylog("** exit SQLAllocEnv: phenv = %u **n", *phenv);
  40. return SQL_SUCCESS;
  41. }
  43. RETCODE SQL_API SQLFreeEnv(HENV henv)
  44. {
  45. static char *func = "SQLFreeEnv";
  46. EnvironmentClass *env = (EnvironmentClass *) henv;
  48. mylog("**** in SQLFreeEnv: env = %u ** n", env);
  50. if (env && EN_Destructor(env)) {
  51. mylog("   okn");
  52. return SQL_SUCCESS;
  53. }
  55. mylog("    errorn");
  56. EN_log_error(func, "Error freeing environment", env);
  57. return SQL_ERROR;
  58. }
  60. //      Returns the next SQL error information.
  62. RETCODE SQL_API SQLError(
  63.         HENV       henv,
  64.         HDBC       hdbc,
  65.         HSTMT      hstmt,
  66.         UCHAR  FAR *szSqlState,
  67.         SDWORD FAR *pfNativeError,
  68.         UCHAR  FAR *szErrorMsg,
  69.         SWORD      cbErrorMsgMax,
  70.         SWORD  FAR *pcbErrorMsg)
  71. {
  72. char *msg;
  73. int status;
  74.     
  75. mylog("**** SQLError: henv=%u, hdbc=%u, hstmt=%un", henv, hdbc, hstmt);
  77.     if (SQL_NULL_HSTMT != hstmt) {
  78.         // CC: return an error of a hstmt 
  79.         StatementClass *stmt = (StatementClass *) hstmt;
  80.         
  81.         if (SC_get_error(stmt, &status, &msg)) {
  82. mylog("SC_get_error: status = %d, msg = #%s#n", status, msg);
  83.             if (NULL == msg) {
  84.                 if (NULL != szSqlState)
  85.                     strcpy(szSqlState, "00000");
  86.                 if (NULL != pcbErrorMsg)
  87.                     *pcbErrorMsg = 0;
  88.                 if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  89.                     szErrorMsg[0] = '';
  90.                 
  91.                 return SQL_NO_DATA_FOUND;
  92.             }                
  93.             if (NULL != pcbErrorMsg)                
  94.                 *pcbErrorMsg = (SWORD)strlen(msg);
  95.             
  96.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
  97.                 strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
  98.             
  99.             if (NULL != pfNativeError) 
  100.                 *pfNativeError = status;
  101.             
  102.             if (NULL != szSqlState)    
  103.                 
  104.                 switch (status) {
  105.                     // now determine the SQLSTATE to be returned
  106.                 case STMT_TRUNCATED:
  107.                     strcpy(szSqlState, "01004");
  108.                     // data truncated
  109.                     break;
  110.                 case STMT_INFO_ONLY:
  111.                     strcpy(szSqlState, "00000");
  112.                     // just information that is returned, no error
  113.                     break;
  114.                 case STMT_EXEC_ERROR:
  115.                     strcpy(szSqlState, "08S01");
  116.                     // communication link failure
  117.                     break;
  118.                 case STMT_CREATE_TABLE_ERROR:
  119.                     strcpy(szSqlState, "S0001");
  120.                     // table already exists
  121.                     break;
  122.                 case STMT_STATUS_ERROR:
  123.                 case STMT_SEQUENCE_ERROR:
  124.                     strcpy(szSqlState, "S1010");
  125.                     // Function sequence error
  126.                     break;
  127.                 case STMT_NO_MEMORY_ERROR:
  128.                     strcpy(szSqlState, "S1001");
  129.                     // memory allocation failure
  130.                     break;
  131.                 case STMT_COLNUM_ERROR:
  132.                     strcpy(szSqlState, "S1002");
  133.                     // invalid column number
  134.                     break;
  135.                 case STMT_NO_STMTSTRING:
  136.                     strcpy(szSqlState, "S1001");
  137.                     // having no stmtstring is also a malloc problem
  138.                     break;
  139.                 case STMT_ERROR_TAKEN_FROM_BACKEND:
  140.                     strcpy(szSqlState, "S1000");
  141.                     // general error
  142.                     break;
  143.                 case STMT_INTERNAL_ERROR:
  144.                     strcpy(szSqlState, "S1000");
  145.                     // general error
  146.                     break;  
  147. case STMT_ROW_OUT_OF_RANGE:
  148. strcpy(szSqlState, "S1107");
  149. break;
  151. case STMT_OPERATION_CANCELLED:
  152. strcpy(szSqlState, "S1008");
  153. break;
  155.                 case STMT_NOT_IMPLEMENTED_ERROR:
  156.                     strcpy(szSqlState, "S1C00"); // == 'driver not capable'
  157.                     break;
  158.                 case STMT_OPTION_OUT_OF_RANGE_ERROR:
  159.                     strcpy(szSqlState, "S1092");
  160.                     break;
  161.                 case STMT_BAD_PARAMETER_NUMBER_ERROR:
  162.                     strcpy(szSqlState, "S1093");
  163.                     break;
  164.                 case STMT_INVALID_COLUMN_NUMBER_ERROR:
  165.                     strcpy(szSqlState, "S1002");
  166.                     break;
  167.                 case STMT_RESTRICTED_DATA_TYPE_ERROR:
  168.                     strcpy(szSqlState, "07006");
  169.                     break;
  170.                 case STMT_INVALID_CURSOR_STATE_ERROR:
  171.                     strcpy(szSqlState, "24000");
  172.                     break;
  173.                 case STMT_OPTION_VALUE_CHANGED:
  174.                     strcpy(szSqlState, "01S02");
  175.                     break;
  176. case STMT_INVALID_CURSOR_NAME:
  177.                     strcpy(szSqlState, "34000");
  178.                     break;
  179. case STMT_NO_CURSOR_NAME:
  180.                     strcpy(szSqlState, "S1015");
  181.                     break;
  182.                 case STMT_INVALID_ARGUMENT_NO:
  183.                     strcpy(szSqlState, "S1009");
  184.                     // invalid argument value
  185.                     break;
  186. case STMT_INVALID_CURSOR_POSITION:
  187.                     strcpy(szSqlState, "S1109");
  188.                     break;
  189.                 
  190. case STMT_VALUE_OUT_OF_RANGE:
  191. strcpy(szSqlState, "22003");
  192. break;
  194. case STMT_OPERATION_INVALID:
  195. strcpy(szSqlState, "S1011");
  196. break;
  198. default:
  199.                     strcpy(szSqlState, "S1000");
  200.                     // also a general error
  201.                     break;
  202.                 }         
  204. mylog("       szSqlState = '%s', szError='%s'n", szSqlState, szErrorMsg);
  205.             
  206.         } else {
  207.             if (NULL != szSqlState)
  208.                 strcpy(szSqlState, "00000");
  209.             if (NULL != pcbErrorMsg)
  210.                 *pcbErrorMsg = 0;
  211.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  212.                 szErrorMsg[0] = '';
  213.             
  214. mylog("       returning NO_DATA_FOUNDn");
  215.             return SQL_NO_DATA_FOUND;
  216.         }
  217.         return SQL_SUCCESS;    
  218.         
  219.     } else if (SQL_NULL_HDBC != hdbc) {
  220.         ConnectionClass *conn = (ConnectionClass *) hdbc;
  221.         
  222. mylog("calling CC_get_errorn");
  223.         if (CC_get_error(conn, &status, &msg)) {
  224. mylog("CC_get_error: status = %d, msg = #%s#n", status, msg);
  225.             if (NULL == msg) {
  226.                 if (NULL != szSqlState)
  227.                     strcpy(szSqlState, "00000");
  228.                 if (NULL != pcbErrorMsg)
  229.                     *pcbErrorMsg = 0;
  230.                 if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  231.                     szErrorMsg[0] = '';
  232.                 
  233.                 return SQL_NO_DATA_FOUND;
  234.             }                
  235.             
  236.             if (NULL != pcbErrorMsg)
  237.                 *pcbErrorMsg = (SWORD)strlen(msg);
  238.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))    
  239.                 strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
  240.             if (NULL != pfNativeError)    
  241.                 *pfNativeError = status;
  242.             
  243.             if (NULL != szSqlState) 
  244.                 switch(status) {
  245. case STMT_OPTION_VALUE_CHANGED:
  246. case CONN_OPTION_VALUE_CHANGED:
  247.                     strcpy(szSqlState, "01S02");
  248. break;
  249.                 case STMT_TRUNCATED:
  250. case CONN_TRUNCATED:
  251.                     strcpy(szSqlState, "01004");
  252.                     // data truncated
  253.                     break;
  254.                 case CONN_INIREAD_ERROR:
  255.                     strcpy(szSqlState, "IM002");
  256.                     // data source not found
  257.                     break;
  258.                 case CONN_OPENDB_ERROR:
  259.                     strcpy(szSqlState, "08001");
  260.                     // unable to connect to data source
  261.                     break;
  262. case CONN_INVALID_AUTHENTICATION:
  263. case CONN_AUTH_TYPE_UNSUPPORTED:
  264. strcpy(szSqlState, "28000");
  265. break;
  266.                 case CONN_STMT_ALLOC_ERROR:
  267.                     strcpy(szSqlState, "S1001");
  268.                     // memory allocation failure
  269.                     break;
  270.                 case CONN_IN_USE:
  271.                     strcpy(szSqlState, "S1000");
  272.                     // general error
  273.                     break;
  274.                 case CONN_UNSUPPORTED_OPTION:
  275.                     strcpy(szSqlState, "IM001");
  276.                     // driver does not support this function
  277.                 case CONN_INVALID_ARGUMENT_NO:
  278.                     strcpy(szSqlState, "S1009");
  279.                     // invalid argument value
  280.                     break;
  281.                 case CONN_TRANSACT_IN_PROGRES:
  282.                     strcpy(szSqlState, "S1010");
  283.                     // when the user tries to switch commit mode in a transaction
  284.                     // -> function sequence error
  285.                     break;
  286.                 case CONN_NO_MEMORY_ERROR:
  287.                     strcpy(szSqlState, "S1001");
  288.                     break;
  289.                 case CONN_NOT_IMPLEMENTED_ERROR:
  290. case STMT_NOT_IMPLEMENTED_ERROR:
  291.                     strcpy(szSqlState, "S1C00");
  292.                     break;
  294. case CONN_VALUE_OUT_OF_RANGE:
  295. case STMT_VALUE_OUT_OF_RANGE:
  296. strcpy(szSqlState, "22003");
  297. break;
  299.                 default:
  300.                     strcpy(szSqlState, "S1000");
  301.                     // general error
  302.                     break;
  303.                 }
  304.        
  305.         } else {
  306. mylog("CC_Get_error returned nothing.n");
  307.             if (NULL != szSqlState)
  308.                 strcpy(szSqlState, "00000");
  309.             if (NULL != pcbErrorMsg)
  310.                 *pcbErrorMsg = 0;
  311.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  312.                 szErrorMsg[0] = '';
  313.             
  314.             return SQL_NO_DATA_FOUND;
  315.         }
  316.         return SQL_SUCCESS;
  317.         
  318.     } else if (SQL_NULL_HENV != henv) {
  319.         EnvironmentClass *env = (EnvironmentClass *)henv;
  320.         if(EN_get_error(env, &status, &msg)) {
  321. mylog("EN_get_error: status = %d, msg = #%s#n", status, msg);
  322.             if (NULL == msg) {
  323.                 if (NULL != szSqlState)
  324.                     strcpy(szSqlState, "00000");
  325.                 if (NULL != pcbErrorMsg)
  326.                     *pcbErrorMsg = 0;
  327.                 if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  328.                     szErrorMsg[0] = '';
  330.                 return SQL_NO_DATA_FOUND;
  331.             }                
  333.             if (NULL != pcbErrorMsg)                
  334.                 *pcbErrorMsg = (SWORD)strlen(msg);
  335.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
  336.                 strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
  337.             if (NULL != pfNativeError) 
  338.                 *pfNativeError = status;
  339.             
  340.             if(szSqlState) {
  341.                 switch(status) {
  342.                 case ENV_ALLOC_ERROR:
  343.                     // memory allocation failure
  344.                     strcpy(szSqlState, "S1001");
  345.                     break;
  346.                 default:
  347.                     strcpy(szSqlState, "S1000");
  348.                     // general error
  349.                     break;
  350.                 }
  351.             }
  352.         } else {
  353.             if (NULL != szSqlState)
  354.                 strcpy(szSqlState, "00000");
  355.             if (NULL != pcbErrorMsg)
  356.                 *pcbErrorMsg = 0;
  357.             if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  358.                 szErrorMsg[0] = '';
  359.             
  360.             return SQL_NO_DATA_FOUND;
  361.         }
  363.         return SQL_SUCCESS;
  364.     }
  365.     
  366.     if (NULL != szSqlState)
  367.         strcpy(szSqlState, "00000");
  368.     if (NULL != pcbErrorMsg)
  369.         *pcbErrorMsg = 0;
  370.     if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0)) 
  371.         szErrorMsg[0] = '';
  372.     
  373.     return SQL_NO_DATA_FOUND;
  374. }
  377. /*********************************************************************/
  378. /*
  379.  * EnvironmentClass implementation
  380.  */
  384. EnvironmentClass
  385. *EN_Constructor(void)
  386. {
  387. EnvironmentClass *rv;
  389.     rv = (EnvironmentClass *) malloc(sizeof(EnvironmentClass));
  390.     if( rv) {
  391. rv->errormsg = 0;
  392. rv->errornumber = 0;
  393. }
  395.     return rv;
  396. }
  399. char
  400. EN_Destructor(EnvironmentClass *self)
  401. {
  402. int lf;
  403. char rv = 1;
  405. mylog("in EN_Destructor, self=%un", self);
  407.     // the error messages are static strings distributed throughout
  408.     // the source--they should not be freed
  410. /* Free any connections belonging to this environment */
  411. for (lf = 0; lf < MAX_CONNECTIONS; lf++) {
  412. if (conns[lf] && conns[lf]->henv == self)
  413. rv = rv && CC_Destructor(conns[lf]);
  414. }
  416. mylog("exit EN_Destructor: rv = %dn", rv);
  417. return rv;
  418. }
  420. char
  421. EN_get_error(EnvironmentClass *self, int *number, char **message)
  422. {
  423. if(self && self->errormsg && self->errornumber) {
  424. *message = self->errormsg;
  425. *number = self->errornumber;
  426. self->errormsg = 0;
  427. self->errornumber = 0;
  428. return 1;
  429. } else {
  430. return 0;
  431. }
  432. }
  434. char
  435. EN_add_connection(EnvironmentClass *self, ConnectionClass *conn)
  436. {
  437. int i;
  439. mylog("EN_add_connection: self = %u, conn = %un", self, conn);
  441. for (i = 0; i < MAX_CONNECTIONS; i++) {
  442. if ( ! conns[i]) {
  443. conn->henv = self;
  444. conns[i] = conn;
  446. mylog("       added at i =%d, conn->henv = %u, conns[i]->henv = %un", i, conn->henv, conns[i]->henv);
  448. return TRUE;
  449. }
  450. }
  452. return FALSE;
  453. }
  455. char
  456. EN_remove_connection(EnvironmentClass *self, ConnectionClass *conn)
  457. {
  458. int i;
  460. for (i = 0; i < MAX_CONNECTIONS; i++)
  461. if (conns[i] == conn && conns[i]->status != CONN_EXECUTING) {
  462. conns[i] = NULL;
  463. return TRUE;
  464. }
  466. return FALSE;
  467. }
  469. void
  470. EN_log_error(char *func, char *desc, EnvironmentClass *self)
  471. {
  472. if (self) {
  473. qlog("ENVIRON ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'n", func, desc, self->errornumber, self->errormsg);
  474. }
  475. else
  476. qlog("INVALID ENVIRON HANDLE ERROR: func=%s, desc='%s'n", func, desc);
  477. }